Try to reduce false positives more

.
Fix new false positive
2024-08-29 12:48:37 +01:00 · 2024-08-23 16:47:01 +01:00 · 2024-08-23 14:15:03 +01:00 · 2024-08-23 13:34:38 +01:00
275 changed files with 3024 additions and 8567 deletions
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -20,7 +20,7 @@
 			"extensions": [
 				"ms-python.python",
 				"rust-lang.rust-analyzer",
-				"fill-labs.dependi",
+				"serayuzgur.crates",
 				"tamasfe.even-better-toml",
 				"Swellaby.vscode-rust-test-adapter",
 				"charliermarsh.ruff"
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -37,7 +37,7 @@ jobs:
        with:
          fetch-depth: 0

-      - uses: tj-actions/changed-files@v45
+      - uses: tj-actions/changed-files@v44
        id: changed
        with:
          files_yaml: |
--- a/.github/workflows/publish-docs.yml
+++ b/.github/workflows/publish-docs.yml
@@ -34,10 +34,10 @@ jobs:
      - name: "Set docs version"
        run: |
          version="${{ (inputs.plan != '' && fromJson(inputs.plan).announcement_tag) || inputs.ref }}"
-          # if version is missing, use 'latest'
-          if [ -z "$version" ]; then
-            echo "Using 'latest' as version"
-            version="latest"
+          # if version is missing, exit with error
+          if [[ -z "$version" ]]; then
+          echo "Can't build docs without a version."
+          exit 1
          fi

          # Use version as display name for now
@@ -145,7 +145,6 @@ jobs:
          GITHUB_TOKEN: ${{ secrets.ASTRAL_DOCS_PAT }}
        run: |
          branch_name="${{ env.branch_name }}"
-
          # auto-merge the PR if the build was triggered by a release. Manual builds should be reviewed by a human.
          # give the PR a few seconds to be created before trying to auto-merge it
          sleep 10
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -45,7 +45,7 @@ repos:
          )$

  - repo: https://github.com/crate-ci/typos
-    rev: v1.24.3
+    rev: v1.23.6
    hooks:
      - id: typos

@@ -59,7 +59,7 @@ repos:
        pass_filenames: false # This makes it a lot faster

  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.3
+    rev: v0.6.1
    hooks:
      - id: ruff-format
      - id: ruff
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,56 +1,5 @@
 # Changelog

-## 0.6.4
-
-### Preview features
-
- \[`flake8-builtins`\] Use dynamic builtins list based on Python version ([#13172](https://github.com/astral-sh/ruff/pull/13172))
- \[`pydoclint`\] Permit yielding `None` in `DOC402` and `DOC403` ([#13148](https://github.com/astral-sh/ruff/pull/13148))
- \[`pylint`\] Update diagnostic message for `PLW3201` ([#13194](https://github.com/astral-sh/ruff/pull/13194))
- \[`ruff`\] Implement `post-init-default` (`RUF033`) ([#13192](https://github.com/astral-sh/ruff/pull/13192))
- \[`ruff`\] Implement useless if-else (`RUF034`) ([#13218](https://github.com/astral-sh/ruff/pull/13218))
-
-### Rule changes
-
- \[`flake8-pyi`\] Respect `pep8_naming.classmethod-decorators` settings when determining if a method is a classmethod in `custom-type-var-return-type` (`PYI019`) ([#13162](https://github.com/astral-sh/ruff/pull/13162))
- \[`flake8-pyi`\] Teach various rules that annotations might be stringized ([#12951](https://github.com/astral-sh/ruff/pull/12951))
- \[`pylint`\] Avoid `no-self-use` for `attrs`-style validators ([#13166](https://github.com/astral-sh/ruff/pull/13166))
- \[`pylint`\] Recurse into subscript subexpressions when searching for list/dict lookups (`PLR1733`, `PLR1736`) ([#13186](https://github.com/astral-sh/ruff/pull/13186))
- \[`pyupgrade`\] Detect `aiofiles.open` calls in `UP015` ([#13173](https://github.com/astral-sh/ruff/pull/13173))
- \[`pyupgrade`\] Mark `sys.version_info[0] < 3` and similar comparisons as outdated (`UP036`) ([#13175](https://github.com/astral-sh/ruff/pull/13175))
-
-### CLI
-
- Enrich messages of SARIF results ([#13180](https://github.com/astral-sh/ruff/pull/13180))
- Handle singular case for incompatible rules warning in `ruff format` output ([#13212](https://github.com/astral-sh/ruff/pull/13212))
-
-### Bug fixes
-
- \[`pydocstyle`\] Improve heuristics for detecting Google-style docstrings ([#13142](https://github.com/astral-sh/ruff/pull/13142))
- \[`refurb`\] Treat `sep` arguments with effects as unsafe removals (`FURB105`) ([#13165](https://github.com/astral-sh/ruff/pull/13165))
-
-## 0.6.3
-
-### Preview features
-
- \[`flake8-simplify`\] Extend `open-file-with-context-handler` to work with `dbm.sqlite3` (`SIM115`) ([#13104](https://github.com/astral-sh/ruff/pull/13104))
- \[`pycodestyle`\] Disable `E741` in stub files (`.pyi`) ([#13119](https://github.com/astral-sh/ruff/pull/13119))
- \[`pydoclint`\] Avoid `DOC201` on explicit returns in functions that only return `None` ([#13064](https://github.com/astral-sh/ruff/pull/13064))
-
-### Rule changes
-
- \[`flake8-async`\] Disable check for `asyncio` before Python 3.11 (`ASYNC109`) ([#13023](https://github.com/astral-sh/ruff/pull/13023))
-
-### Bug fixes
-
- \[`FastAPI`\] Avoid introducing invalid syntax in fix for `fast-api-non-annotated-dependency` (`FAST002`) ([#13133](https://github.com/astral-sh/ruff/pull/13133))
- \[`flake8-implicit-str-concat`\] Normalize octals before merging concatenated strings in `single-line-implicit-string-concatenation` (`ISC001`) ([#13118](https://github.com/astral-sh/ruff/pull/13118))
- \[`flake8-pytest-style`\] Improve help message for `pytest-incorrect-mark-parentheses-style` (`PT023`) ([#13092](https://github.com/astral-sh/ruff/pull/13092))
- \[`pylint`\] Avoid autofix for calls that aren't `min` or `max` as starred expression (`PLW3301`) ([#13089](https://github.com/astral-sh/ruff/pull/13089))
- \[`ruff`\] Add `datetime.time`, `datetime.tzinfo`, and `datetime.timezone` as immutable function calls (`RUF009`) ([#13109](https://github.com/astral-sh/ruff/pull/13109))
- \[`ruff`\] Extend comment deletion for `RUF100` to include trailing text from `noqa` directives while preserving any following comments on the same line, if any ([#13105](https://github.com/astral-sh/ruff/pull/13105))
- Fix dark theme on initial page load for the Ruff playground ([#13077](https://github.com/astral-sh/ruff/pull/13077))
-
 ## 0.6.2

 ### Preview features
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -530,8 +530,6 @@ You can run the benchmarks with
 cargo benchmark
 ```

-`cargo benchmark` is an alias for `cargo bench -p ruff_benchmark --bench linter --bench formatter --`
-
 #### Benchmark-driven Development

 Ruff uses [Criterion.rs](https://bheisler.github.io/criterion.rs/book/) for benchmarks. You can use
@@ -570,7 +568,7 @@ cargo install critcmp

 #### Tips

- Use `cargo bench -p ruff_benchmark <filter>` to only run specific benchmarks. For example: `cargo bench -p ruff_benchmark lexer`
+- Use `cargo bench -p ruff_benchmark <filter>` to only run specific benchmarks. For example: `cargo benchmark lexer`
    to only run the lexer benchmarks.
 - Use `cargo bench -p ruff_benchmark -- --quiet` for a more cleaned up output (without statistical relevance)
 - Use `cargo bench -p ruff_benchmark -- --quick` to get faster results (more prone to noise)
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1256,9 +1256,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.158"
+version = "0.2.157"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8adc4bb1803a324070e64a98ae98f38934d91957a99cfb3a43dcbc01bc56439"
+checksum = "374af5f94e54fa97cf75e945cce8a6b201e88a1a07e688b47dfd2a59c66dbd86"

 [[package]]
 name = "libcst"
@@ -1803,9 +1803,9 @@ dependencies = [

 [[package]]
 name = "quick-junit"
-version = "0.5.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62ffd2f9a162cfae131bed6d9d1ed60adced33be340a94f96952897d7cb0c240"
+checksum = "cfc1a6a5406a114913df2df8507998c755311b55b78584bed5f6e88f6417c4d4"
 dependencies = [
 "chrono",
 "indexmap",
@@ -1818,18 +1818,18 @@ dependencies = [

 [[package]]
 name = "quick-xml"
-version = "0.36.1"
+version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96a05e2e8efddfa51a84ca47cec303fac86c8541b686d37cac5efc0e094417bc"
+checksum = "1004a344b30a54e2ee58d66a71b32d2db2feb0a31f9a2d302bf0536f15de2a33"
 dependencies = [
 "memchr",
 ]

 [[package]]
 name = "quote"
-version = "1.0.37"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
 dependencies = [
 "proc-macro2",
 ]
@@ -1989,7 +1989,6 @@ dependencies = [
 "anyhow",
 "crossbeam",
 "notify",
- "rayon",
 "red_knot_python_semantic",
 "ruff_cache",
 "ruff_db",
@@ -1997,7 +1996,6 @@ dependencies = [
 "ruff_text_size",
 "rustc-hash 2.0.0",
 "salsa",
- "tempfile",
 "tracing",
 ]

@@ -2091,7 +2089,7 @@ dependencies = [

 [[package]]
 name = "ruff"
-version = "0.6.4"
+version = "0.6.2"
 dependencies = [
 "anyhow",
 "argfile",
@@ -2149,7 +2147,6 @@ dependencies = [
 "criterion",
 "mimalloc",
 "once_cell",
- "rayon",
 "red_knot_python_semantic",
 "red_knot_workspace",
 "ruff_db",
@@ -2284,7 +2281,7 @@ dependencies = [

 [[package]]
 name = "ruff_linter"
-version = "0.6.4"
+version = "0.6.2"
 dependencies = [
 "aho-corasick",
 "annotate-snippets 0.9.2",
@@ -2604,7 +2601,7 @@ dependencies = [

 [[package]]
 name = "ruff_wasm"
-version = "0.6.4"
+version = "0.6.2"
 dependencies = [
 "console_error_panic_hook",
 "console_log",
@@ -2831,9 +2828,9 @@ checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"

 [[package]]
 name = "serde"
-version = "1.0.209"
+version = "1.0.208"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
+checksum = "cff085d2cb684faa248efb494c39b68e522822ac0de72ccf08109abde717cfb2"
 dependencies = [
 "serde_derive",
 ]
@@ -2851,9 +2848,9 @@ dependencies = [

 [[package]]
 name = "serde_derive"
-version = "1.0.209"
+version = "1.0.208"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
+checksum = "24008e81ff7613ed8e5ba0cfaf24e2c2f1e5b8a0495711e44fcd4882fca62bcf"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -2873,9 +2870,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.127"
+version = "1.0.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
+checksum = "83c8e735a073ccf5be70aa8066aa984eaf2fa000db6c8d0100ae605b366d31ed"
 dependencies = [
 "itoa",
 "memchr",
@@ -3034,9 +3031,9 @@ checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"

 [[package]]
 name = "syn"
-version = "2.0.76"
+version = "2.0.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578e081a14e0cefc3279b0472138c513f37b41a08d5a3cca9b6e4e8ceb6cd525"
+checksum = "f6af063034fc1935ede7be0122941bafa9bacb949334d090b77ca98b5817c7d9"
 dependencies = [
 "proc-macro2",
 "quote",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -102,7 +102,7 @@ pep440_rs = { version = "0.6.0", features = ["serde"] }
 pretty_assertions = "1.3.0"
 proc-macro2 = { version = "1.0.79" }
 pyproject-toml = { version = "0.9.0" }
-quick-junit = { version = "0.5.0" }
+quick-junit = { version = "0.4.0" }
 quote = { version = "1.0.23" }
 rand = { version = "0.8.5" }
 rayon = { version = "1.10.0" }
--- a/README.md
+++ b/README.md
@@ -110,7 +110,7 @@ For more, see the [documentation](https://docs.astral.sh/ruff/).
 1. [Who's Using Ruff?](#whos-using-ruff)
 1. [License](#license)

-## Getting Started<a id="getting-started"></a>
+## Getting Started

 For more, see the [documentation](https://docs.astral.sh/ruff/).

@@ -136,8 +136,8 @@ curl -LsSf https://astral.sh/ruff/install.sh | sh
 powershell -c "irm https://astral.sh/ruff/install.ps1 | iex"

 # For a specific version.
-curl -LsSf https://astral.sh/ruff/0.6.4/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.6.4/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.6.2/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.6.2/install.ps1 | iex"
 ```

 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -170,7 +170,7 @@ Ruff can also be used as a [pre-commit](https://pre-commit.com/) hook via [`ruff
 ```yaml
 - repo: https://github.com/astral-sh/ruff-pre-commit
  # Ruff version.
-  rev: v0.6.4
+  rev: v0.6.2
  hooks:
    # Run the linter.
    - id: ruff
@@ -195,7 +195,7 @@ jobs:
      - uses: chartboost/ruff-action@v1
 ```

-### Configuration<a id="configuration"></a>
+### Configuration

 Ruff can be configured through a `pyproject.toml`, `ruff.toml`, or `.ruff.toml` file (see:
 [_Configuration_](https://docs.astral.sh/ruff/configuration/), or [_Settings_](https://docs.astral.sh/ruff/settings/)
@@ -291,7 +291,7 @@ features that may change prior to stabilization.
 See `ruff help` for more on Ruff's top-level commands, or `ruff help check` and `ruff help format`
 for more on the linting and formatting commands, respectively.

-## Rules<a id="rules"></a>
+## Rules

 <!-- Begin section: Rules -->

@@ -367,21 +367,21 @@ quality tools, including:

 For a complete enumeration of the supported rules, see [_Rules_](https://docs.astral.sh/ruff/rules/).

-## Contributing<a id="contributing"></a>
+## Contributing

 Contributions are welcome and highly appreciated. To get started, check out the
 [**contributing guidelines**](https://docs.astral.sh/ruff/contributing/).

 You can also join us on [**Discord**](https://discord.com/invite/astral-sh).

-## Support<a id="support"></a>
+## Support

 Having trouble? Check out the existing issues on [**GitHub**](https://github.com/astral-sh/ruff/issues),
 or feel free to [**open a new one**](https://github.com/astral-sh/ruff/issues/new).

 You can also ask for help on [**Discord**](https://discord.com/invite/astral-sh).

-## Acknowledgements<a id="acknowledgements"></a>
+## Acknowledgements

 Ruff's linter draws on both the APIs and implementation details of many other
 tools in the Python ecosystem, especially [Flake8](https://github.com/PyCQA/flake8), [Pyflakes](https://github.com/PyCQA/pyflakes),
@@ -405,7 +405,7 @@ Ruff is the beneficiary of a large number of [contributors](https://github.com/a

 Ruff is released under the MIT license.

-## Who's Using Ruff?<a id="whos-using-ruff"></a>
+## Who's Using Ruff?

 Ruff is used by a number of major open-source projects and companies, including:

@@ -524,7 +524,7 @@ If you're using Ruff, consider adding the Ruff badge to your project's `README.m
 <a href="https://github.com/astral-sh/ruff"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json" alt="Ruff" style="max-width:100%;"></a>
 ```

-## License<a id="license"></a>
+## License

 This repository is licensed under the [MIT License](https://github.com/astral-sh/ruff/blob/main/LICENSE)

--- a/crates/red_knot/docs/tracing.md
+++ b/crates/red_knot/docs/tracing.md
@@ -13,17 +13,12 @@ The CLI supports different verbosity levels.
 - `-vv` activates `debug!` and timestamps: This should be enough information to get to the bottom of bug reports. When you're processing many packages or files, you'll get pages and pages of output, but each line is link to a specific action or state change.
 - `-vvv` activates `trace!` (only in debug builds) and shows tracing-spans: At this level, you're logging everything. Most of this is wasted, it's really slow, we dump e.g. the entire resolution graph. Only useful to developers, and you almost certainly want to use `RED_KNOT_LOG` to filter it down to the area your investigating.

-## Better logging with `RED_KNOT_LOG` and `RAYON_NUM_THREADS`
+## `RED_KNOT_LOG`

 By default, the CLI shows messages from the `ruff` and `red_knot` crates. Tracing messages from other crates are not shown.
 The `RED_KNOT_LOG` environment variable allows you to customize which messages are shown by specifying one
 or more [filter directives](https://docs.rs/tracing-subscriber/latest/tracing_subscriber/filter/struct.EnvFilter.html#directives).

-The `RAYON_NUM_THREADS` environment variable, meanwhile, can be used to control the level of concurrency red-knot uses.
-By default, red-knot will attempt to parallelize its work so that multiple files are checked simultaneously,
-but this can result in a confused logging output where messages from different threads are intertwined.
-To switch off concurrency entirely and have more readable logs, use `RAYON_NUM_THREADS=1`.
-
 ### Examples

 #### Show all debug messages
--- a/crates/red_knot_python_semantic/src/ast_node_ref.rs
+++ b/crates/red_knot_python_semantic/src/ast_node_ref.rs
@@ -31,10 +31,10 @@ impl<T> AstNodeRef<T> {
    /// which the `AstNodeRef` belongs.
    ///
    /// ## Safety
-    ///
    /// Dereferencing the `node` can result in undefined behavior if `parsed` isn't the
    /// [`ParsedModule`] to which `node` belongs. It's the caller's responsibility to ensure that
    /// the invariant `node belongs to parsed` is upheld.
+
    pub(super) unsafe fn new(parsed: ParsedModule, node: &T) -> Self {
        Self {
            _parsed: parsed,
--- a/crates/red_knot_python_semantic/src/builtins.rs
+++ b/crates/red_knot_python_semantic/src/builtins.rs
@@ -0,0 +1,16 @@
+use crate::module_name::ModuleName;
+use crate::module_resolver::resolve_module;
+use crate::semantic_index::global_scope;
+use crate::semantic_index::symbol::ScopeId;
+use crate::Db;
+
+/// Salsa query to get the builtins scope.
+///
+/// Can return None if a custom typeshed is used that is missing `builtins.pyi`.
+#[salsa::tracked]
+pub(crate) fn builtins_scope(db: &dyn Db) -> Option<ScopeId<'_>> {
+    let builtins_name =
+        ModuleName::new_static("builtins").expect("Expected 'builtins' to be a valid module name");
+    let builtins_file = resolve_module(db, builtins_name)?.file();
+    Some(global_scope(db, builtins_file))
+}
--- a/crates/red_knot_python_semantic/src/lib.rs
+++ b/crates/red_knot_python_semantic/src/lib.rs
@@ -10,6 +10,7 @@ pub use python_version::PythonVersion;
 pub use semantic_model::{HasTy, SemanticModel};

 pub mod ast_node_ref;
+mod builtins;
 mod db;
 mod module_name;
 mod module_resolver;
@@ -19,8 +20,6 @@ mod python_version;
 pub mod semantic_index;
 mod semantic_model;
 pub(crate) mod site_packages;
-mod stdlib;
 pub mod types;

 type FxOrderSet<V> = ordermap::set::OrderSet<V, BuildHasherDefault<FxHasher>>;
-type FxOrderMap<K, V> = ordermap::map::OrderMap<K, V, BuildHasherDefault<FxHasher>>;
--- a/crates/red_knot_python_semantic/src/semantic_index.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index.rs
@@ -575,7 +575,7 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
        let index = semantic_index(&db, file);
        let global_table = symbol_table(&db, global_scope(&db, file));

-        assert_eq!(names(&global_table), vec!["str", "int", "f"]);
+        assert_eq!(names(&global_table), vec!["f", "str", "int"]);

        let [(function_scope_id, _function_scope)] = index
            .child_scopes(FileScopeId::global())
@@ -666,7 +666,7 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
    fn comprehension_scope() {
        let TestCase { db, file } = test_case(
            "
-[x for x, y in iter1]
+[x for x in iter1]
 ",
        );

@@ -690,22 +690,7 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):

        let comprehension_symbol_table = index.symbol_table(comprehension_scope_id);

-        assert_eq!(names(&comprehension_symbol_table), vec!["x", "y"]);
-
-        let use_def = index.use_def_map(comprehension_scope_id);
-        for name in ["x", "y"] {
-            let definition = use_def
-                .first_public_definition(
-                    comprehension_symbol_table
-                        .symbol_id_by_name(name)
-                        .expect("symbol exists"),
-                )
-                .unwrap();
-            assert!(matches!(
-                definition.node(&db),
-                DefinitionKind::Comprehension(_)
-            ));
-        }
+        assert_eq!(names(&comprehension_symbol_table), vec!["x"]);
    }

    /// Test case to validate that the `x` variable used in the comprehension is referencing the
@@ -745,8 +730,8 @@ def f(a: str, /, b: str, c: int = 1, *args, d: int = 2, **kwargs):
        let DefinitionKind::Comprehension(comprehension) = definition.node(&db) else {
            panic!("expected generator definition")
        };
-        let target = comprehension.target();
-        let name = target.id().as_str();
+        let ast::Comprehension { target, .. } = comprehension.node();
+        let name = target.as_name_expr().unwrap().id().as_str();

        assert_eq!(name, "x");
        assert_eq!(target.range(), TextRange::new(23.into(), 24.into()));
@@ -1088,7 +1073,7 @@ def x():
    }

    #[test]
-    fn match_stmt() {
+    fn match_stmt_symbols() {
        let TestCase { db, file } = test_case(
            "
 match subject:
@@ -1102,124 +1087,12 @@ match subject:
 ",
        );

-        let global_scope_id = global_scope(&db, file);
-        let global_table = symbol_table(&db, global_scope_id);
+        let global_table = symbol_table(&db, global_scope(&db, file));

        assert!(global_table.symbol_by_name("Foo").unwrap().is_used());
        assert_eq!(
            names(&global_table),
-            vec!["subject", "a", "b", "c", "d", "e", "f", "g", "h", "Foo", "i", "j", "k", "l"]
+            vec!["subject", "a", "b", "c", "d", "f", "e", "h", "g", "Foo", "i", "j", "k", "l"]
        );
-
-        let use_def = use_def_map(&db, global_scope_id);
-        for (name, expected_index) in [
-            ("a", 0),
-            ("b", 0),
-            ("c", 1),
-            ("d", 2),
-            ("e", 0),
-            ("f", 1),
-            ("g", 0),
-            ("h", 1),
-            ("i", 0),
-            ("j", 1),
-            ("k", 0),
-            ("l", 1),
-        ] {
-            let definition = use_def
-                .first_public_definition(
-                    global_table.symbol_id_by_name(name).expect("symbol exists"),
-                )
-                .expect("Expected with item definition for {name}");
-            if let DefinitionKind::MatchPattern(pattern) = definition.node(&db) {
-                assert_eq!(pattern.index(), expected_index);
-            } else {
-                panic!("Expected match pattern definition for {name}");
-            }
-        }
-    }
-
-    #[test]
-    fn nested_match_case() {
-        let TestCase { db, file } = test_case(
-            "
-match 1:
-    case first:
-        match 2:
-            case second:
-                pass
-",
-        );
-
-        let global_scope_id = global_scope(&db, file);
-        let global_table = symbol_table(&db, global_scope_id);
-
-        assert_eq!(names(&global_table), vec!["first", "second"]);
-
-        let use_def = use_def_map(&db, global_scope_id);
-        for (name, expected_index) in [("first", 0), ("second", 0)] {
-            let definition = use_def
-                .first_public_definition(
-                    global_table.symbol_id_by_name(name).expect("symbol exists"),
-                )
-                .expect("Expected with item definition for {name}");
-            if let DefinitionKind::MatchPattern(pattern) = definition.node(&db) {
-                assert_eq!(pattern.index(), expected_index);
-            } else {
-                panic!("Expected match pattern definition for {name}");
-            }
-        }
-    }
-
-    #[test]
-    fn for_loops_single_assignment() {
-        let TestCase { db, file } = test_case("for x in a: pass");
-        let scope = global_scope(&db, file);
-        let global_table = symbol_table(&db, scope);
-
-        assert_eq!(&names(&global_table), &["a", "x"]);
-
-        let use_def = use_def_map(&db, scope);
-        let definition = use_def
-            .first_public_definition(global_table.symbol_id_by_name("x").unwrap())
-            .unwrap();
-
-        assert!(matches!(definition.node(&db), DefinitionKind::For(_)));
-    }
-
-    #[test]
-    fn for_loops_simple_unpacking() {
-        let TestCase { db, file } = test_case("for (x, y) in a: pass");
-        let scope = global_scope(&db, file);
-        let global_table = symbol_table(&db, scope);
-
-        assert_eq!(&names(&global_table), &["a", "x", "y"]);
-
-        let use_def = use_def_map(&db, scope);
-        let x_definition = use_def
-            .first_public_definition(global_table.symbol_id_by_name("x").unwrap())
-            .unwrap();
-        let y_definition = use_def
-            .first_public_definition(global_table.symbol_id_by_name("y").unwrap())
-            .unwrap();
-
-        assert!(matches!(x_definition.node(&db), DefinitionKind::For(_)));
-        assert!(matches!(y_definition.node(&db), DefinitionKind::For(_)));
-    }
-
-    #[test]
-    fn for_loops_complex_unpacking() {
-        let TestCase { db, file } = test_case("for [((a,) b), (c, d)] in e: pass");
-        let scope = global_scope(&db, file);
-        let global_table = symbol_table(&db, scope);
-
-        assert_eq!(&names(&global_table), &["e", "a", "b", "c", "d"]);
-
-        let use_def = use_def_map(&db, scope);
-        let definition = use_def
-            .first_public_definition(global_table.symbol_id_by_name("a").unwrap())
-            .unwrap();
-
-        assert!(matches!(definition.node(&db), DefinitionKind::For(_)));
    }
 }
--- a/crates/red_knot_python_semantic/src/semantic_index/builder.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/builder.rs
@@ -15,7 +15,7 @@ use crate::semantic_index::ast_ids::node_key::ExpressionNodeKey;
 use crate::semantic_index::ast_ids::AstIdsBuilder;
 use crate::semantic_index::definition::{
    AssignmentDefinitionNodeRef, ComprehensionDefinitionNodeRef, Definition, DefinitionNodeKey,
-    DefinitionNodeRef, ForStmtDefinitionNodeRef, ImportFromDefinitionNodeRef,
+    DefinitionNodeRef, ImportFromDefinitionNodeRef,
 };
 use crate::semantic_index::expression::Expression;
 use crate::semantic_index::symbol::{
@@ -26,7 +26,7 @@ use crate::semantic_index::use_def::{FlowSnapshot, UseDefMapBuilder};
 use crate::semantic_index::SemanticIndex;
 use crate::Db;

-use super::definition::{MatchPatternDefinitionNodeRef, WithItemDefinitionNodeRef};
+use super::definition::WithItemDefinitionNodeRef;

 pub(super) struct SemanticIndexBuilder<'db> {
    // Builder state
@@ -36,8 +36,6 @@ pub(super) struct SemanticIndexBuilder<'db> {
    scope_stack: Vec<FileScopeId>,
    /// The assignment we're currently visiting.
    current_assignment: Option<CurrentAssignment<'db>>,
-    /// The match case we're currently visiting.
-    current_match_case: Option<CurrentMatchCase<'db>>,
    /// Flow states at each `break` in the current loop.
    loop_break_states: Vec<FlowSnapshot>,

@@ -61,7 +59,6 @@ impl<'db> SemanticIndexBuilder<'db> {
            module: parsed,
            scope_stack: Vec::new(),
            current_assignment: None,
-            current_match_case: None,
            loop_break_states: vec![],

            scopes: IndexVec::new(),
@@ -193,11 +190,8 @@ impl<'db> SemanticIndexBuilder<'db> {
            countme::Count::default(),
        );

-        let existing_definition = self
-            .definitions_by_node
+        self.definitions_by_node
            .insert(definition_node.key(), definition);
-        debug_assert_eq!(existing_definition, None);
-
        self.current_use_def_map_mut()
            .record_definition(symbol, definition);

@@ -288,7 +282,6 @@ impl<'db> SemanticIndexBuilder<'db> {

        // The `iter` of the first generator is evaluated in the outer scope, while all subsequent
        // nodes are evaluated in the inner scope.
-        self.add_standalone_expression(&generator.iter);
        self.visit_expr(&generator.iter);
        self.push_scope(scope);

@@ -304,7 +297,6 @@ impl<'db> SemanticIndexBuilder<'db> {
        }

        for generator in generators_iter {
-            self.add_standalone_expression(&generator.iter);
            self.visit_expr(&generator.iter);

            self.current_assignment = Some(CurrentAssignment::Comprehension {
@@ -330,11 +322,10 @@ impl<'db> SemanticIndexBuilder<'db> {
            // Insert a mapping from the parameter to the same definition.
            // This ensures that calling `HasTy::ty` on the inner parameter returns
            // a valid type (and doesn't panic)
-            let existing_definition = self.definitions_by_node.insert(
+            self.definitions_by_node.insert(
                DefinitionNodeRef::from(AnyParameterRef::Variadic(&with_default.parameter)).key(),
                definition,
            );
-            debug_assert_eq!(existing_definition, None);
        }
    }

@@ -401,6 +392,20 @@ where
                    self.visit_decorator(decorator);
                }

+                let symbol = self
+                    .add_or_update_symbol(function_def.name.id.clone(), SymbolFlags::IS_DEFINED);
+                self.add_definition(symbol, function_def);
+
+                // The default value of the parameters needs to be evaluated in the
+                // enclosing scope.
+                for default in function_def
+                    .parameters
+                    .iter_non_variadic_params()
+                    .filter_map(|param| param.default.as_deref())
+                {
+                    self.visit_expr(default);
+                }
+
                self.with_type_params(
                    NodeWithScopeRef::FunctionTypeParameters(function_def),
                    function_def.type_params.as_deref(),
@@ -421,21 +426,6 @@ where
                        builder.pop_scope()
                    },
                );
-                // The default value of the parameters needs to be evaluated in the
-                // enclosing scope.
-                for default in function_def
-                    .parameters
-                    .iter_non_variadic_params()
-                    .filter_map(|param| param.default.as_deref())
-                {
-                    self.visit_expr(default);
-                }
-                // The symbol for the function name itself has to be evaluated
-                // at the end to match the runtime evaluation of parameter defaults
-                // and return-type annotations.
-                let symbol = self
-                    .add_or_update_symbol(function_def.name.id.clone(), SymbolFlags::IS_DEFINED);
-                self.add_definition(symbol, function_def);
            }
            ast::Stmt::ClassDef(class) => {
                for decorator in &class.decorator_list {
@@ -588,38 +578,6 @@ where
            ast::Stmt::Break(_) => {
                self.loop_break_states.push(self.flow_snapshot());
            }
-
-            ast::Stmt::For(
-                for_stmt @ ast::StmtFor {
-                    range: _,
-                    is_async: _,
-                    target,
-                    iter,
-                    body,
-                    orelse,
-                },
-            ) => {
-                // TODO add control flow similar to `ast::Stmt::While` above
-                self.add_standalone_expression(iter);
-                self.visit_expr(iter);
-                debug_assert!(self.current_assignment.is_none());
-                self.current_assignment = Some(for_stmt.into());
-                self.visit_expr(target);
-                self.current_assignment = None;
-                self.visit_body(body);
-                self.visit_body(orelse);
-            }
-            ast::Stmt::Match(ast::StmtMatch {
-                subject,
-                cases,
-                range: _,
-            }) => {
-                self.add_standalone_expression(subject);
-                self.visit_expr(subject);
-                for case in cases {
-                    self.visit_match_case(case);
-                }
-            }
            _ => {
                walk_stmt(self, stmt);
            }
@@ -666,16 +624,6 @@ where
                        Some(CurrentAssignment::AugAssign(aug_assign)) => {
                            self.add_definition(symbol, aug_assign);
                        }
-                        Some(CurrentAssignment::For(node)) => {
-                            self.add_definition(
-                                symbol,
-                                ForStmtDefinitionNodeRef {
-                                    iterable: &node.iter,
-                                    target: name_node,
-                                    is_async: node.is_async,
-                                },
-                            );
-                        }
                        Some(CurrentAssignment::Named(named)) => {
                            // TODO(dhruvmanila): If the current scope is a comprehension, then the
                            // named expression is implicitly nonlocal. This is yet to be
@@ -685,11 +633,7 @@ where
                        Some(CurrentAssignment::Comprehension { node, first }) => {
                            self.add_definition(
                                symbol,
-                                ComprehensionDefinitionNodeRef {
-                                    iterable: &node.iter,
-                                    target: name_node,
-                                    first,
-                                },
+                                ComprehensionDefinitionNodeRef { node, first },
                            );
                        }
                        Some(CurrentAssignment::WithItem(with_item)) => {
@@ -819,7 +763,7 @@ where
        }
    }

-    fn visit_parameters(&mut self, parameters: &'ast ast::Parameters) {
+    fn visit_parameters(&mut self, parameters: &'ast ruff_python_ast::Parameters) {
        // Intentionally avoid walking default expressions, as we handle them in the enclosing
        // scope.
        for parameter in parameters.iter().map(ast::AnyParameterRef::as_parameter) {
@@ -827,58 +771,23 @@ where
        }
    }

-    fn visit_match_case(&mut self, match_case: &'ast ast::MatchCase) {
-        debug_assert!(self.current_match_case.is_none());
-        self.current_match_case = Some(CurrentMatchCase::new(&match_case.pattern));
-        self.visit_pattern(&match_case.pattern);
-        self.current_match_case = None;
-
-        if let Some(expr) = &match_case.guard {
-            self.visit_expr(expr);
-        }
-        self.visit_body(&match_case.body);
-    }
-
    fn visit_pattern(&mut self, pattern: &'ast ast::Pattern) {
-        if let ast::Pattern::MatchStar(ast::PatternMatchStar {
-            name: Some(name),
-            range: _,
-        }) = pattern
-        {
-            let symbol = self.add_or_update_symbol(name.id().clone(), SymbolFlags::IS_DEFINED);
-            let state = self.current_match_case.as_ref().unwrap();
-            self.add_definition(
-                symbol,
-                MatchPatternDefinitionNodeRef {
-                    pattern: state.pattern,
-                    identifier: name,
-                    index: state.index,
-                },
-            );
-        }
-
-        walk_pattern(self, pattern);
-
        if let ast::Pattern::MatchAs(ast::PatternMatchAs {
            name: Some(name), ..
        })
+        | ast::Pattern::MatchStar(ast::PatternMatchStar {
+            name: Some(name),
+            range: _,
+        })
        | ast::Pattern::MatchMapping(ast::PatternMatchMapping {
            rest: Some(name), ..
        }) = pattern
        {
-            let symbol = self.add_or_update_symbol(name.id().clone(), SymbolFlags::IS_DEFINED);
-            let state = self.current_match_case.as_ref().unwrap();
-            self.add_definition(
-                symbol,
-                MatchPatternDefinitionNodeRef {
-                    pattern: state.pattern,
-                    identifier: name,
-                    index: state.index,
-                },
-            );
+            // TODO(dhruvmanila): Add definition
+            self.add_or_update_symbol(name.id.clone(), SymbolFlags::IS_DEFINED);
        }

-        self.current_match_case.as_mut().unwrap().index += 1;
+        walk_pattern(self, pattern);
    }
 }

@@ -887,7 +796,6 @@ enum CurrentAssignment<'a> {
    Assign(&'a ast::StmtAssign),
    AnnAssign(&'a ast::StmtAnnAssign),
    AugAssign(&'a ast::StmtAugAssign),
-    For(&'a ast::StmtFor),
    Named(&'a ast::ExprNamed),
    Comprehension {
        node: &'a ast::Comprehension,
@@ -914,12 +822,6 @@ impl<'a> From<&'a ast::StmtAugAssign> for CurrentAssignment<'a> {
    }
 }

-impl<'a> From<&'a ast::StmtFor> for CurrentAssignment<'a> {
-    fn from(value: &'a ast::StmtFor) -> Self {
-        Self::For(value)
-    }
-}
-
 impl<'a> From<&'a ast::ExprNamed> for CurrentAssignment<'a> {
    fn from(value: &'a ast::ExprNamed) -> Self {
        Self::Named(value)
@@ -931,27 +833,3 @@ impl<'a> From<&'a ast::WithItem> for CurrentAssignment<'a> {
        Self::WithItem(value)
    }
 }
-
-struct CurrentMatchCase<'a> {
-    /// The pattern that's part of the current match case.
-    pattern: &'a ast::Pattern,
-
-    /// The index of the sub-pattern that's being currently visited within the pattern.
-    ///
-    /// For example:
-    /// ```py
-    /// match subject:
-    ///     case a as b: ...
-    ///     case [a, b]: ...
-    ///     case a | b: ...
-    /// ```
-    ///
-    /// In all of the above cases, the index would be 0 for `a` and 1 for `b`.
-    index: u32,
-}
-
-impl<'a> CurrentMatchCase<'a> {
-    fn new(pattern: &'a ast::Pattern) -> Self {
-        Self { pattern, index: 0 }
-    }
-}
--- a/crates/red_knot_python_semantic/src/semantic_index/definition.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/definition.rs
@@ -39,7 +39,6 @@ impl<'db> Definition<'db> {
 pub(crate) enum DefinitionNodeRef<'a> {
    Import(&'a ast::Alias),
    ImportFrom(ImportFromDefinitionNodeRef<'a>),
-    For(ForStmtDefinitionNodeRef<'a>),
    Function(&'a ast::StmtFunctionDef),
    Class(&'a ast::StmtClassDef),
    NamedExpression(&'a ast::ExprNamed),
@@ -49,7 +48,6 @@ pub(crate) enum DefinitionNodeRef<'a> {
    Comprehension(ComprehensionDefinitionNodeRef<'a>),
    Parameter(ast::AnyParameterRef<'a>),
    WithItem(WithItemDefinitionNodeRef<'a>),
-    MatchPattern(MatchPatternDefinitionNodeRef<'a>),
 }

 impl<'a> From<&'a ast::StmtFunctionDef> for DefinitionNodeRef<'a> {
@@ -94,12 +92,6 @@ impl<'a> From<ImportFromDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
    }
 }

-impl<'a> From<ForStmtDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
-    fn from(value: ForStmtDefinitionNodeRef<'a>) -> Self {
-        Self::For(value)
-    }
-}
-
 impl<'a> From<AssignmentDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
    fn from(node_ref: AssignmentDefinitionNodeRef<'a>) -> Self {
        Self::Assignment(node_ref)
@@ -124,12 +116,6 @@ impl<'a> From<ast::AnyParameterRef<'a>> for DefinitionNodeRef<'a> {
    }
 }

-impl<'a> From<MatchPatternDefinitionNodeRef<'a>> for DefinitionNodeRef<'a> {
-    fn from(node: MatchPatternDefinitionNodeRef<'a>) -> Self {
-        Self::MatchPattern(node)
-    }
-}
-
 #[derive(Copy, Clone, Debug)]
 pub(crate) struct ImportFromDefinitionNodeRef<'a> {
    pub(crate) node: &'a ast::StmtImportFrom,
@@ -148,31 +134,12 @@ pub(crate) struct WithItemDefinitionNodeRef<'a> {
    pub(crate) target: &'a ast::ExprName,
 }

-#[derive(Copy, Clone, Debug)]
-pub(crate) struct ForStmtDefinitionNodeRef<'a> {
-    pub(crate) iterable: &'a ast::Expr,
-    pub(crate) target: &'a ast::ExprName,
-    pub(crate) is_async: bool,
-}
-
 #[derive(Copy, Clone, Debug)]
 pub(crate) struct ComprehensionDefinitionNodeRef<'a> {
-    pub(crate) iterable: &'a ast::Expr,
-    pub(crate) target: &'a ast::ExprName,
+    pub(crate) node: &'a ast::Comprehension,
    pub(crate) first: bool,
 }

-#[derive(Copy, Clone, Debug)]
-pub(crate) struct MatchPatternDefinitionNodeRef<'a> {
-    /// The outermost pattern node in which the identifier being defined occurs.
-    pub(crate) pattern: &'a ast::Pattern,
-    /// The identifier being defined.
-    pub(crate) identifier: &'a ast::Identifier,
-    /// The index of the identifier in the pattern when visiting the `pattern` node in evaluation
-    /// order.
-    pub(crate) index: u32,
-}
-
 impl DefinitionNodeRef<'_> {
    #[allow(unsafe_code)]
    pub(super) unsafe fn into_owned(self, parsed: ParsedModule) -> DefinitionKind {
@@ -207,24 +174,12 @@ impl DefinitionNodeRef<'_> {
            DefinitionNodeRef::AugmentedAssignment(augmented_assignment) => {
                DefinitionKind::AugmentedAssignment(AstNodeRef::new(parsed, augmented_assignment))
            }
-            DefinitionNodeRef::For(ForStmtDefinitionNodeRef {
-                iterable,
-                target,
-                is_async,
-            }) => DefinitionKind::For(ForStmtDefinitionKind {
-                iterable: AstNodeRef::new(parsed.clone(), iterable),
-                target: AstNodeRef::new(parsed, target),
-                is_async,
-            }),
-            DefinitionNodeRef::Comprehension(ComprehensionDefinitionNodeRef {
-                iterable,
-                target,
-                first,
-            }) => DefinitionKind::Comprehension(ComprehensionDefinitionKind {
-                iterable: AstNodeRef::new(parsed.clone(), iterable),
-                target: AstNodeRef::new(parsed, target),
-                first,
-            }),
+            DefinitionNodeRef::Comprehension(ComprehensionDefinitionNodeRef { node, first }) => {
+                DefinitionKind::Comprehension(ComprehensionDefinitionKind {
+                    node: AstNodeRef::new(parsed, node),
+                    first,
+                })
+            }
            DefinitionNodeRef::Parameter(parameter) => match parameter {
                ast::AnyParameterRef::Variadic(parameter) => {
                    DefinitionKind::Parameter(AstNodeRef::new(parsed, parameter))
@@ -239,15 +194,6 @@ impl DefinitionNodeRef<'_> {
                    target: AstNodeRef::new(parsed, target),
                })
            }
-            DefinitionNodeRef::MatchPattern(MatchPatternDefinitionNodeRef {
-                pattern,
-                identifier,
-                index,
-            }) => DefinitionKind::MatchPattern(MatchPatternDefinitionKind {
-                pattern: AstNodeRef::new(parsed.clone(), pattern),
-                identifier: AstNodeRef::new(parsed, identifier),
-                index,
-            }),
        }
    }

@@ -266,20 +212,12 @@ impl DefinitionNodeRef<'_> {
            }) => target.into(),
            Self::AnnotatedAssignment(node) => node.into(),
            Self::AugmentedAssignment(node) => node.into(),
-            Self::For(ForStmtDefinitionNodeRef {
-                iterable: _,
-                target,
-                is_async: _,
-            }) => target.into(),
-            Self::Comprehension(ComprehensionDefinitionNodeRef { target, .. }) => target.into(),
+            Self::Comprehension(ComprehensionDefinitionNodeRef { node, first: _ }) => node.into(),
            Self::Parameter(node) => match node {
                ast::AnyParameterRef::Variadic(parameter) => parameter.into(),
                ast::AnyParameterRef::NonVariadic(parameter) => parameter.into(),
            },
            Self::WithItem(WithItemDefinitionNodeRef { node: _, target }) => target.into(),
-            Self::MatchPattern(MatchPatternDefinitionNodeRef { identifier, .. }) => {
-                identifier.into()
-            }
        }
    }
 }
@@ -294,46 +232,21 @@ pub enum DefinitionKind {
    Assignment(AssignmentDefinitionKind),
    AnnotatedAssignment(AstNodeRef<ast::StmtAnnAssign>),
    AugmentedAssignment(AstNodeRef<ast::StmtAugAssign>),
-    For(ForStmtDefinitionKind),
    Comprehension(ComprehensionDefinitionKind),
    Parameter(AstNodeRef<ast::Parameter>),
    ParameterWithDefault(AstNodeRef<ast::ParameterWithDefault>),
    WithItem(WithItemDefinitionKind),
-    MatchPattern(MatchPatternDefinitionKind),
-}
-
-#[derive(Clone, Debug)]
-#[allow(dead_code)]
-pub struct MatchPatternDefinitionKind {
-    pattern: AstNodeRef<ast::Pattern>,
-    identifier: AstNodeRef<ast::Identifier>,
-    index: u32,
-}
-
-impl MatchPatternDefinitionKind {
-    pub(crate) fn pattern(&self) -> &ast::Pattern {
-        self.pattern.node()
-    }
-
-    pub(crate) fn index(&self) -> u32 {
-        self.index
-    }
 }

 #[derive(Clone, Debug)]
 pub struct ComprehensionDefinitionKind {
-    iterable: AstNodeRef<ast::Expr>,
-    target: AstNodeRef<ast::ExprName>,
+    node: AstNodeRef<ast::Comprehension>,
    first: bool,
 }

 impl ComprehensionDefinitionKind {
-    pub(crate) fn iterable(&self) -> &ast::Expr {
-        self.iterable.node()
-    }
-
-    pub(crate) fn target(&self) -> &ast::ExprName {
-        self.target.node()
+    pub(crate) fn node(&self) -> &ast::Comprehension {
+        self.node.node()
    }

    pub(crate) fn is_first(&self) -> bool {
@@ -389,27 +302,6 @@ impl WithItemDefinitionKind {
    }
 }

-#[derive(Clone, Debug)]
-pub struct ForStmtDefinitionKind {
-    iterable: AstNodeRef<ast::Expr>,
-    target: AstNodeRef<ast::ExprName>,
-    is_async: bool,
-}
-
-impl ForStmtDefinitionKind {
-    pub(crate) fn iterable(&self) -> &ast::Expr {
-        self.iterable.node()
-    }
-
-    pub(crate) fn target(&self) -> &ast::ExprName {
-        self.target.node()
-    }
-
-    pub(crate) fn is_async(&self) -> bool {
-        self.is_async
-    }
-}
-
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
 pub(crate) struct DefinitionNodeKey(NodeKey);

@@ -455,9 +347,9 @@ impl From<&ast::StmtAugAssign> for DefinitionNodeKey {
    }
 }

-impl From<&ast::StmtFor> for DefinitionNodeKey {
-    fn from(value: &ast::StmtFor) -> Self {
-        Self(NodeKey::from_node(value))
+impl From<&ast::Comprehension> for DefinitionNodeKey {
+    fn from(node: &ast::Comprehension) -> Self {
+        Self(NodeKey::from_node(node))
    }
 }

@@ -472,9 +364,3 @@ impl From<&ast::ParameterWithDefault> for DefinitionNodeKey {
        Self(NodeKey::from_node(node))
    }
 }
-
-impl From<&ast::Identifier> for DefinitionNodeKey {
-    fn from(identifier: &ast::Identifier) -> Self {
-        Self(NodeKey::from_node(identifier))
-    }
-}
--- a/crates/red_knot_python_semantic/src/semantic_index/symbol.rs
+++ b/crates/red_knot_python_semantic/src/semantic_index/symbol.rs
@@ -149,10 +149,6 @@ impl FileScopeId {
        FileScopeId::from_u32(0)
    }

-    pub fn is_global(self) -> bool {
-        self == FileScopeId::global()
-    }
-
    pub fn to_scope_id(self, db: &dyn Db, file: File) -> ScopeId<'_> {
        let index = semantic_index(db, file);
        index.scope_ids_by_scope[self]
--- a/crates/red_knot_python_semantic/src/semantic_model.rs
+++ b/crates/red_knot_python_semantic/src/semantic_model.rs
@@ -8,7 +8,7 @@ use crate::module_name::ModuleName;
 use crate::module_resolver::{resolve_module, Module};
 use crate::semantic_index::ast_ids::HasScopedAstId;
 use crate::semantic_index::semantic_index;
-use crate::types::{definition_ty, global_symbol_ty, infer_scope_types, Type};
+use crate::types::{definition_ty, global_symbol_ty_by_name, infer_scope_types, Type};
 use crate::Db;

 pub struct SemanticModel<'db> {
@@ -40,7 +40,7 @@ impl<'db> SemanticModel<'db> {
    }

    pub fn global_symbol_ty(&self, module: &Module, symbol_name: &str) -> Type<'db> {
-        global_symbol_ty(self.db, module.file(), symbol_name)
+        global_symbol_ty_by_name(self.db, module.file(), symbol_name)
    }
 }

--- a/crates/red_knot_python_semantic/src/stdlib.rs
+++ b/crates/red_knot_python_semantic/src/stdlib.rs
@@ -1,77 +0,0 @@
-use crate::module_name::ModuleName;
-use crate::module_resolver::resolve_module;
-use crate::semantic_index::global_scope;
-use crate::semantic_index::symbol::ScopeId;
-use crate::types::{global_symbol_ty, Type};
-use crate::Db;
-
-/// Enumeration of various core stdlib modules, for which we have dedicated Salsa queries.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum CoreStdlibModule {
-    Builtins,
-    Types,
-    Typeshed,
-}
-
-impl CoreStdlibModule {
-    fn name(self) -> ModuleName {
-        let module_name = match self {
-            Self::Builtins => "builtins",
-            Self::Types => "types",
-            Self::Typeshed => "_typeshed",
-        };
-        ModuleName::new_static(module_name)
-            .unwrap_or_else(|| panic!("{module_name} should be a valid module name!"))
-    }
-}
-
-/// Lookup the type of `symbol` in a given core module
-///
-/// Returns `Unbound` if the given core module cannot be resolved for some reason
-fn core_module_symbol_ty<'db>(
-    db: &'db dyn Db,
-    core_module: CoreStdlibModule,
-    symbol: &str,
-) -> Type<'db> {
-    resolve_module(db, core_module.name())
-        .map(|module| global_symbol_ty(db, module.file(), symbol))
-        .unwrap_or(Type::Unbound)
-}
-
-/// Lookup the type of `symbol` in the builtins namespace.
-///
-/// Returns `Unbound` if the `builtins` module isn't available for some reason.
-#[inline]
-pub(crate) fn builtins_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
-    core_module_symbol_ty(db, CoreStdlibModule::Builtins, symbol)
-}
-
-/// Lookup the type of `symbol` in the `types` module namespace.
-///
-/// Returns `Unbound` if the `types` module isn't available for some reason.
-#[inline]
-pub(crate) fn types_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
-    core_module_symbol_ty(db, CoreStdlibModule::Types, symbol)
-}
-
-/// Lookup the type of `symbol` in the `_typeshed` module namespace.
-///
-/// Returns `Unbound` if the `_typeshed` module isn't available for some reason.
-#[inline]
-pub(crate) fn typeshed_symbol_ty<'db>(db: &'db dyn Db, symbol: &str) -> Type<'db> {
-    core_module_symbol_ty(db, CoreStdlibModule::Typeshed, symbol)
-}
-
-/// Get the scope of a core stdlib module.
-///
-/// Can return `None` if a custom typeshed is used that is missing the core module in question.
-fn core_module_scope(db: &dyn Db, core_module: CoreStdlibModule) -> Option<ScopeId<'_>> {
-    resolve_module(db, core_module.name()).map(|module| global_scope(db, module.file()))
-}
-
-/// Get the `builtins` module scope.
-///
-/// Can return `None` if a custom typeshed is used that is missing `builtins.pyi`.
-pub(crate) fn builtins_module_scope(db: &dyn Db) -> Option<ScopeId<'_>> {
-    core_module_scope(db, CoreStdlibModule::Builtins)
-}
--- a/crates/red_knot_python_semantic/src/types.rs
+++ b/crates/red_knot_python_semantic/src/types.rs
@@ -1,23 +1,20 @@
-use infer::TypeInferenceBuilder;
 use ruff_db::files::File;
-use ruff_python_ast as ast;
+use ruff_python_ast::name::Name;

-use crate::semantic_index::ast_ids::HasScopedAstId;
-use crate::semantic_index::definition::{Definition, DefinitionKind};
+use crate::builtins::builtins_scope;
+use crate::semantic_index::definition::Definition;
 use crate::semantic_index::symbol::{ScopeId, ScopedSymbolId};
 use crate::semantic_index::{
    global_scope, semantic_index, symbol_table, use_def_map, DefinitionWithConstraints,
    DefinitionWithConstraintsIterator,
 };
-use crate::stdlib::{builtins_symbol_ty, types_symbol_ty, typeshed_symbol_ty};
 use crate::types::narrow::narrowing_constraint;
 use crate::{Db, FxOrderSet};

 pub(crate) use self::builder::{IntersectionBuilder, UnionBuilder};
 pub(crate) use self::diagnostic::TypeCheckDiagnostics;
 pub(crate) use self::infer::{
-    infer_deferred_types, infer_definition_types, infer_expression_types, infer_scope_types,
-    TypeInference,
+    infer_definition_types, infer_expression_types, infer_scope_types, TypeInference,
 };

 mod builder;
@@ -41,7 +38,7 @@ pub fn check_types(db: &dyn Db, file: File) -> TypeCheckDiagnostics {
 }

 /// Infer the public type of a symbol (its type as seen from outside its scope).
-pub(crate) fn symbol_ty_by_id<'db>(
+pub(crate) fn symbol_ty<'db>(
    db: &'db dyn Db,
    scope: ScopeId<'db>,
    symbol: ScopedSymbolId,
@@ -59,17 +56,30 @@ pub(crate) fn symbol_ty_by_id<'db>(
 }

 /// Shorthand for `symbol_ty` that takes a symbol name instead of an ID.
-pub(crate) fn symbol_ty<'db>(db: &'db dyn Db, scope: ScopeId<'db>, name: &str) -> Type<'db> {
+pub(crate) fn symbol_ty_by_name<'db>(
+    db: &'db dyn Db,
+    scope: ScopeId<'db>,
+    name: &str,
+) -> Type<'db> {
    let table = symbol_table(db, scope);
    table
        .symbol_id_by_name(name)
-        .map(|symbol| symbol_ty_by_id(db, scope, symbol))
+        .map(|symbol| symbol_ty(db, scope, symbol))
        .unwrap_or(Type::Unbound)
 }

 /// Shorthand for `symbol_ty` that looks up a module-global symbol by name in a file.
-pub(crate) fn global_symbol_ty<'db>(db: &'db dyn Db, file: File, name: &str) -> Type<'db> {
-    symbol_ty(db, global_scope(db, file), name)
+pub(crate) fn global_symbol_ty_by_name<'db>(db: &'db dyn Db, file: File, name: &str) -> Type<'db> {
+    symbol_ty_by_name(db, global_scope(db, file), name)
+}
+
+/// Shorthand for `symbol_ty` that looks up a symbol in the builtins.
+///
+/// Returns `Unbound` if the builtins module isn't available for some reason.
+pub(crate) fn builtins_symbol_ty_by_name<'db>(db: &'db dyn Db, name: &str) -> Type<'db> {
+    builtins_scope(db)
+        .map(|builtins| symbol_ty_by_name(db, builtins, name))
+        .unwrap_or(Type::Unbound)
 }

 /// Infer the type of a [`Definition`].
@@ -78,24 +88,6 @@ pub(crate) fn definition_ty<'db>(db: &'db dyn Db, definition: Definition<'db>) -
    inference.definition_ty(definition)
 }

-/// Infer the type of a (possibly deferred) sub-expression of a [`Definition`].
-///
-/// ## Panics
-/// If the given expression is not a sub-expression of the given [`Definition`].
-pub(crate) fn definition_expression_ty<'db>(
-    db: &'db dyn Db,
-    definition: Definition<'db>,
-    expression: &ast::Expr,
-) -> Type<'db> {
-    let expr_id = expression.scoped_ast_id(db, definition.scope(db));
-    let inference = infer_definition_types(db, definition);
-    if let Some(ty) = inference.try_expression_ty(expr_id) {
-        ty
-    } else {
-        infer_deferred_types(db, definition).expression_ty(expr_id)
-    }
-}
-
 /// Infer the combined type of an array of [`Definition`]s, plus one optional "unbound type".
 ///
 /// Will return a union if there is more than one definition, or at least one plus an unbound
@@ -140,9 +132,9 @@ pub(crate) fn definitions_ty<'db>(
    );
    let mut all_types = unbound_ty.into_iter().chain(def_types);

-    let first = all_types
-        .next()
-        .expect("definitions_ty should never be called with zero definitions and no unbound_ty.");
+    let Some(first) = all_types.next() else {
+        panic!("definitions_ty should never be called with zero definitions and no unbound_ty.")
+    };

    if let Some(second) = all_types.next() {
        let mut builder = UnionBuilder::new(db);
@@ -159,7 +151,7 @@ pub(crate) fn definitions_ty<'db>(
 }

 /// Unique ID for a type.
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq, Hash)]
 pub enum Type<'db> {
    /// the dynamic type: a statically-unknown set of values
    Any,
@@ -189,11 +181,6 @@ pub enum Type<'db> {
    IntLiteral(i64),
    /// A boolean literal, either `True` or `False`.
    BooleanLiteral(bool),
-    /// A string literal
-    StringLiteral(StringLiteralType<'db>),
-    /// A string known to originate only from literal values, but whose value is not known (unlike
-    /// `StringLiteral` above).
-    LiteralString,
    /// A bytes literal
    BytesLiteral(BytesLiteralType<'db>),
    // TODO protocols, callable types, overloads, generics, type vars
@@ -204,82 +191,14 @@ impl<'db> Type<'db> {
        matches!(self, Type::Unbound)
    }

+    pub const fn is_unknown(&self) -> bool {
+        matches!(self, Type::Unknown)
+    }
+
    pub const fn is_never(&self) -> bool {
        matches!(self, Type::Never)
    }

-    pub const fn into_class_type(self) -> Option<ClassType<'db>> {
-        match self {
-            Type::Class(class_type) => Some(class_type),
-            _ => None,
-        }
-    }
-
-    pub fn expect_class(self) -> ClassType<'db> {
-        self.into_class_type()
-            .expect("Expected a Type::Class variant")
-    }
-
-    pub const fn into_module_type(self) -> Option<File> {
-        match self {
-            Type::Module(file) => Some(file),
-            _ => None,
-        }
-    }
-
-    pub fn expect_module(self) -> File {
-        self.into_module_type()
-            .expect("Expected a Type::Module variant")
-    }
-
-    pub const fn into_union_type(self) -> Option<UnionType<'db>> {
-        match self {
-            Type::Union(union_type) => Some(union_type),
-            _ => None,
-        }
-    }
-
-    pub fn expect_union(self) -> UnionType<'db> {
-        self.into_union_type()
-            .expect("Expected a Type::Union variant")
-    }
-
-    pub const fn into_intersection_type(self) -> Option<IntersectionType<'db>> {
-        match self {
-            Type::Intersection(intersection_type) => Some(intersection_type),
-            _ => None,
-        }
-    }
-
-    pub fn expect_intersection(self) -> IntersectionType<'db> {
-        self.into_intersection_type()
-            .expect("Expected a Type::Intersection variant")
-    }
-
-    pub const fn into_function_type(self) -> Option<FunctionType<'db>> {
-        match self {
-            Type::Function(function_type) => Some(function_type),
-            _ => None,
-        }
-    }
-
-    pub fn expect_function(self) -> FunctionType<'db> {
-        self.into_function_type()
-            .expect("Expected a Type::Function variant")
-    }
-
-    pub const fn into_int_literal_type(self) -> Option<i64> {
-        match self {
-            Type::IntLiteral(value) => Some(value),
-            _ => None,
-        }
-    }
-
-    pub fn expect_int_literal(self) -> i64 {
-        self.into_int_literal_type()
-            .expect("Expected a Type::IntLiteral variant")
-    }
-
    pub fn may_be_unbound(&self, db: &'db dyn Db) -> bool {
        match self {
            Type::Unbound => true,
@@ -294,9 +213,13 @@ impl<'db> Type<'db> {
    pub fn replace_unbound_with(&self, db: &'db dyn Db, replacement: Type<'db>) -> Type<'db> {
        match self {
            Type::Unbound => replacement,
-            Type::Union(union) => {
-                union.map(db, |element| element.replace_unbound_with(db, replacement))
-            }
+            Type::Union(union) => union
+                .elements(db)
+                .into_iter()
+                .fold(UnionBuilder::new(db), |builder, ty| {
+                    builder.add(ty.replace_unbound_with(db, replacement))
+                })
+                .build(),
            ty => *ty,
        }
    }
@@ -315,7 +238,7 @@ impl<'db> Type<'db> {
    /// us to explicitly consider whether to handle an error or propagate
    /// it up the call stack.
    #[must_use]
-    pub fn member(&self, db: &'db dyn Db, name: &str) -> Type<'db> {
+    pub fn member(&self, db: &'db dyn Db, name: &Name) -> Type<'db> {
        match self {
            Type::Any => Type::Any,
            Type::Never => {
@@ -332,13 +255,19 @@ impl<'db> Type<'db> {
                // TODO: attribute lookup on function type
                Type::Unknown
            }
-            Type::Module(file) => global_symbol_ty(db, *file, name),
+            Type::Module(file) => global_symbol_ty_by_name(db, *file, name),
            Type::Class(class) => class.class_member(db, name),
            Type::Instance(_) => {
                // TODO MRO? get_own_instance_member, get_instance_member
                Type::Unknown
            }
-            Type::Union(union) => union.map(db, |element| element.member(db, name)),
+            Type::Union(union) => union
+                .elements(db)
+                .iter()
+                .fold(UnionBuilder::new(db), |builder, element_ty| {
+                    builder.add(element_ty.member(db, name))
+                })
+                .build(),
            Type::Intersection(_) => {
                // TODO perform the get_member on each type in the intersection
                // TODO return the intersection of those results
@@ -349,16 +278,6 @@ impl<'db> Type<'db> {
                Type::Unknown
            }
            Type::BooleanLiteral(_) => Type::Unknown,
-            Type::StringLiteral(_) => {
-                // TODO defer to `typing.LiteralString`/`builtins.str` methods
-                // from typeshed's stubs
-                Type::Unknown
-            }
-            Type::LiteralString => {
-                // TODO defer to `typing.LiteralString`/`builtins.str` methods
-                // from typeshed's stubs
-                Type::Unknown
-            }
            Type::BytesLiteral(_) => {
                // TODO defer to Type::Instance(<bytes from typeshed>).member
                Type::Unknown
@@ -366,81 +285,8 @@ impl<'db> Type<'db> {
        }
    }

-    /// Return the type resulting from calling an object of this type.
-    ///
-    /// Returns `None` if `self` is not a callable type.
    #[must_use]
-    pub fn call(&self, db: &'db dyn Db) -> Option<Type<'db>> {
-        match self {
-            Type::Function(function_type) => Some(function_type.return_type(db)),
-
-            // TODO annotated return type on `__new__` or metaclass `__call__`
-            Type::Class(class) => Some(Type::Instance(*class)),
-
-            // TODO: handle classes which implement the Callable protocol
-            Type::Instance(_instance_ty) => Some(Type::Unknown),
-
-            // `Any` is callable, and its return type is also `Any`.
-            Type::Any => Some(Type::Any),
-
-            Type::Unknown => Some(Type::Unknown),
-
-            // TODO: union and intersection types, if they reduce to `Callable`
-            Type::Union(_) => Some(Type::Unknown),
-            Type::Intersection(_) => Some(Type::Unknown),
-
-            _ => None,
-        }
-    }
-
-    /// Given the type of an object that is iterated over in some way,
-    /// return the type of objects that are yielded by that iteration.
-    ///
-    /// E.g., for the following loop, given the type of `x`, infer the type of `y`:
-    /// ```python
-    /// for y in x:
-    ///     pass
-    /// ```
-    fn iterate(&self, db: &'db dyn Db) -> IterationOutcome<'db> {
-        // `self` represents the type of the iterable;
-        // `__iter__` and `__next__` are both looked up on the class of the iterable:
-        let iterable_meta_type = self.to_meta_type(db);
-
-        let dunder_iter_method = iterable_meta_type.member(db, "__iter__");
-        if !dunder_iter_method.is_unbound() {
-            let Some(iterator_ty) = dunder_iter_method.call(db) else {
-                return IterationOutcome::NotIterable {
-                    not_iterable_ty: *self,
-                };
-            };
-
-            let dunder_next_method = iterator_ty.to_meta_type(db).member(db, "__next__");
-            return dunder_next_method
-                .call(db)
-                .map(|element_ty| IterationOutcome::Iterable { element_ty })
-                .unwrap_or(IterationOutcome::NotIterable {
-                    not_iterable_ty: *self,
-                });
-        }
-
-        // Although it's not considered great practice,
-        // classes that define `__getitem__` are also iterable,
-        // even if they do not define `__iter__`.
-        //
-        // TODO(Alex) this is only valid if the `__getitem__` method is annotated as
-        // accepting `int` or `SupportsIndex`
-        let dunder_get_item_method = iterable_meta_type.member(db, "__getitem__");
-
-        dunder_get_item_method
-            .call(db)
-            .map(|element_ty| IterationOutcome::Iterable { element_ty })
-            .unwrap_or(IterationOutcome::NotIterable {
-                not_iterable_ty: *self,
-            })
-    }
-
-    #[must_use]
-    pub fn to_instance(&self) -> Type<'db> {
+    pub fn instance(&self) -> Type<'db> {
        match self {
            Type::Any => Type::Any,
            Type::Unknown => Type::Unknown,
@@ -448,65 +294,12 @@ impl<'db> Type<'db> {
            _ => Type::Unknown, // TODO type errors
        }
    }
-
-    /// Given a type that is assumed to represent an instance of a class,
-    /// return a type that represents that class itself.
-    #[must_use]
-    pub fn to_meta_type(&self, db: &'db dyn Db) -> Type<'db> {
-        match self {
-            Type::Unbound => Type::Unbound,
-            Type::Never => Type::Never,
-            Type::Instance(class) => Type::Class(*class),
-            Type::Union(union) => union.map(db, |ty| ty.to_meta_type(db)),
-            Type::BooleanLiteral(_) => builtins_symbol_ty(db, "bool"),
-            Type::BytesLiteral(_) => builtins_symbol_ty(db, "bytes"),
-            Type::IntLiteral(_) => builtins_symbol_ty(db, "int"),
-            Type::Function(_) => types_symbol_ty(db, "FunctionType"),
-            Type::Module(_) => types_symbol_ty(db, "ModuleType"),
-            Type::None => typeshed_symbol_ty(db, "NoneType"),
-            // TODO not accurate if there's a custom metaclass...
-            Type::Class(_) => builtins_symbol_ty(db, "type"),
-            // TODO can we do better here? `type[LiteralString]`?
-            Type::StringLiteral(_) | Type::LiteralString => builtins_symbol_ty(db, "str"),
-            // TODO: `type[Any]`?
-            Type::Any => Type::Any,
-            // TODO: `type[Unknown]`?
-            Type::Unknown => Type::Unknown,
-            // TODO intersections
-            Type::Intersection(_) => Type::Unknown,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-enum IterationOutcome<'db> {
-    Iterable { element_ty: Type<'db> },
-    NotIterable { not_iterable_ty: Type<'db> },
-}
-
-impl<'db> IterationOutcome<'db> {
-    fn unwrap_with_diagnostic(
-        self,
-        iterable_node: ast::AnyNodeRef,
-        inference_builder: &mut TypeInferenceBuilder<'db>,
-    ) -> Type<'db> {
-        match self {
-            Self::Iterable { element_ty } => element_ty,
-            Self::NotIterable { not_iterable_ty } => {
-                inference_builder.not_iterable_diagnostic(iterable_node, not_iterable_ty);
-                Type::Unknown
-            }
-        }
-    }
 }

 #[salsa::interned]
 pub struct FunctionType<'db> {
    /// name of the function at definition
-    #[return_ref]
-    pub name: ast::name::Name,
-
-    definition: Definition<'db>,
+    pub name: Name,

    /// types of all decorators on this function
    decorators: Vec<Type<'db>>,
@@ -516,69 +309,24 @@ impl<'db> FunctionType<'db> {
    pub fn has_decorator(self, db: &dyn Db, decorator: Type<'_>) -> bool {
        self.decorators(db).contains(&decorator)
    }
-
-    /// inferred return type for this function
-    pub fn return_type(&self, db: &'db dyn Db) -> Type<'db> {
-        let definition = self.definition(db);
-        let DefinitionKind::Function(function_stmt_node) = definition.node(db) else {
-            panic!("Function type definition must have `DefinitionKind::Function`")
-        };
-
-        // TODO if a function `bar` is decorated by `foo`,
-        // where `foo` is annotated as returning a type `X` that is a subtype of `Callable`,
-        // we need to infer the return type from `X`'s return annotation
-        // rather than from `bar`'s return annotation
-        // in order to determine the type that `bar` returns
-        if !function_stmt_node.decorator_list.is_empty() {
-            return Type::Unknown;
-        }
-
-        function_stmt_node
-            .returns
-            .as_ref()
-            .map(|returns| {
-                if function_stmt_node.is_async {
-                    // TODO: generic `types.CoroutineType`!
-                    Type::Unknown
-                } else {
-                    definition_expression_ty(db, definition, returns.as_ref())
-                }
-            })
-            .unwrap_or(Type::Unknown)
-    }
 }

 #[salsa::interned]
 pub struct ClassType<'db> {
    /// Name of the class at definition
-    #[return_ref]
-    pub name: ast::name::Name,
+    pub name: Name,

-    definition: Definition<'db>,
+    /// Types of all class bases
+    bases: Vec<Type<'db>>,

    body_scope: ScopeId<'db>,
 }

 impl<'db> ClassType<'db> {
-    /// Return an iterator over the types of this class's bases.
-    ///
-    /// # Panics:
-    /// If `definition` is not a `DefinitionKind::Class`.
-    pub fn bases(&self, db: &'db dyn Db) -> impl Iterator<Item = Type<'db>> {
-        let definition = self.definition(db);
-        let DefinitionKind::Class(class_stmt_node) = definition.node(db) else {
-            panic!("Class type definition must have DefinitionKind::Class");
-        };
-        class_stmt_node
-            .bases()
-            .iter()
-            .map(move |base_expr| definition_expression_ty(db, definition, base_expr))
-    }
-
    /// Returns the class member of this class named `name`.
    ///
    /// The member resolves to a member of the class itself or any of its bases.
-    pub fn class_member(self, db: &'db dyn Db, name: &str) -> Type<'db> {
+    pub fn class_member(self, db: &'db dyn Db, name: &Name) -> Type<'db> {
        let member = self.own_class_member(db, name);
        if !member.is_unbound() {
            return member;
@@ -588,12 +336,12 @@ impl<'db> ClassType<'db> {
    }

    /// Returns the inferred type of the class member named `name`.
-    pub fn own_class_member(self, db: &'db dyn Db, name: &str) -> Type<'db> {
+    pub fn own_class_member(self, db: &'db dyn Db, name: &Name) -> Type<'db> {
        let scope = self.body_scope(db);
-        symbol_ty(db, scope, name)
+        symbol_ty_by_name(db, scope, name)
    }

-    pub fn inherited_class_member(self, db: &'db dyn Db, name: &str) -> Type<'db> {
+    pub fn inherited_class_member(self, db: &'db dyn Db, name: &Name) -> Type<'db> {
        for base in self.bases(db) {
            let member = base.member(db, name);
            if !member.is_unbound() {
@@ -608,7 +356,6 @@ impl<'db> ClassType<'db> {
 #[salsa::interned]
 pub struct UnionType<'db> {
    /// The union type includes values in any of these types.
-    #[return_ref]
    elements: FxOrderSet<Type<'db>>,
 }

@@ -616,27 +363,11 @@ impl<'db> UnionType<'db> {
    pub fn contains(&self, db: &'db dyn Db, ty: Type<'db>) -> bool {
        self.elements(db).contains(&ty)
    }
-
-    /// Apply a transformation function to all elements of the union,
-    /// and create a new union from the resulting set of types
-    pub fn map(
-        &self,
-        db: &'db dyn Db,
-        mut transform_fn: impl FnMut(&Type<'db>) -> Type<'db>,
-    ) -> Type<'db> {
-        self.elements(db)
-            .into_iter()
-            .fold(UnionBuilder::new(db), |builder, element| {
-                builder.add(transform_fn(element))
-            })
-            .build()
-    }
 }

 #[salsa::interned]
 pub struct IntersectionType<'db> {
    /// The intersection type includes only values in all of these types.
-    #[return_ref]
    positive: FxOrderSet<Type<'db>>,

    /// The intersection type does not include any value in any of these types.
@@ -644,16 +375,9 @@ pub struct IntersectionType<'db> {
    /// Negation types aren't expressible in annotations, and are most likely to arise from type
    /// narrowing along with intersections (e.g. `if not isinstance(...)`), so we represent them
    /// directly in intersections rather than as a separate type.
-    #[return_ref]
    negative: FxOrderSet<Type<'db>>,
 }

-#[salsa::interned]
-pub struct StringLiteralType<'db> {
-    #[return_ref]
-    value: Box<str>,
-}
-
 #[salsa::interned]
 pub struct BytesLiteralType<'db> {
    #[return_ref]
@@ -708,7 +432,7 @@ mod tests {
        let foo = system_path_to_file(&db, "src/foo.py").context("Failed to resolve foo.py")?;

        let diagnostics = super::check_types(&db, foo);
-        assert_diagnostic_messages(&diagnostics, &["Cannot resolve import 'bar'."]);
+        assert_diagnostic_messages(&diagnostics, &["Import 'bar' could not be resolved."]);

        Ok(())
    }
@@ -721,7 +445,7 @@ mod tests {
            .unwrap();
        let foo = system_path_to_file(&db, "src/foo.py").unwrap();
        let diagnostics = super::check_types(&db, foo);
-        assert_diagnostic_messages(&diagnostics, &["Cannot resolve import 'bar'."]);
+        assert_diagnostic_messages(&diagnostics, &["Import 'bar' could not be resolved."]);
    }

    #[test]
@@ -733,9 +457,15 @@ mod tests {

        let b_file = system_path_to_file(&db, "/src/b.py").unwrap();
        let b_file_diagnostics = super::check_types(&db, b_file);
-        assert_diagnostic_messages(&b_file_diagnostics, &["Module 'a' has no member 'thing'"]);
+        assert_diagnostic_messages(
+            &b_file_diagnostics,
+            &["Could not resolve import of 'thing' from 'a'"],
+        );
    }

+    #[ignore = "\
+A spurious second 'Unresolved import' diagnostic message is emitted on `b.py`, \
+despite the symbol existing in the symbol table for `a.py`"]
    #[test]
    fn resolved_import_of_symbol_from_unresolved_import() {
        let mut db = setup_db();
@@ -748,7 +478,10 @@ mod tests {

        let a_file = system_path_to_file(&db, "/src/a.py").unwrap();
        let a_file_diagnostics = super::check_types(&db, a_file);
-        assert_diagnostic_messages(&a_file_diagnostics, &["Cannot resolve import 'foo'."]);
+        assert_diagnostic_messages(
+            &a_file_diagnostics,
+            &["Import 'foo' could not be resolved."],
+        );

        // Importing the unresolved import into a second first-party file should not trigger
        // an additional "unresolved import" violation
@@ -756,135 +489,4 @@ mod tests {
        let b_file_diagnostics = super::check_types(&db, b_file);
        assert_eq!(&*b_file_diagnostics, &[]);
    }
-
-    #[test]
-    fn invalid_callable() {
-        let mut db = setup_db();
-
-        db.write_dedented(
-            "src/a.py",
-            "
-            nonsense = 123
-            x = nonsense()
-            ",
-        )
-        .unwrap();
-
-        let a_file = system_path_to_file(&db, "/src/a.py").unwrap();
-        let a_file_diagnostics = super::check_types(&db, a_file);
-        assert_diagnostic_messages(
-            &a_file_diagnostics,
-            &["Object of type 'Literal[123]' is not callable"],
-        );
-    }
-
-    #[test]
-    fn invalid_iterable() {
-        let mut db = setup_db();
-
-        db.write_dedented(
-            "src/a.py",
-            "
-            nonsense = 123
-            for x in nonsense:
-                pass
-            ",
-        )
-        .unwrap();
-
-        let a_file = system_path_to_file(&db, "/src/a.py").unwrap();
-        let a_file_diagnostics = super::check_types(&db, a_file);
-        assert_diagnostic_messages(
-            &a_file_diagnostics,
-            &["Object of type 'Literal[123]' is not iterable"],
-        );
-    }
-
-    #[test]
-    fn new_iteration_protocol_takes_precedence_over_old_style() {
-        let mut db = setup_db();
-
-        db.write_dedented(
-            "src/a.py",
-            "
-            class NotIterable:
-                def __getitem__(self, key: int) -> int:
-                    return 42
-
-                __iter__ = None
-
-            for x in NotIterable():
-                pass
-            ",
-        )
-        .unwrap();
-
-        let a_file = system_path_to_file(&db, "/src/a.py").unwrap();
-        let a_file_diagnostics = super::check_types(&db, a_file);
-        assert_diagnostic_messages(
-            &a_file_diagnostics,
-            &["Object of type 'NotIterable' is not iterable"],
-        );
-    }
-
-    #[test]
-    fn starred_expressions_must_be_iterable() {
-        let mut db = setup_db();
-
-        db.write_dedented(
-            "src/a.py",
-            "
-            class NotIterable: pass
-
-            class Iterator:
-                def __next__(self) -> int:
-                    return 42
-
-            class Iterable:
-                def __iter__(self) -> Iterator:
-
-            x = [*NotIterable()]
-            y = [*Iterable()]
-            ",
-        )
-        .unwrap();
-
-        let a_file = system_path_to_file(&db, "/src/a.py").unwrap();
-        let a_file_diagnostics = super::check_types(&db, a_file);
-        assert_diagnostic_messages(
-            &a_file_diagnostics,
-            &["Object of type 'NotIterable' is not iterable"],
-        );
-    }
-
-    #[test]
-    fn yield_from_expression_must_be_iterable() {
-        let mut db = setup_db();
-
-        db.write_dedented(
-            "src/a.py",
-            "
-            class NotIterable: pass
-
-            class Iterator:
-                def __next__(self) -> int:
-                    return 42
-
-            class Iterable:
-                def __iter__(self) -> Iterator:
-
-            def generator_function():
-                yield from Iterable()
-                yield from NotIterable()
-            ",
-        )
-        .unwrap();
-
-        let a_file = system_path_to_file(&db, "/src/a.py").unwrap();
-        let a_file_diagnostics = super::check_types(&db, a_file);
-        assert_diagnostic_messages(
-            &a_file_diagnostics,
-            &["Object of type 'NotIterable' is not iterable"],
-        );
-    }
 }
--- a/crates/red_knot_python_semantic/src/types/builder.rs
+++ b/crates/red_knot_python_semantic/src/types/builder.rs
@@ -25,9 +25,8 @@
 //!   * No type in an intersection can be a supertype of any other type in the intersection (just
 //!     eliminate the supertype from the intersection).
 //!   * An intersection containing two non-overlapping types should simplify to [`Type::Never`].
-use crate::types::{builtins_symbol_ty, IntersectionType, Type, UnionType};
+use crate::types::{IntersectionType, Type, UnionType};
 use crate::{Db, FxOrderSet};
-use ordermap::set::MutableValues;

 pub(crate) struct UnionBuilder<'db> {
    elements: FxOrderSet<Type<'db>>,
@@ -46,7 +45,7 @@ impl<'db> UnionBuilder<'db> {
    pub(crate) fn add(mut self, ty: Type<'db>) -> Self {
        match ty {
            Type::Union(union) => {
-                self.elements.extend(union.elements(self.db));
+                self.elements.extend(&union.elements(self.db));
            }
            Type::Never => {}
            _ => {
@@ -57,36 +56,11 @@ impl<'db> UnionBuilder<'db> {
        self
    }

-    /// Performs the following normalizations:
-    ///     - Replaces `Literal[True,False]` with `bool`.
-    ///     - TODO For enums `E` with members `X1`,...,`Xn`, replaces
-    ///     `Literal[E.X1,...,E.Xn]` with `E`.
-    fn simplify(&mut self) {
-        if let Some(true_index) = self.elements.get_index_of(&Type::BooleanLiteral(true)) {
-            if self.elements.contains(&Type::BooleanLiteral(false)) {
-                *self.elements.get_index_mut2(true_index).unwrap() =
-                    builtins_symbol_ty(self.db, "bool");
-                self.elements.remove(&Type::BooleanLiteral(false));
-            }
-        }
-    }
-
-    pub(crate) fn build(mut self) -> Type<'db> {
+    pub(crate) fn build(self) -> Type<'db> {
        match self.elements.len() {
            0 => Type::Never,
            1 => self.elements[0],
-            _ => {
-                self.simplify();
-
-                match self.elements.len() {
-                    0 => Type::Never,
-                    1 => self.elements[0],
-                    _ => {
-                        self.elements.shrink_to_fit();
-                        Type::Union(UnionType::new(self.db, self.elements))
-                    }
-                }
-            }
+            _ => Type::Union(UnionType::new(self.db, self.elements)),
        }
    }
 }
@@ -273,48 +247,25 @@ impl<'db> InnerIntersectionBuilder<'db> {
 mod tests {
    use super::{IntersectionBuilder, IntersectionType, Type, UnionBuilder, UnionType};
    use crate::db::tests::TestDb;
-    use crate::program::{Program, SearchPathSettings};
-    use crate::python_version::PythonVersion;
-    use crate::types::builtins_symbol_ty;
-    use crate::ProgramSettings;
-    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
+
+    fn setup_db() -> TestDb {
+        TestDb::new()
+    }

    impl<'db> UnionType<'db> {
        fn elements_vec(self, db: &'db TestDb) -> Vec<Type<'db>> {
-            self.elements(db).into_iter().copied().collect()
+            self.elements(db).into_iter().collect()
        }
    }

-    fn setup_db() -> TestDb {
-        let db = TestDb::new();
-
-        let src_root = SystemPathBuf::from("/src");
-        db.memory_file_system()
-            .create_directory_all(&src_root)
-            .unwrap();
-
-        Program::from_settings(
-            &db,
-            &ProgramSettings {
-                target_version: PythonVersion::default(),
-                search_paths: SearchPathSettings::new(src_root),
-            },
-        )
-        .expect("Valid search path settings");
-
-        db
-    }
-
    #[test]
    fn build_union() {
        let db = setup_db();
        let t0 = Type::IntLiteral(0);
        let t1 = Type::IntLiteral(1);
-        let union = UnionBuilder::new(&db)
-            .add(t0)
-            .add(t1)
-            .build()
-            .expect_union();
+        let Type::Union(union) = UnionBuilder::new(&db).add(t0).add(t1).build() else {
+            panic!("expected a union");
+        };

        assert_eq!(union.elements_vec(&db), &[t0, t1]);
    }
@@ -345,34 +296,6 @@ mod tests {
        assert_eq!(ty, t0);
    }

-    #[test]
-    fn build_union_bool() {
-        let db = setup_db();
-        let bool_ty = builtins_symbol_ty(&db, "bool");
-
-        let t0 = Type::BooleanLiteral(true);
-        let t1 = Type::BooleanLiteral(true);
-        let t2 = Type::BooleanLiteral(false);
-        let t3 = Type::IntLiteral(17);
-
-        let union = UnionBuilder::new(&db)
-            .add(t0)
-            .add(t1)
-            .add(t3)
-            .build()
-            .expect_union();
-        assert_eq!(union.elements_vec(&db), &[t0, t3]);
-        let union = UnionBuilder::new(&db)
-            .add(t0)
-            .add(t1)
-            .add(t2)
-            .add(t3)
-            .build()
-            .expect_union();
-
-        assert_eq!(union.elements_vec(&db), &[bool_ty, t3]);
-    }
-
    #[test]
    fn build_union_flatten() {
        let db = setup_db();
@@ -380,22 +303,20 @@ mod tests {
        let t1 = Type::IntLiteral(1);
        let t2 = Type::IntLiteral(2);
        let u1 = UnionBuilder::new(&db).add(t0).add(t1).build();
-        let union = UnionBuilder::new(&db)
-            .add(u1)
-            .add(t2)
-            .build()
-            .expect_union();
+        let Type::Union(union) = UnionBuilder::new(&db).add(u1).add(t2).build() else {
+            panic!("expected a union");
+        };

        assert_eq!(union.elements_vec(&db), &[t0, t1, t2]);
    }

    impl<'db> IntersectionType<'db> {
        fn pos_vec(self, db: &'db TestDb) -> Vec<Type<'db>> {
-            self.positive(db).into_iter().copied().collect()
+            self.positive(db).into_iter().collect()
        }

        fn neg_vec(self, db: &'db TestDb) -> Vec<Type<'db>> {
-            self.negative(db).into_iter().copied().collect()
+            self.negative(db).into_iter().collect()
        }
    }

@@ -404,14 +325,16 @@ mod tests {
        let db = setup_db();
        let t0 = Type::IntLiteral(0);
        let ta = Type::Any;
-        let intersection = IntersectionBuilder::new(&db)
+        let Type::Intersection(inter) = IntersectionBuilder::new(&db)
            .add_positive(ta)
            .add_negative(t0)
            .build()
-            .expect_intersection();
+        else {
+            panic!("expected to be an intersection");
+        };

-        assert_eq!(intersection.pos_vec(&db), &[ta]);
-        assert_eq!(intersection.neg_vec(&db), &[t0]);
+        assert_eq!(inter.pos_vec(&db), &[ta]);
+        assert_eq!(inter.neg_vec(&db), &[t0]);
    }

    #[test]
@@ -424,14 +347,16 @@ mod tests {
            .add_positive(ta)
            .add_negative(t1)
            .build();
-        let intersection = IntersectionBuilder::new(&db)
+        let Type::Intersection(inter) = IntersectionBuilder::new(&db)
            .add_positive(t2)
            .add_positive(i0)
            .build()
-            .expect_intersection();
+        else {
+            panic!("expected to be an intersection");
+        };

-        assert_eq!(intersection.pos_vec(&db), &[t2, ta]);
-        assert_eq!(intersection.neg_vec(&db), &[t1]);
+        assert_eq!(inter.pos_vec(&db), &[t2, ta]);
+        assert_eq!(inter.neg_vec(&db), &[t1]);
    }

    #[test]
@@ -444,14 +369,16 @@ mod tests {
            .add_positive(ta)
            .add_negative(t1)
            .build();
-        let intersection = IntersectionBuilder::new(&db)
+        let Type::Intersection(inter) = IntersectionBuilder::new(&db)
            .add_positive(t2)
            .add_negative(i0)
            .build()
-            .expect_intersection();
+        else {
+            panic!("expected to be an intersection");
+        };

-        assert_eq!(intersection.pos_vec(&db), &[t2, t1]);
-        assert_eq!(intersection.neg_vec(&db), &[ta]);
+        assert_eq!(inter.pos_vec(&db), &[t2, t1]);
+        assert_eq!(inter.neg_vec(&db), &[ta]);
    }

    #[test]
@@ -462,11 +389,13 @@ mod tests {
        let ta = Type::Any;
        let u0 = UnionBuilder::new(&db).add(t0).add(t1).build();

-        let union = IntersectionBuilder::new(&db)
+        let Type::Union(union) = IntersectionBuilder::new(&db)
            .add_positive(ta)
            .add_positive(u0)
            .build()
-            .expect_union();
+        else {
+            panic!("expected a union");
+        };
        let [Type::Intersection(i0), Type::Intersection(i1)] = union.elements_vec(&db)[..] else {
            panic!("expected a union of two intersections");
        };
--- a/crates/red_knot_python_semantic/src/types/display.rs
+++ b/crates/red_knot_python_semantic/src/types/display.rs
@@ -6,16 +6,12 @@ use ruff_python_ast::str::Quote;
 use ruff_python_literal::escape::AsciiEscape;

 use crate::types::{IntersectionType, Type, UnionType};
-use crate::{Db, FxOrderMap};
+use crate::Db;

 impl<'db> Type<'db> {
    pub fn display(&'db self, db: &'db dyn Db) -> DisplayType<'db> {
        DisplayType { ty: self, db }
    }
-
-    fn representation(&'db self, db: &'db dyn Db) -> DisplayRepresentation<'db> {
-        DisplayRepresentation { db, ty: self }
-    }
 }

 #[derive(Copy, Clone)]
@@ -25,39 +21,6 @@ pub struct DisplayType<'db> {
 }

 impl Display for DisplayType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let representation = self.ty.representation(self.db);
-        if matches!(
-            self.ty,
-            Type::IntLiteral(_)
-                | Type::BooleanLiteral(_)
-                | Type::StringLiteral(_)
-                | Type::BytesLiteral(_)
-                | Type::Class(_)
-                | Type::Function(_)
-        ) {
-            write!(f, "Literal[{representation}]",)
-        } else {
-            representation.fmt(f)
-        }
-    }
-}
-
-impl std::fmt::Debug for DisplayType<'_> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        std::fmt::Display::fmt(self, f)
-    }
-}
-
-/// Writes the string representation of a type, which is the value displayed either as
-/// `Literal[<repr>]` or `Literal[<repr1>, <repr2>]` for literal types or as `<repr>` for
-/// non literals
-struct DisplayRepresentation<'db> {
-    ty: &'db Type<'db>,
-    db: &'db dyn Db,
-}
-
-impl std::fmt::Display for DisplayRepresentation<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self.ty {
            Type::Any => f.write_str("Any"),
@@ -69,27 +32,33 @@ impl std::fmt::Display for DisplayRepresentation<'_> {
                write!(f, "<module '{:?}'>", file.path(self.db))
            }
            // TODO functions and classes should display using a fully qualified name
-            Type::Class(class) => f.write_str(class.name(self.db)),
-            Type::Instance(class) => f.write_str(class.name(self.db)),
-            Type::Function(function) => f.write_str(function.name(self.db)),
+            Type::Class(class) => write!(f, "Literal[{}]", class.name(self.db)),
+            Type::Instance(class) => f.write_str(&class.name(self.db)),
+            Type::Function(function) => write!(f, "Literal[{}]", function.name(self.db)),
            Type::Union(union) => union.display(self.db).fmt(f),
            Type::Intersection(intersection) => intersection.display(self.db).fmt(f),
-            Type::IntLiteral(n) => write!(f, "{n}"),
-            Type::BooleanLiteral(boolean) => f.write_str(if *boolean { "True" } else { "False" }),
-            Type::StringLiteral(string) => {
-                write!(f, r#""{}""#, string.value(self.db).replace('"', r#"\""#))
+            Type::IntLiteral(n) => write!(f, "Literal[{n}]"),
+            Type::BooleanLiteral(boolean) => {
+                write!(f, "Literal[{}]", if *boolean { "True" } else { "False" })
            }
-            Type::LiteralString => f.write_str("LiteralString"),
            Type::BytesLiteral(bytes) => {
                let escape =
                    AsciiEscape::with_preferred_quote(bytes.value(self.db).as_ref(), Quote::Double);

-                escape.bytes_repr().write(f)
+                f.write_str("Literal[")?;
+                escape.bytes_repr().write(f)?;
+                f.write_str("]")
            }
        }
    }
 }

+impl std::fmt::Debug for DisplayType<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self, f)
+    }
+}
+
 impl<'db> UnionType<'db> {
    fn display(&'db self, db: &'db dyn Db) -> DisplayUnionType<'db> {
        DisplayUnionType { db, ty: self }
@@ -103,58 +72,45 @@ struct DisplayUnionType<'db> {

 impl Display for DisplayUnionType<'_> {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        let elements = self.ty.elements(self.db);
+        let union = self.ty;

-        // Group literal types by kind.
-        let mut grouped_literals = FxOrderMap::default();
-
-        for element in elements {
-            if let Ok(literal_kind) = LiteralTypeKind::try_from(*element) {
-                grouped_literals
-                    .entry(literal_kind)
-                    .or_insert_with(Vec::new)
-                    .push(*element);
-            }
-        }
+        let (int_literals, other_types): (Vec<Type>, Vec<Type>) = union
+            .elements(self.db)
+            .iter()
+            .copied()
+            .partition(|ty| matches!(ty, Type::IntLiteral(_)));

        let mut first = true;
-
-        // Print all types, but write all literals together (while preserving their position).
-        for ty in elements {
-            if let Ok(literal_kind) = LiteralTypeKind::try_from(*ty) {
-                let Some(mut literals) = grouped_literals.remove(&literal_kind) else {
-                    continue;
-                };
-
-                if !first {
-                    f.write_str(" | ")?;
-                };
-
-                f.write_str("Literal[")?;
-
-                if literal_kind == LiteralTypeKind::IntLiteral {
-                    literals.sort_unstable_by_key(|ty| ty.expect_int_literal());
-                }
-
-                for (i, literal_ty) in literals.iter().enumerate() {
-                    if i > 0 {
-                        f.write_str(", ")?;
+        if !int_literals.is_empty() {
+            f.write_str("Literal[")?;
+            let mut nums: Vec<_> = int_literals
+                .into_iter()
+                .filter_map(|ty| {
+                    if let Type::IntLiteral(n) = ty {
+                        Some(n)
+                    } else {
+                        None
                    }
-                    literal_ty.representation(self.db).fmt(f)?;
-                }
-                f.write_str("]")?;
-            } else {
+                })
+                .collect();
+            nums.sort_unstable();
+            for num in nums {
                if !first {
-                    f.write_str(" | ")?;
-                };
-
-                ty.display(self.db).fmt(f)?;
+                    f.write_str(", ")?;
+                }
+                write!(f, "{num}")?;
+                first = false;
            }
-
-            first = false;
+            f.write_str("]")?;
        }

-        debug_assert!(grouped_literals.is_empty());
+        for ty in other_types {
+            if !first {
+                f.write_str(" | ")?;
+            };
+            first = false;
+            write!(f, "{}", ty.display(self.db))?;
+        }

        Ok(())
    }
@@ -166,30 +122,6 @@ impl std::fmt::Debug for DisplayUnionType<'_> {
    }
 }

-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-enum LiteralTypeKind {
-    Class,
-    Function,
-    IntLiteral,
-    StringLiteral,
-    BytesLiteral,
-}
-
-impl TryFrom<Type<'_>> for LiteralTypeKind {
-    type Error = ();
-
-    fn try_from(value: Type<'_>) -> Result<Self, Self::Error> {
-        match value {
-            Type::Class(_) => Ok(Self::Class),
-            Type::Function(_) => Ok(Self::Function),
-            Type::IntLiteral(_) => Ok(Self::IntLiteral),
-            Type::StringLiteral(_) => Ok(Self::StringLiteral),
-            Type::BytesLiteral(_) => Ok(Self::BytesLiteral),
-            _ => Err(()),
-        }
-    }
-}
-
 impl<'db> IntersectionType<'db> {
    fn display(&'db self, db: &'db dyn Db) -> DisplayIntersectionType<'db> {
        DisplayIntersectionType { db, ty: self }
@@ -229,89 +161,3 @@ impl std::fmt::Debug for DisplayIntersectionType<'_> {
        std::fmt::Display::fmt(self, f)
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use ruff_db::files::system_path_to_file;
-    use ruff_db::system::{DbWithTestSystem, SystemPathBuf};
-
-    use crate::db::tests::TestDb;
-    use crate::types::{global_symbol_ty, BytesLiteralType, StringLiteralType, Type, UnionBuilder};
-    use crate::{Program, ProgramSettings, PythonVersion, SearchPathSettings};
-
-    fn setup_db() -> TestDb {
-        let db = TestDb::new();
-
-        let src_root = SystemPathBuf::from("/src");
-        db.memory_file_system()
-            .create_directory_all(&src_root)
-            .unwrap();
-
-        Program::from_settings(
-            &db,
-            &ProgramSettings {
-                target_version: PythonVersion::default(),
-                search_paths: SearchPathSettings::new(src_root),
-            },
-        )
-        .expect("Valid search path settings");
-
-        db
-    }
-
-    #[test]
-    fn test_condense_literal_display_by_type() -> anyhow::Result<()> {
-        let mut db = setup_db();
-
-        db.write_dedented(
-            "src/main.py",
-            "
-            def foo(x: int) -> int:
-                return x + 1
-
-            def bar(s: str) -> str:
-                return s
-
-            class A: ...
-            class B: ...
-            ",
-        )?;
-        let mod_file = system_path_to_file(&db, "src/main.py").expect("Expected file to exist.");
-
-        let vec: Vec<Type<'_>> = vec![
-            Type::Unknown,
-            Type::IntLiteral(-1),
-            global_symbol_ty(&db, mod_file, "A"),
-            Type::StringLiteral(StringLiteralType::new(&db, Box::from("A"))),
-            Type::BytesLiteral(BytesLiteralType::new(&db, Box::from([0]))),
-            Type::BytesLiteral(BytesLiteralType::new(&db, Box::from([7]))),
-            Type::IntLiteral(0),
-            Type::IntLiteral(1),
-            Type::StringLiteral(StringLiteralType::new(&db, Box::from("B"))),
-            global_symbol_ty(&db, mod_file, "foo"),
-            global_symbol_ty(&db, mod_file, "bar"),
-            global_symbol_ty(&db, mod_file, "B"),
-            Type::BooleanLiteral(true),
-            Type::None,
-        ];
-        let builder = vec.iter().fold(UnionBuilder::new(&db), |builder, literal| {
-            builder.add(*literal)
-        });
-        let union = builder.build().expect_union();
-        let display = format!("{}", union.display(&db));
-        assert_eq!(
-            display,
-            concat!(
-                "Unknown | ",
-                "Literal[-1, 0, 1] | ",
-                "Literal[A, B] | ",
-                "Literal[\"A\", \"B\"] | ",
-                "Literal[b\"\\x00\", b\"\\x07\"] | ",
-                "Literal[foo, bar] | ",
-                "Literal[True] | ",
-                "None"
-            )
-        );
-        Ok(())
-    }
-}
--- a/crates/red_knot_python_semantic/src/types/infer.rs
+++ b/crates/red_knot_python_semantic/src/types/infer.rs
--- a/crates/red_knot_python_semantic/vendor/typeshed/source_commit.txt
+++ b/crates/red_knot_python_semantic/vendor/typeshed/source_commit.txt
@@ -1 +1 @@
-23d867efb2df6de5600f64656f1aa8a83e06109e
+1ace5718deaf3041f8e3d1dc9c9e8a8e830e517f
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_ast.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_ast.pyi
@@ -1,7 +1,7 @@
 import sys
 import typing_extensions
 from typing import Any, ClassVar, Generic, Literal, TypedDict, overload
-from typing_extensions import Self, Unpack
+from typing_extensions import Unpack

 PyCF_ONLY_AST: Literal[1024]
 PyCF_TYPE_COMMENTS: Literal[4096]
@@ -34,9 +34,6 @@ class AST:
    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 type_ignore(AST): ...

@@ -47,9 +44,6 @@ class TypeIgnore(type_ignore):
    tag: str
    def __init__(self, lineno: int, tag: str) -> None: ...

-    if sys.version_info >= (3, 14):
-        def __replace__(self, *, lineno: int = ..., tag: str = ...) -> Self: ...
-
 class FunctionType(mod):
    if sys.version_info >= (3, 10):
        __match_args__ = ("argtypes", "returns")
@@ -63,9 +57,6 @@ class FunctionType(mod):
    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 Module(mod):
    if sys.version_info >= (3, 10):
        __match_args__ = ("body", "type_ignores")
@@ -76,9 +67,6 @@ class Module(mod):
    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",)
@@ -88,18 +76,12 @@ class Interactive(mod):
    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 stmt(AST):
    lineno: int
    col_offset: int
@@ -107,9 +89,6 @@ class stmt(AST):
    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")
@@ -173,19 +152,6 @@ class FunctionDef(stmt):
            **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")
@@ -249,19 +215,6 @@ class AsyncFunctionDef(stmt):
            **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")
@@ -307,28 +260,12 @@ class ClassDef(stmt):
            **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",)
@@ -338,9 +275,6 @@ class Delete(stmt):
    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")
@@ -361,11 +295,6 @@ class Assign(stmt):
            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: ...
-
 class AugAssign(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("target", "op", "value")
@@ -376,16 +305,6 @@ class AugAssign(stmt):
        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")
@@ -413,17 +332,6 @@ class AnnAssign(stmt):
        **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")
@@ -453,18 +361,6 @@ class For(stmt):
            **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")
@@ -494,18 +390,6 @@ class AsyncFor(stmt):
            **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")
@@ -519,9 +403,6 @@ class While(stmt):
    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")
@@ -535,11 +416,6 @@ class If(stmt):
    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")
@@ -559,16 +435,6 @@ class With(stmt):
            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")
@@ -588,16 +454,6 @@ class AsyncWith(stmt):
            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 Raise(stmt):
    if sys.version_info >= (3, 10):
        __match_args__ = ("exc", "cause")
@@ -605,9 +461,6 @@ class Raise(stmt):
    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")
@@ -634,17 +487,6 @@ class Try(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")
@@ -671,17 +513,6 @@ if sys.version_info >= (3, 11):
                **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")
@@ -689,9 +520,6 @@ class Assert(stmt):
    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",)
@@ -701,9 +529,6 @@ class Import(stmt):
    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")
@@ -725,11 +550,6 @@ class ImportFrom(stmt):
            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",)
@@ -739,9 +559,6 @@ class Global(stmt):
    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",)
@@ -751,18 +568,12 @@ class Nonlocal(stmt):
    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): ...
@@ -774,9 +585,6 @@ class expr(AST):
    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")
@@ -787,9 +595,6 @@ class BoolOp(expr):
    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 BinOp(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("left", "op", "right")
@@ -798,11 +603,6 @@ class BinOp(expr):
    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")
@@ -810,9 +610,6 @@ class UnaryOp(expr):
    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")
@@ -820,9 +617,6 @@ class Lambda(expr):
    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")
@@ -831,11 +625,6 @@ class IfExp(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")
@@ -846,11 +635,6 @@ class Dict(expr):
    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",)
@@ -860,9 +644,6 @@ class Set(expr):
    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")
@@ -873,11 +654,6 @@ class ListComp(expr):
    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")
@@ -888,11 +664,6 @@ class SetComp(expr):
    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")
@@ -906,11 +677,6 @@ class DictComp(expr):
    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")
@@ -921,38 +687,24 @@ class GeneratorExp(expr):
    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")
@@ -966,11 +718,6 @@ class Compare(expr):
    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")
@@ -984,11 +731,6 @@ class Call(expr):
    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")
@@ -997,11 +739,6 @@ class FormattedValue(expr):
    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",)
@@ -1011,9 +748,6 @@ class JoinedStr(expr):
    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")
@@ -1026,9 +760,6 @@ class Constant(expr):

    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 NamedExpr(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("target", "value")
@@ -1036,9 +767,6 @@ class NamedExpr(expr):
    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 Attribute(expr):
    if sys.version_info >= (3, 10):
        __match_args__ = ("value", "attr", "ctx")
@@ -1047,11 +775,6 @@ class Attribute(expr):
    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: ...
-
 if sys.version_info >= (3, 9):
    _Slice: typing_extensions.TypeAlias = expr
    _SliceAttributes: typing_extensions.TypeAlias = _Attributes
@@ -1071,16 +794,6 @@ class Slice(_Slice):
        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: ...
-
 if sys.version_info < (3, 9):
    class ExtSlice(slice):
        dims: list[slice]
@@ -1098,11 +811,6 @@ class Subscript(expr):
    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")
@@ -1110,9 +818,6 @@ class Starred(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")
@@ -1120,9 +825,6 @@ class Name(expr):
    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")
@@ -1133,9 +835,6 @@ class List(expr):
    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")
@@ -1148,9 +847,6 @@ class Tuple(expr):
    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 expr_context(AST): ...

 if sys.version_info < (3, 9):
@@ -1214,9 +910,6 @@ class comprehension(AST):
    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
@@ -1224,11 +917,6 @@ class excepthandler(AST):
    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")
@@ -1249,16 +937,6 @@ class ExceptHandler(excepthandler):
            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")
@@ -1317,19 +995,6 @@ class arguments(AST):
            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
@@ -1344,16 +1009,6 @@ class arg(AST):
        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
@@ -1368,9 +1023,6 @@ class keyword(AST):
    @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
@@ -1382,9 +1034,6 @@ class alias(AST):
    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")
@@ -1392,9 +1041,6 @@ class withitem(AST):
    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(stmt):
        __match_args__ = ("subject", "cases")
@@ -1405,11 +1051,6 @@ if sys.version_info >= (3, 10):
        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 pattern(AST):
        lineno: int
        col_offset: int
@@ -1417,11 +1058,6 @@ if sys.version_info >= (3, 10):
        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

@@ -1438,25 +1074,16 @@ if sys.version_info >= (3, 10):
            @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 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]
@@ -1465,17 +1092,11 @@ if sys.version_info >= (3, 10):
        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 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 MatchMapping(pattern):
        __match_args__ = ("keys", "patterns", "rest")
        keys: list[expr]
@@ -1498,16 +1119,6 @@ if sys.version_info >= (3, 10):
                **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
@@ -1533,17 +1144,6 @@ if sys.version_info >= (3, 10):
                **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 MatchAs(pattern):
        __match_args__ = ("pattern", "name")
        pattern: _Pattern | None
@@ -1552,11 +1152,6 @@ if sys.version_info >= (3, 10):
            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]
@@ -1565,9 +1160,6 @@ if sys.version_info >= (3, 10):
        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: ...
-
 if sys.version_info >= (3, 12):
    class type_param(AST):
        lineno: int
@@ -1576,9 +1168,6 @@ if sys.version_info >= (3, 12):
        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")
@@ -1598,16 +1187,6 @@ if sys.version_info >= (3, 12):
        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")
@@ -1622,11 +1201,6 @@ if sys.version_info >= (3, 12):
        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")
@@ -1641,11 +1215,6 @@ if sys.version_info >= (3, 12):
        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 TypeAlias(stmt):
        __match_args__ = ("name", "type_params", "value")
        name: Name
@@ -1664,13 +1233,3 @@ if sys.version_info >= (3, 12):
            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: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_operator.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_operator.pyi
@@ -2,7 +2,7 @@ import sys
 from _typeshed import SupportsGetItem
 from collections.abc import Callable, Container, Iterable, MutableMapping, MutableSequence, Sequence
 from typing import Any, AnyStr, Generic, Protocol, SupportsAbs, SupportsIndex, TypeVar, final, overload
-from typing_extensions import ParamSpec, TypeAlias, TypeIs, TypeVarTuple, Unpack
+from typing_extensions import ParamSpec, TypeAlias, TypeVarTuple, Unpack

 _R = TypeVar("_R")
 _T = TypeVar("_T")
@@ -145,7 +145,3 @@ if sys.version_info >= (3, 11):
    def call(obj: Callable[_P, _R], /, *args: _P.args, **kwargs: _P.kwargs) -> _R: ...

 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]: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_stat.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_stat.pyi
@@ -28,9 +28,9 @@ 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: Final[int]
-S_IFPORT: Final[int]
-S_IFWHT: Final[int]
+S_IFDOOR: int
+S_IFPORT: int
+S_IFWHT: int

 S_ISUID: Final = 0o4000
 S_ISGID: Final = 0o2000
@@ -79,9 +79,9 @@ 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
+    IO_REPARSE_TAG_SYMLINK: int
+    IO_REPARSE_TAG_MOUNT_POINT: int
+    IO_REPARSE_TAG_APPEXECLINK: int

 if sys.platform == "win32":
    FILE_ATTRIBUTE_ARCHIVE: Final = 32
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_thread.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_thread.pyi
@@ -1,4 +1,3 @@
-import signal
 import sys
 from _typeshed import structseq
 from collections.abc import Callable
@@ -17,39 +16,16 @@ 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: ...

-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: ...
-    lock = LockType
-
@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: ...
-
-if sys.version_info >= (3, 10):
-    def interrupt_main(signum: signal.Signals = ..., /) -> None: ...
-
-else:
-    def interrupt_main() -> None: ...
-
+def interrupt_main() -> None: ...
 def exit() -> NoReturn: ...
 def allocate_lock() -> LockType: ...
 def get_ident() -> int: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_tkinter.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/_tkinter.pyi
@@ -106,8 +106,8 @@ EXCEPTION: Final = 8
 READABLE: Final = 2
 WRITABLE: Final = 4

-TCL_VERSION: Final[str]
-TK_VERSION: Final[str]
+TCL_VERSION: str
+TK_VERSION: str

@final
 class TkttType:
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/builtins.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/builtins.pyi
@@ -33,8 +33,7 @@ from collections.abc import Awaitable, Callable, Iterable, Iterator, MutableSet,
 from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
 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,
@@ -968,9 +967,7 @@ class tuple(Sequence[_T_co]):
    if sys.version_info >= (3, 9):
        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...

-# 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
+# Doesn't exist at runtime, but deleting this breaks mypy. See #2999
@final
@type_check_only
 class function:
@@ -1087,8 +1084,7 @@ class dict(MutableMapping[_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
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/cmd.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/cmd.pyi
@@ -1,11 +1,10 @@
 from collections.abc import Callable
 from typing import IO, Any, Final
-from typing_extensions import LiteralString

 __all__ = ["Cmd"]

 PROMPT: Final = "(Cmd) "
-IDENTCHARS: Final[LiteralString]  # Too big to be `Literal`
+IDENTCHARS: str  # Too big to be `Literal`

 class Cmd:
    prompt: str
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/collections/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/collections/init.pyi
@@ -345,15 +345,15 @@ 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[reportGeneralTypeIssues]
+class _odict_keys(dict_keys[_KT_co, _VT_co], Reversible[_KT_co]):  # type: ignore[misc]  # pyright: ignore
    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[reportGeneralTypeIssues]
+class _odict_items(dict_items[_KT_co, _VT_co], Reversible[tuple[_KT_co, _VT_co]]):  # type: ignore[misc]  # pyright: ignore
    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[reportGeneralTypeIssues]
+class _odict_values(dict_values[_KT_co, _VT_co], Reversible[_VT_co], Generic[_KT_co, _VT_co]):  # type: ignore[misc]  # pyright: ignore
    def __reversed__(self) -> Iterator[_VT_co]: ...

 class OrderedDict(dict[_KT, _VT], Reversible[_KT], Generic[_KT, _VT]):
@@ -475,8 +475,7 @@ class ChainMap(MutableMapping[_KT, _VT]):
    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]: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/crypt.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/crypt.pyi
@@ -1,13 +1,12 @@
 import sys
-from typing import Final

 if sys.platform != "win32":
    class _Method: ...
-    METHOD_CRYPT: Final[_Method]
-    METHOD_MD5: Final[_Method]
-    METHOD_SHA256: Final[_Method]
-    METHOD_SHA512: Final[_Method]
-    METHOD_BLOWFISH: Final[_Method]
+    METHOD_CRYPT: _Method
+    METHOD_MD5: _Method
+    METHOD_SHA256: _Method
+    METHOD_SHA512: _Method
+    METHOD_BLOWFISH: _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: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/ctypes/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/ctypes/init.pyi
@@ -185,8 +185,3 @@ if sys.version_info >= (3, 12):
    c_time_t: type[c_int32 | c_int64]  # alias for one or the other at runtime

 class py_object(_CanCastTo, _SimpleCData[_T]): ...
-
-if sys.version_info >= (3, 14):
-    class c_float_complex(_SimpleCData[complex]): ...
-    class c_double_complex(_SimpleCData[complex]): ...
-    class c_longdouble_complex(_SimpleCData[complex]): ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/dataclasses.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/dataclasses.pyi
@@ -229,17 +229,18 @@ if sys.version_info >= (3, 9):
 else:
    class _InitVarMeta(type):
        # Not used, instead `InitVar.__class_getitem__` is called.
-        # pyright (not unreasonably) thinks this is an invalid use of InitVar.
-        def __getitem__(self, params: Any) -> InitVar[Any]: ...  # pyright: ignore[reportInvalidTypeForm]
+        # pyright ignore is needed because pyright (not unreasonably) thinks this
+        # is an invalid use of InitVar.
+        def __getitem__(self, params: Any) -> InitVar[Any]: ...  # pyright: ignore

 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]: ...  # pyright: ignore[reportInvalidTypeForm]
+        def __class_getitem__(cls, type: Type[_T]) -> InitVar[_T]: ...  # pyright: ignore
        @overload
-        def __class_getitem__(cls, type: Any) -> InitVar[Any]: ...  # pyright: ignore[reportInvalidTypeForm]
+        def __class_getitem__(cls, type: Any) -> InitVar[Any]: ...  # pyright: ignore

 if sys.version_info >= (3, 12):
    def make_dataclass(
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/datetime.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/datetime.pyi
@@ -265,12 +265,12 @@ class datetime(date):
        def fromtimestamp(cls, timestamp: float, /, tz: _TzInfo | None = ...) -> Self: ...

    @classmethod
-    @deprecated("Use timezone-aware objects to represent datetimes in UTC; e.g. by calling .fromtimestamp(datetime.timezone.utc)")
+    @deprecated("Use timezone-aware objects to represent datetimes in UTC; e.g. by calling .fromtimestamp(datetime.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)")
+    @deprecated("Use timezone-aware objects to represent datetimes in UTC; e.g. by calling .now(datetime.UTC)")
    def utcnow(cls) -> Self: ...
    @classmethod
    def combine(cls, date: _Date, time: _Time, tzinfo: _TzInfo | None = ...) -> Self: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/cmd.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/cmd.pyi
@@ -30,7 +30,6 @@ _CommandT = TypeVar("_CommandT", bound=Command)
 _Ts = TypeVarTuple("_Ts")

 class Command:
-    dry_run: Literal[0, 1]  # Exposed from __getattr_. Same as Distribution.dry_run
    distribution: Distribution
    # Any to work around variance issues
    sub_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]]
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/check.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/check.pyi
@@ -1,4 +1,4 @@
-from typing import Any, ClassVar, Final, Literal
+from typing import Any, ClassVar, Literal
 from typing_extensions import TypeAlias

 from ..cmd import Command
@@ -22,7 +22,7 @@ class SilentReporter(_Reporter):
    ) -> None: ...
    def system_message(self, level, message, *children, **kwargs): ...

-HAS_DOCUTILS: Final[bool]
+HAS_DOCUTILS: bool

 class check(Command):
    description: str
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/config.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/config.pyi
@@ -1,12 +1,12 @@
 from _typeshed import StrOrBytesPath
 from collections.abc import Sequence
 from re import Pattern
-from typing import Any, ClassVar, Final, Literal
+from typing import Any, ClassVar, Literal

 from ..ccompiler import CCompiler
 from ..cmd import Command

-LANG_EXT: Final[dict[str, str]]
+LANG_EXT: dict[str, str]

 class config(Command):
    description: str
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/install.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/install.pyi
@@ -1,16 +1,11 @@
-import sys
 from collections.abc import Callable
-from typing import Any, ClassVar, Final, Literal
+from typing import Any, ClassVar

 from ..cmd import Command

-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]]
+HAS_USER_SITE: bool
+SCHEME_KEYS: tuple[str, ...]
+INSTALL_SCHEMES: dict[str, dict[Any, Any]]

 class install(Command):
    description: str
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/install_lib.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/command/install_lib.pyi
@@ -1,8 +1,8 @@
-from typing import Any, ClassVar, Final
+from typing import Any, ClassVar

 from ..cmd import Command

-PYTHON_SOURCE_EXTENSION: Final = ".py"
+PYTHON_SOURCE_EXTENSION: str

 class install_lib(Command):
    description: str
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/core.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/core.pyi
@@ -3,9 +3,9 @@ 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, Final, Literal
+from typing import Any, Literal

-USAGE: Final[str]
+USAGE: str

 def gen_usage(script_name: StrOrBytesPath) -> str: ...

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/cygwinccompiler.pyi
+++ b/crates/red_knot_python_semantic/vendor/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 import Final, Literal
+from typing import Literal

 def get_msvcr() -> list[str] | None: ...

 class CygwinCCompiler(UnixCCompiler): ...
 class Mingw32CCompiler(CygwinCCompiler): ...

-CONFIG_H_OK: Final = "ok"
-CONFIG_H_NOTOK: Final = "not ok"
-CONFIG_H_UNCERTAIN: Final = "uncertain"
+CONFIG_H_OK: str
+CONFIG_H_NOTOK: str
+CONFIG_H_UNCERTAIN: str

 def check_config_h() -> tuple[Literal["ok", "not ok", "uncertain"], str]: ...

-RE_VERSION: Final[Pattern[bytes]]
+RE_VERSION: Pattern[bytes]

 def get_versions() -> tuple[LooseVersion | None, ...]: ...
 def is_cygwingcc() -> bool: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/debug.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/debug.pyi
@@ -1,3 +1 @@
-from typing import Final
-
-DEBUG: Final[str | None]
+DEBUG: bool | None
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/dist.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/dist.pyi
@@ -88,9 +88,9 @@ class Distribution:
    display_options: ClassVar[_OptionsList]
    display_option_names: ClassVar[list[str]]
    negative_opt: ClassVar[dict[str, str]]
-    verbose: Literal[0, 1]
-    dry_run: Literal[0, 1]
-    help: Literal[0, 1]
+    verbose: int
+    dry_run: int
+    help: int
    command_packages: list[str] | None
    script_name: str | None
    script_args: list[str] | None
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/fancy_getopt.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/fancy_getopt.pyi
@@ -1,15 +1,15 @@
 from collections.abc import Iterable, Mapping
 from re import Pattern
-from typing import Any, Final, overload
+from typing import Any, overload
 from typing_extensions import TypeAlias

 _Option: TypeAlias = tuple[str, str | None, str]
 _GR: TypeAlias = tuple[list[str], OptionDummy]

-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]]
+longopt_pat: str
+longopt_re: Pattern[str]
+neg_alias_re: Pattern[str]
+longopt_xlate: dict[int, int]

 class FancyGetopt:
    def __init__(self, option_table: list[_Option] | None = None) -> None: ...
@@ -25,7 +25,7 @@ def fancy_getopt(
    options: list[_Option], negative_opt: Mapping[_Option, _Option], object: Any, args: list[str] | None
 ) -> list[str] | _GR: ...

-WS_TRANS: Final[dict[int, str]]
+WS_TRANS: dict[int, str]

 def wrap_text(text: str, width: int) -> list[str]: ...
 def translate_longopt(opt: str) -> str: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/log.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/log.pyi
@@ -1,10 +1,10 @@
-from typing import Any, Final
+from typing import Any

-DEBUG: Final = 1
-INFO: Final = 2
-WARN: Final = 3
-ERROR: Final = 4
-FATAL: Final = 5
+DEBUG: int
+INFO: int
+WARN: int
+ERROR: int
+FATAL: int

 class Log:
    def __init__(self, threshold: int = 3) -> None: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/sysconfig.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/distutils/sysconfig.pyi
@@ -1,15 +1,15 @@
 import sys
 from collections.abc import Mapping
 from distutils.ccompiler import CCompiler
-from typing import Final, Literal, overload
+from typing import Literal, overload
 from typing_extensions import deprecated

-PREFIX: Final[str]
-EXEC_PREFIX: Final[str]
-BASE_PREFIX: Final[str]
-BASE_EXEC_PREFIX: Final[str]
-project_base: Final[str]
-python_build: Final[bool]
+PREFIX: str
+EXEC_PREFIX: str
+BASE_PREFIX: str
+BASE_EXEC_PREFIX: str
+project_base: str
+python_build: bool

 def expand_makefile_vars(s: str, vars: Mapping[str, str]) -> str: ...
@overload
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/email/message.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/email/message.pyi
@@ -50,8 +50,7 @@ class Message(Generic[_HeaderT, _HeaderParamT]):
    def get_payload(self, i: None = None, *, decode: Literal[True]) -> _EncodedPayloadType | Any: ...
    @overload  # not multipart, IDEM but w/o kwarg
    def get_payload(self, i: None, decode: Literal[True]) -> _EncodedPayloadType | Any: ...
-    # If `charset=None` and payload supports both `encode` AND `decode`,
-    # then an invalid payload could be passed, but this is unlikely
+    # 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(
@@ -147,11 +146,7 @@ class Message(Generic[_HeaderT, _HeaderParamT]):
 class MIMEPart(Message[_HeaderRegistryT, _HeaderRegistryParamT]):
    def __init__(self, policy: Policy | 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_attachments(self) -> Iterator[MIMEPart[_HeaderRegistryT]]: ...
    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: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/ftplib.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/ftplib.pyi
@@ -86,7 +86,7 @@ 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` can actually be anything whose str() is an integer sequence, so to make it simple we allow integers
+    # 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 | None]: ...
    def transfercmd(self, cmd: str, rest: int | str | None = None) -> socket: ...
    def retrbinary(
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/json/encoder.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/json/encoder.pyi
@@ -1,12 +1,12 @@
 from collections.abc import Callable, Iterator
 from re import Pattern
-from typing import Any, Final
+from typing import Any

-ESCAPE: Final[Pattern[str]]
-ESCAPE_ASCII: Final[Pattern[str]]
-HAS_UTF8: Final[Pattern[bytes]]
-ESCAPE_DCT: Final[dict[str, str]]
-INFINITY: Final[float]
+ESCAPE: Pattern[str]
+ESCAPE_ASCII: Pattern[str]
+HAS_UTF8: Pattern[bytes]
+ESCAPE_DCT: dict[str, str]
+INFINITY: float

 def py_encode_basestring(s: str) -> str: ...  # undocumented
 def py_encode_basestring_ascii(s: str) -> str: ...  # undocumented
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/operator.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/operator.pyi
@@ -61,9 +61,6 @@ __all__ = [
 if sys.version_info >= (3, 11):
    __all__ += ["call"]

-if sys.version_info >= (3, 14):
-    __all__ += ["is_none", "is_not_none"]
-
 __lt__ = lt
 __le__ = le
 __eq__ = eq
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/os/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/os/init.pyi
@@ -365,9 +365,7 @@ class stat_result(structseq[float], tuple[int, int, int, int, int, int, int, flo
    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."""
+            "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:
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/poplib.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/poplib.pyi
@@ -67,6 +67,5 @@ class POP3_SSL(POP3):
            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
+        # "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: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pyexpat/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pyexpat/init.pyi
@@ -15,9 +15,9 @@ class ExpatError(Exception):
    offset: int

 error = ExpatError
-XML_PARAM_ENTITY_PARSING_NEVER: Final = 0
-XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE: Final = 1
-XML_PARAM_ENTITY_PARSING_ALWAYS: Final = 2
+XML_PARAM_ENTITY_PARSING_NEVER: int
+XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE: int
+XML_PARAM_ENTITY_PARSING_ALWAYS: int

 _Model: TypeAlias = tuple[int, int, str | None, tuple[Any, ...]]

--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pyexpat/errors.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pyexpat/errors.pyi
@@ -1,51 +1,49 @@
 import sys
-from typing import Final
-from typing_extensions import LiteralString

 codes: dict[str, int]
 messages: dict[int, 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]
+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
 if sys.version_info >= (3, 11):
-    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]
+    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
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pyexpat/model.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/pyexpat/model.pyi
@@ -1,13 +1,11 @@
-from typing import Final
+XML_CTYPE_ANY: int
+XML_CTYPE_CHOICE: int
+XML_CTYPE_EMPTY: int
+XML_CTYPE_MIXED: int
+XML_CTYPE_NAME: int
+XML_CTYPE_SEQ: 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
+XML_CQUANT_NONE: int
+XML_CQUANT_OPT: int
+XML_CQUANT_PLUS: int
+XML_CQUANT_REP: int
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/socketserver.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/socketserver.pyi
@@ -3,9 +3,8 @@ 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, ClassVar
+from typing import Any, BinaryIO, ClassVar
 from typing_extensions import Self, TypeAlias

 __all__ = [
@@ -159,11 +158,11 @@ class StreamRequestHandler(BaseRequestHandler):
    timeout: ClassVar[float | None]  # undocumented
    disable_nagle_algorithm: ClassVar[bool]  # undocumented
    connection: Any  # undocumented
-    rfile: BufferedIOBase
-    wfile: BufferedIOBase
+    rfile: BinaryIO
+    wfile: BinaryIO

 class DatagramRequestHandler(BaseRequestHandler):
-    packet: bytes  # undocumented
+    packet: _socket  # undocumented
    socket: _socket  # undocumented
-    rfile: BufferedIOBase
-    wfile: BufferedIOBase
+    rfile: BinaryIO
+    wfile: BinaryIO
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/constants.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/constants.pyi
@@ -1,12 +1,12 @@
 from typing import Final

 # These are not actually bools. See #4669
-NO: Final[bool]
-YES: Final[bool]
-TRUE: Final[bool]
-FALSE: Final[bool]
-ON: Final[bool]
-OFF: Final[bool]
+NO: bool
+YES: bool
+TRUE: bool
+FALSE: bool
+ON: bool
+OFF: bool
 N: Final = "n"
 S: Final = "s"
 W: Final = "w"
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/dialog.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/dialog.pyi
@@ -2,12 +2,12 @@ import sys
 from _typeshed import Incomplete
 from collections.abc import Mapping
 from tkinter import Widget
-from typing import Any, Final
+from typing import Any

 if sys.version_info >= (3, 9):
    __all__ = ["Dialog"]

-DIALOG_ICON: Final = "questhead"
+DIALOG_ICON: str

 class Dialog(Widget):
    widgetName: str
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/messagebox.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/messagebox.pyi
@@ -1,6 +1,6 @@
 import sys
 from tkinter.commondialog import Dialog
-from typing import ClassVar, Final
+from typing import ClassVar

 if sys.version_info >= (3, 9):
    __all__ = [
@@ -14,22 +14,22 @@ if sys.version_info >= (3, 9):
        "askretrycancel",
    ]

-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"
+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

 class Message(Dialog):
    command: ClassVar[str]
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/ttk.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/tkinter/ttk.pyi
@@ -556,9 +556,7 @@ class Notebook(Widget):
        sticky: str = ...,  # consists of letters 'n', 's', 'w', 'e', no repeats, may be empty
        padding: _Padding = ...,
        text: str = ...,
-        # `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=...,
+        image=...,  # Sequence of an image name, followed by zero or more (sequences of one or more state names followed by an image name)
        compound: tkinter._Compound = ...,
        underline: int = ...,
    ) -> None: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/typing.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/typing.pyi
@@ -2,7 +2,7 @@
 # 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 collections  # noqa: F401  # pyright: ignore
 import sys
 import typing_extensions
 from _collections_abc import dict_items, dict_keys, dict_values
@@ -800,12 +800,18 @@ class IO(Iterator[AnyStr]):
    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: ...
    @abstractmethod
    @overload
+    def writelines(self: IO[str], lines: Iterable[str], /) -> None: ...
+    @abstractmethod
+    @overload
    def writelines(self: IO[bytes], lines: Iterable[ReadableBuffer], /) -> None: ...
    @abstractmethod
    @overload
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/unittest/runner.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/unittest/runner.pyi
@@ -2,52 +2,36 @@ import sys
 import unittest.case
 import unittest.result
 import unittest.suite
-from _typeshed import SupportsFlush, SupportsWrite
+from _typeshed import Incomplete
 from collections.abc import Callable, Iterable
-from typing import Any, Generic, Protocol, TypeVar
-from typing_extensions import Never, TypeAlias
+from typing import TextIO
+from typing_extensions import TypeAlias

-_ResultClassType: TypeAlias = Callable[[_TextTestStream, bool, int], TextTestResult]
+_ResultClassType: TypeAlias = Callable[[TextIO, bool, int], 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) -> str: ...
-
-# _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(_TextTestStream):
-    def __init__(self, stream: _TextTestStream) -> 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
-
-_StreamT = TypeVar("_StreamT", bound=_TextTestStream, default=_WritelnDecorator)
-
-class TextTestResult(unittest.result.TestResult, Generic[_StreamT]):
+class TextTestResult(unittest.result.TestResult):
    descriptions: bool  # undocumented
    dots: bool  # undocumented
    separator1: str
    separator2: str
    showAll: bool  # undocumented
-    stream: _StreamT  # undocumented
+    stream: TextIO  # undocumented
    if sys.version_info >= (3, 12):
        durations: unittest.result._DurationsType | None
        def __init__(
-            self, stream: _StreamT, descriptions: bool, verbosity: int, *, durations: unittest.result._DurationsType | None = None
+            self, stream: TextIO, descriptions: bool, verbosity: int, *, durations: unittest.result._DurationsType | None = None
        ) -> None: ...
    else:
-        def __init__(self, stream: _StreamT, descriptions: bool, verbosity: int) -> None: ...
+        def __init__(self, stream: TextIO, 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
-    stream: _WritelnDecorator
+    # TODO: add `_WritelnDecorator` type
+    # stream: _WritelnDecorator
+    stream: Incomplete
    descriptions: bool
    verbosity: int
    failfast: bool
@@ -59,7 +43,7 @@ class TextTestRunner:
        durations: unittest.result._DurationsType | None
        def __init__(
            self,
-            stream: _SupportsWriteAndFlush | None = None,
+            stream: TextIO | None = None,
            descriptions: bool = True,
            verbosity: int = 1,
            failfast: bool = False,
@@ -73,7 +57,7 @@ class TextTestRunner:
    else:
        def __init__(
            self,
-            stream: _SupportsWriteAndFlush | None = None,
+            stream: TextIO | None = None,
            descriptions: bool = True,
            verbosity: int = 1,
            failfast: bool = False,
@@ -84,5 +68,5 @@ class TextTestRunner:
            tb_locals: bool = False,
        ) -> None: ...

-    def _makeResult(self) -> TextTestResult: ...
-    def run(self, test: unittest.suite.TestSuite | unittest.case.TestCase) -> TextTestResult: ...
+    def _makeResult(self) -> unittest.result.TestResult: ...
+    def run(self, test: unittest.suite.TestSuite | unittest.case.TestCase) -> unittest.result.TestResult: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/zipfile/init.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/zipfile/init.pyi
@@ -304,7 +304,6 @@ else:

    class Path:
        root: CompleteDirs
-        at: str
        def __init__(self, root: ZipFile | StrPath | IO[bytes], at: str = "") -> None: ...
        @property
        def name(self) -> str: ...
--- a/crates/red_knot_python_semantic/vendor/typeshed/stdlib/zipfile/_path.pyi
+++ b/crates/red_knot_python_semantic/vendor/typeshed/stdlib/zipfile/_path.pyi
@@ -31,7 +31,6 @@ if sys.version_info >= (3, 12):

    class Path:
        root: CompleteDirs
-        at: str
        def __init__(self, root: ZipFile | StrPath | IO[bytes], at: str = "") -> None: ...
        @property
        def name(self) -> str: ...
--- a/crates/red_knot_wasm/tests/api.rs
+++ b/crates/red_knot_wasm/tests/api.rs
@@ -11,14 +11,14 @@ fn check() {
    };
    let mut workspace = Workspace::new("/", &settings).expect("Workspace to be created");

-    workspace
+    let test = workspace
        .open_file("test.py", "import random22\n")
        .expect("File to be opened");

-    let result = workspace.check().expect("Check to succeed");
+    let result = workspace.check_file(&test).expect("Check to succeed");

    assert_eq!(
        result,
-        vec!["/test.py:1:8: Cannot resolve import 'random22'."]
+        vec!["/test.py:1:8: Import 'random22' could not be resolved.",]
    );
 }
--- a/crates/red_knot_workspace/Cargo.toml
+++ b/crates/red_knot_workspace/Cargo.toml
@@ -22,14 +22,12 @@ ruff_text_size = { workspace = true }
 anyhow = { workspace = true }
 crossbeam = { workspace = true }
 notify = { workspace = true }
-rayon = { workspace = true }
 rustc-hash = { workspace = true }
 salsa = { workspace = true }
 tracing = { workspace = true }

 [dev-dependencies]
-ruff_db = { workspace = true, features = ["testing"] }
-tempfile = { workspace = true }
+ruff_db = { workspace = true, features = ["testing"]}

 [lints]
 workspace = true
--- a/crates/red_knot_workspace/resources/test/corpus/25_func_annotations_same_name.py
+++ b/crates/red_knot_workspace/resources/test/corpus/25_func_annotations_same_name.py
@@ -1,11 +0,0 @@
-def bool(x) -> bool:
-    return True
-
-
-class MyClass: ...
-
-
-def MyClass() -> MyClass: ...
-
-
-def x(self) -> x: ...
--- a/crates/red_knot_workspace/resources/test/corpus/26_func_defaults_same_name.py
+++ b/crates/red_knot_workspace/resources/test/corpus/26_func_defaults_same_name.py
@@ -1,2 +0,0 @@
-def bool(x=bool):
-    return x
--- a/crates/red_knot_workspace/src/db.rs
+++ b/crates/red_knot_workspace/src/db.rs
@@ -56,8 +56,6 @@ impl RootDatabase {
    }

    pub fn check_file(&self, file: File) -> Result<Vec<String>, Cancelled> {
-        let _span = tracing::debug_span!("check_file", file=%file.path(self)).entered();
-
        self.with_db(|db| check_file(db, file))
    }

--- a/crates/red_knot_workspace/src/lint.rs
+++ b/crates/red_knot_workspace/src/lint.rs
@@ -164,7 +164,7 @@ fn lint_bad_override(context: &SemanticLintContext, class: &ast::StmtClassDef) {
        if ty.has_decorator(db, override_ty) {
            let method_name = ty.name(db);
            if class_ty
-                .inherited_class_member(db, method_name)
+                .inherited_class_member(db, &method_name)
                .is_unbound()
            {
                // TODO should have a qualname() method to support nested classes
--- a/crates/red_knot_workspace/src/workspace.rs
+++ b/crates/red_knot_workspace/src/workspace.rs
@@ -15,8 +15,7 @@ use ruff_db::{
 use ruff_python_ast::{name::Name, PySourceType};
 use ruff_text_size::Ranged;

-use crate::db::RootDatabase;
-use crate::workspace::files::{Index, Indexed, IndexedIter, PackageFiles};
+use crate::workspace::files::{Index, Indexed, PackageFiles};
 use crate::{
    db::Db,
    lint::{lint_semantic, lint_syntax},
@@ -191,35 +190,23 @@ impl Workspace {
    }

    /// Checks all open files in the workspace and its dependencies.
-    pub fn check(self, db: &RootDatabase) -> Vec<String> {
-        let workspace_span = tracing::debug_span!("check_workspace");
-        let _span = workspace_span.enter();
-
+    #[tracing::instrument(level = "debug", skip_all)]
+    pub fn check(self, db: &dyn Db) -> Vec<String> {
        tracing::debug!("Checking workspace");
-        let files = WorkspaceFiles::new(db, self);
-        let result = Arc::new(std::sync::Mutex::new(Vec::new()));
-        let inner_result = Arc::clone(&result);

-        let db = db.snapshot();
-        let workspace_span = workspace_span.clone();
+        let mut result = Vec::new();

-        rayon::scope(move |scope| {
-            for file in &files {
-                let result = inner_result.clone();
-                let db = db.snapshot();
-                let workspace_span = workspace_span.clone();
-
-                scope.spawn(move |_| {
-                    let check_file_span = tracing::debug_span!(parent: &workspace_span, "check_file", file=%file.path(&db));
-                    let _entered = check_file_span.entered();
-
-                    let file_diagnostics = check_file(&db, file);
-                    result.lock().unwrap().extend(file_diagnostics);
-                });
+        if let Some(open_files) = self.open_files(db) {
+            for file in open_files {
+                result.extend_from_slice(&check_file(db, *file));
            }
-        });
+        } else {
+            for package in self.packages(db) {
+                result.extend(package.check(db));
+            }
+        }

-        Arc::into_inner(result).unwrap().into_inner().unwrap()
+        result
    }

    /// Opens a file in the workspace.
@@ -297,6 +284,7 @@ impl Workspace {
    }
 }

+#[salsa::tracked]
 impl Package {
    pub fn root(self, db: &dyn Db) -> &SystemPath {
        self.root_buf(db)
@@ -336,6 +324,19 @@ impl Package {
        index.insert(file);
    }

+    #[tracing::instrument(level = "debug", skip(db))]
+    pub(crate) fn check(self, db: &dyn Db) -> Vec<String> {
+        tracing::debug!("Checking package '{}'", self.root(db));
+
+        let mut result = Vec::new();
+        for file in &self.files(db) {
+            let diagnostics = check_file(db, file);
+            result.extend_from_slice(&diagnostics);
+        }
+
+        result
+    }
+
    /// Returns the files belonging to this package.
    pub fn files(self, db: &dyn Db) -> Indexed<'_> {
        let files = self.file_set(db);
@@ -383,7 +384,9 @@ impl Package {

 #[salsa::tracked]
 pub(super) fn check_file(db: &dyn Db, file: File) -> Vec<String> {
-    tracing::debug!("Checking file '{path}'", path = file.path(db));
+    let path = file.path(db);
+    let _span = tracing::debug_span!("check_file", file=%path).entered();
+    tracing::debug!("Checking file '{path}'");

    let mut diagnostics = Vec::new();

@@ -471,73 +474,6 @@ fn discover_package_files(db: &dyn Db, path: &SystemPath) -> FxHashSet<File> {
    files
 }

-#[derive(Debug)]
-enum WorkspaceFiles<'a> {
-    OpenFiles(&'a FxHashSet<File>),
-    PackageFiles(Vec<Indexed<'a>>),
-}
-
-impl<'a> WorkspaceFiles<'a> {
-    fn new(db: &'a dyn Db, workspace: Workspace) -> Self {
-        if let Some(open_files) = workspace.open_files(db) {
-            WorkspaceFiles::OpenFiles(open_files)
-        } else {
-            WorkspaceFiles::PackageFiles(
-                workspace
-                    .packages(db)
-                    .map(|package| package.files(db))
-                    .collect(),
-            )
-        }
-    }
-}
-
-impl<'a> IntoIterator for &'a WorkspaceFiles<'a> {
-    type Item = File;
-    type IntoIter = WorkspaceFilesIter<'a>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        match self {
-            WorkspaceFiles::OpenFiles(files) => WorkspaceFilesIter::OpenFiles(files.iter()),
-            WorkspaceFiles::PackageFiles(package_files) => {
-                let mut package_files = package_files.iter();
-                WorkspaceFilesIter::PackageFiles {
-                    current: package_files.next().map(IntoIterator::into_iter),
-                    package_files,
-                }
-            }
-        }
-    }
-}
-
-enum WorkspaceFilesIter<'db> {
-    OpenFiles(std::collections::hash_set::Iter<'db, File>),
-    PackageFiles {
-        package_files: std::slice::Iter<'db, Indexed<'db>>,
-        current: Option<IndexedIter<'db>>,
-    },
-}
-
-impl Iterator for WorkspaceFilesIter<'_> {
-    type Item = File;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self {
-            WorkspaceFilesIter::OpenFiles(files) => files.next().copied(),
-            WorkspaceFilesIter::PackageFiles {
-                package_files,
-                current,
-            } => loop {
-                if let Some(file) = current.as_mut().and_then(Iterator::next) {
-                    return Some(file);
-                }
-
-                *current = Some(package_files.next()?.into_iter());
-            },
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
    use ruff_db::files::system_path_to_file;
--- a/crates/red_knot_workspace/src/workspace/files.rs
+++ b/crates/red_knot_workspace/src/workspace/files.rs
@@ -158,11 +158,9 @@ impl Deref for Indexed<'_> {
    }
 }

-pub(super) type IndexedIter<'a> = std::iter::Copied<std::collections::hash_set::Iter<'a, File>>;
-
 impl<'a> IntoIterator for &'a Indexed<'_> {
    type Item = File;
-    type IntoIter = IndexedIter<'a>;
+    type IntoIter = std::iter::Copied<std::collections::hash_set::Iter<'a, File>>;

    fn into_iter(self) -> Self::IntoIter {
        self.files.iter().copied()
--- a/crates/red_knot_workspace/tests/check.rs
+++ b/crates/red_knot_workspace/tests/check.rs
@@ -21,27 +21,19 @@ fn setup_db(workspace_root: &SystemPath) -> anyhow::Result<RootDatabase> {
 #[test]
 #[allow(clippy::print_stdout)]
 fn corpus_no_panic() -> anyhow::Result<()> {
-    let root = SystemPathBuf::from_path_buf(tempfile::TempDir::new()?.into_path()).unwrap();
-    let db = setup_db(&root)?;
-
    let corpus = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("resources/test/corpus");
+    let system_corpus =
+        SystemPathBuf::from_path_buf(corpus.clone()).expect("corpus path to be UTF8");
+    let db = setup_db(&system_corpus)?;

-    for path in fs::read_dir(&corpus)? {
-        let source = path?.path();
-        println!("checking {source:?}");
-        let source_fn = source.file_name().unwrap().to_str().unwrap();
-        let py_dest = root.join(source_fn);
-        fs::copy(&source, py_dest.as_std_path())?;
+    for path in fs::read_dir(&corpus).expect("corpus to be a directory") {
+        let path = path.expect("path to not be an error").path();
+        println!("checking {path:?}");
+        let path = SystemPathBuf::from_path_buf(path.clone()).expect("path to be UTF-8");
        // this test is only asserting that we can pull every expression type without a panic
        // (and some non-expressions that clearly define a single type)
-        let file = system_path_to_file(&db, py_dest).unwrap();
-        pull_types(&db, file);
+        let file = system_path_to_file(&db, path).expect("file to exist");

-        // try the file as a stub also
-        println!("re-checking as .pyi");
-        let pyi_dest = root.join(format!("{source_fn}i"));
-        std::fs::copy(source, pyi_dest.as_std_path())?;
-        let file = system_path_to_file(&db, pyi_dest).unwrap();
        pull_types(&db, file);
    }
    Ok(())
--- a/crates/ruff/Cargo.toml
+++ b/crates/ruff/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.6.4"
+version = "0.6.2"
 publish = true
 authors = { workspace = true }
 edition = { workspace = true }
--- a/crates/ruff/src/commands/format.rs
+++ b/crates/ruff/src/commands/format.rs
@@ -810,11 +810,7 @@ pub(super) fn warn_incompatible_formatter_settings(resolver: &Resolver) {
            .map(|rule| format!("`{}`", rule.noqa_code()))
            .collect();
        rule_names.sort();
-        if let [rule] = rule_names.as_slice() {
-            warn_user_once!("The following rule may cause conflicts when used with the formatter: {rule}. To avoid unexpected behavior, we recommend disabling this rule, either by removing it from the `select` or `extend-select` configuration, or adding it to the `ignore` configuration.");
-        } else {
-            warn_user_once!("The following rules may cause conflicts when used with the formatter: {}. To avoid unexpected behavior, we recommend disabling these rules, either by removing them from the `select` or `extend-select` configuration, or adding them to the `ignore` configuration.", rule_names.join(", "));
-        }
+        warn_user_once!("The following rules may cause conflicts when used with the formatter: {}. To avoid unexpected behavior, we recommend disabling these rules, either by removing them from the `select` or `extend-select` configuration, or adding them to the `ignore` configuration.", rule_names.join(", "));
    }

    // Next, validate settings-specific incompatibilities.
--- a/crates/ruff/src/printer.rs
+++ b/crates/ruff/src/printer.rs
@@ -151,15 +151,15 @@ impl Printer {
                    let fix_prefix = format!("[{}]", "*".cyan());

                    if self.unsafe_fixes.is_hint() {
-                        if fixables.applicable > 0 && fixables.inapplicable_unsafe > 0 {
-                            let es = if fixables.inapplicable_unsafe == 1 {
+                        if fixables.applicable > 0 && fixables.unapplicable_unsafe > 0 {
+                            let es = if fixables.unapplicable_unsafe == 1 {
                                ""
                            } else {
                                "es"
                            };
                            writeln!(writer,
                                "{fix_prefix} {} fixable with the `--fix` option ({} hidden fix{es} can be enabled with the `--unsafe-fixes` option).",
-                                fixables.applicable, fixables.inapplicable_unsafe
+                                fixables.applicable, fixables.unapplicable_unsafe
                            )?;
                        } else if fixables.applicable > 0 {
                            // Only applicable fixes
@@ -169,15 +169,15 @@ impl Printer {
                                fixables.applicable,
                            )?;
                        } else {
-                            // Only inapplicable fixes
-                            let es = if fixables.inapplicable_unsafe == 1 {
+                            // Only unapplicable fixes
+                            let es = if fixables.unapplicable_unsafe == 1 {
                                ""
                            } else {
                                "es"
                            };
                            writeln!(writer,
                                "No fixes available ({} hidden fix{es} can be enabled with the `--unsafe-fixes` option).",
-                                fixables.inapplicable_unsafe
+                                fixables.unapplicable_unsafe
                            )?;
                        }
                    } else {
@@ -194,7 +194,7 @@ impl Printer {
                // Check if there are unapplied fixes
                let unapplied = {
                    if let Some(fixables) = fixables {
-                        fixables.inapplicable_unsafe
+                        fixables.unapplicable_unsafe
                    } else {
                        0
                    }
@@ -545,33 +545,33 @@ fn print_fix_summary(writer: &mut dyn Write, fixed: &FixMap) -> Result<()> {
 #[derive(Debug)]
 struct FixableStatistics {
    applicable: u32,
-    inapplicable_unsafe: u32,
+    unapplicable_unsafe: u32,
 }

 impl FixableStatistics {
    fn try_from(diagnostics: &Diagnostics, unsafe_fixes: UnsafeFixes) -> Option<Self> {
        let mut applicable = 0;
-        let mut inapplicable_unsafe = 0;
+        let mut unapplicable_unsafe = 0;

        for message in &diagnostics.messages {
            if let Some(fix) = message.fix() {
                if fix.applies(unsafe_fixes.required_applicability()) {
                    applicable += 1;
                } else {
-                    // Do not include inapplicable fixes at other levels that do not provide an opt-in
+                    // Do not include unapplicable fixes at other levels that do not provide an opt-in
                    if fix.applicability().is_unsafe() {
-                        inapplicable_unsafe += 1;
+                        unapplicable_unsafe += 1;
                    }
                }
            }
        }

-        if applicable == 0 && inapplicable_unsafe == 0 {
+        if applicable == 0 && unapplicable_unsafe == 0 {
            None
        } else {
            Some(Self {
                applicable,
-                inapplicable_unsafe,
+                unapplicable_unsafe,
            })
        }
    }
--- a/crates/ruff/tests/format.rs
+++ b/crates/ruff/tests/format.rs
@@ -785,7 +785,7 @@ if condition:
    	print('Should change quotes')

    ----- stderr -----
-    warning: The following rule may cause conflicts when used with the formatter: `COM812`. To avoid unexpected behavior, we recommend disabling this rule, either by removing it from the `select` or `extend-select` configuration, or adding it to the `ignore` configuration.
+    warning: The following rules may cause conflicts when used with the formatter: `COM812`. To avoid unexpected behavior, we recommend disabling these rules, either by removing them from the `select` or `extend-select` configuration, or adding them to the `ignore` configuration.
    "###);
    Ok(())
 }
--- a/crates/ruff_benchmark/Cargo.toml
+++ b/crates/ruff_benchmark/Cargo.toml
@@ -37,14 +37,13 @@ name = "red_knot"
 harness = false

 [dependencies]
-codspeed-criterion-compat = { workspace = true, default-features = false, optional = true }
-criterion = { workspace = true, default-features = false }
 once_cell = { workspace = true }
-rayon = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 url = { workspace = true }
 ureq = { workspace = true }
+criterion = { workspace = true, default-features = false }
+codspeed-criterion-compat = { workspace = true, default-features = false, optional = true }

 [dev-dependencies]
 ruff_db = { workspace = true }
--- a/crates/ruff_benchmark/benches/red_knot.rs
+++ b/crates/ruff_benchmark/benches/red_knot.rs
@@ -1,6 +1,5 @@
 #![allow(clippy::disallowed_names)]

-use rayon::ThreadPoolBuilder;
 use red_knot_python_semantic::PythonVersion;
 use red_knot_workspace::db::RootDatabase;
 use red_knot_workspace::watch::{ChangeEvent, ChangedKind};
@@ -21,9 +20,18 @@ struct Case {

 const TOMLLIB_312_URL: &str = "https://raw.githubusercontent.com/python/cpython/8e8a4baf652f6e1cee7acde9d78c4b6154539748/Lib/tomllib";

-// The failed import from 'collections.abc' is due to lack of support for 'import *'.
+// This first "unresolved import" is because we don't understand `*` imports yet.
+// The following "unresolved import" violations are because we can't distinguish currently from
+// "Symbol exists in the module but its type is unknown" and
+// "Symbol does not exist in the module"
 static EXPECTED_DIAGNOSTICS: &[&str] = &[
-    "/src/tomllib/_parser.py:7:29: Module 'collections.abc' has no member 'Iterable'",
+    "/src/tomllib/_parser.py:7:29: Could not resolve import of 'Iterable' from 'collections.abc'",
+    "/src/tomllib/_parser.py:10:20: Could not resolve import of 'Any' from 'typing'",
+    "/src/tomllib/_parser.py:13:5: Could not resolve import of 'RE_DATETIME' from '._re'",
+    "/src/tomllib/_parser.py:14:5: Could not resolve import of 'RE_LOCALTIME' from '._re'",
+    "/src/tomllib/_parser.py:15:5: Could not resolve import of 'RE_NUMBER' from '._re'",
+    "/src/tomllib/_parser.py:20:21: Could not resolve import of 'Key' from '._types'",
+    "/src/tomllib/_parser.py:20:26: Could not resolve import of 'ParseFloat' from '._types'",
    "Line 69 is too long (89 characters)",
    "Use double quotes for strings",
    "Use double quotes for strings",
@@ -32,7 +40,25 @@ static EXPECTED_DIAGNOSTICS: &[&str] = &[
    "Use double quotes for strings",
    "Use double quotes for strings",
    "Use double quotes for strings",
+    "/src/tomllib/_parser.py:153:22: Name 'key' used when not defined.",
+    "/src/tomllib/_parser.py:153:27: Name 'flag' used when not defined.",
+    "/src/tomllib/_parser.py:159:16: Name 'k' used when not defined.",
+    "/src/tomllib/_parser.py:161:25: Name 'k' used when not defined.",
+    "/src/tomllib/_parser.py:168:16: Name 'k' used when not defined.",
+    "/src/tomllib/_parser.py:169:22: Name 'k' used when not defined.",
+    "/src/tomllib/_parser.py:170:25: Name 'k' used when not defined.",
+    "/src/tomllib/_parser.py:180:16: Name 'k' used when not defined.",
+    "/src/tomllib/_parser.py:182:31: Name 'k' used when not defined.",
+    "/src/tomllib/_parser.py:206:16: Name 'k' used when not defined.",
+    "/src/tomllib/_parser.py:207:22: Name 'k' used when not defined.",
+    "/src/tomllib/_parser.py:208:25: Name 'k' used when not defined.",
+    "/src/tomllib/_parser.py:330:32: Name 'header' used when not defined.",
+    "/src/tomllib/_parser.py:330:41: Name 'key' used when not defined.",
+    "/src/tomllib/_parser.py:333:26: Name 'cont_key' used when not defined.",
+    "/src/tomllib/_parser.py:334:71: Name 'cont_key' used when not defined.",
+    "/src/tomllib/_parser.py:337:31: Name 'cont_key' used when not defined.",
    "/src/tomllib/_parser.py:628:75: Name 'e' used when not defined.",
+    "/src/tomllib/_parser.py:686:23: Name 'parse_float' used when not defined.",
 ];

 fn get_test_file(name: &str) -> TestFile {
@@ -86,25 +112,7 @@ fn setup_case() -> Case {
    }
 }

-static RAYON_INITIALIZED: std::sync::Once = std::sync::Once::new();
-
-fn setup_rayon() {
-    // Initialize the rayon thread pool outside the benchmark because it has a significant cost.
-    // We limit the thread pool to only one (the current thread) because we're focused on
-    // where red knot spends time and less about how well the code runs concurrently.
-    // We might want to add a benchmark focusing on concurrency to detect congestion in the future.
-    RAYON_INITIALIZED.call_once(|| {
-        ThreadPoolBuilder::new()
-            .num_threads(1)
-            .use_current_thread()
-            .build_global()
-            .unwrap();
-    });
-}
-
 fn benchmark_incremental(criterion: &mut Criterion) {
-    setup_rayon();
-
    criterion.bench_function("red_knot_check_file[incremental]", |b| {
        b.iter_batched_ref(
            || {
@@ -141,8 +149,6 @@ fn benchmark_incremental(criterion: &mut Criterion) {
 }

 fn benchmark_cold(criterion: &mut Criterion) {
-    setup_rayon();
-
    criterion.bench_function("red_knot_check_file[cold]", |b| {
        b.iter_batched_ref(
            setup_case,
--- a/crates/ruff_db/src/files.rs
+++ b/crates/ruff_db/src/files.rs
@@ -8,7 +8,6 @@ use salsa::{Durability, Setter};
 pub use file_root::{FileRoot, FileRootKind};
 pub use path::FilePath;
 use ruff_notebook::{Notebook, NotebookError};
-use ruff_python_ast::PySourceType;

 use crate::file_revision::FileRevision;
 use crate::files::file_root::FileRoots;
@@ -425,13 +424,6 @@ impl File {
    pub fn exists(self, db: &dyn Db) -> bool {
        self.status(db) == FileStatus::Exists
    }
-
-    /// Returns `true` if the file should be analyzed as a type stub.
-    pub fn is_stub(self, db: &dyn Db) -> bool {
-        self.path(db)
-            .extension()
-            .is_some_and(|extension| PySourceType::from_extension(extension).is_stub())
-    }
 }

 /// A virtual file that doesn't exist on the file system.
--- a/crates/ruff_linter/Cargo.toml
+++ b/crates/ruff_linter/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.6.4"
+version = "0.6.2"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }
--- a/crates/ruff_linter/resources/test/fixtures/fastapi/FAST002.py
+++ b/crates/ruff_linter/resources/test/fixtures/fastapi/FAST002.py
@@ -17,7 +17,7 @@ app = FastAPI()
 router = APIRouter()


-# Fixable errors
+# Errors

@app.get("/items/")
 def get_items(
@@ -40,34 +40,6 @@ def do_stuff(
    # do stuff
    pass

-@app.get("/users/")
-def get_users(
-    skip: int,
-    limit: int,
-    current_user: User = Depends(get_current_user),
-):
-    pass
-
-@app.get("/users/")
-def get_users(
-    current_user: User = Depends(get_current_user),
-    skip: int = 0,
-    limit: int = 10,
-):
-    pass
-
-
-
-# Non fixable errors
-
-@app.get("/users/")
-def get_users(
-    skip: int = 0,
-    limit: int = 10,
-    current_user: User = Depends(get_current_user),
-):
-    pass
-

 # Unchanged

--- a/crates/ruff_linter/resources/test/fixtures/flake8_builtins/A004.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_builtins/A004.py
@@ -3,9 +3,3 @@ import float
 from some import other as int
 from some import input, exec
 from directory import new as dir
-
-# See: https://github.com/astral-sh/ruff/issues/13037
-import sys
-
-if sys.version_info < (3, 11):
-    from exceptiongroup import BaseExceptionGroup, ExceptionGroup
--- a/crates/ruff_linter/resources/test/fixtures/flake8_implicit_str_concat/ISC.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_implicit_str_concat/ISC.py
@@ -79,15 +79,3 @@ _ = f"a {f"first"
    + f"second"} d"
 _ = f"a {f"first {f"middle"}"
    + f"second"} d"
-
-# See https://github.com/astral-sh/ruff/issues/12936
-_ = "\12""0" # fix should be "\0120"
-_ = "\\12""0" # fix should be "\\120"
-_ = "\\\12""0" # fix should be "\\\0120"
-_ = "\12 0""0" # fix should be "\12 00"
-_ = r"\12"r"0" # fix should be r"\120"
-_ = "\12 and more""0" # fix should be "\12 and more0"
-_ = "\8""0" # fix should be "\80"
-_ = "\12""8" # fix should be "\128"
-_ = "\12""foo" # fix should be "\12foo"
-_ = "\12" ""  # fix should be "\12"
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI019.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI019.py
@@ -44,11 +44,3 @@ class PEP695BadDunderNew[T]:

 class PEP695GoodDunderNew[T]:
  def __new__(cls, *args: Any, **kwargs: Any) -> Self: ...
-
-
-class CustomClassMethod:
-   # Should be recognised as a classmethod decorator
-   # due to `foo_classmethod being listed in `pep8_naming.classmethod-decorators`
-   # in the settings for this test:
-   @foo_classmethod
-   def foo[S](cls: type[S]) -> S: ...  # PYI019
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI019.pyi
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI019.pyi
@@ -44,11 +44,3 @@ class PEP695BadDunderNew[T]:

 class PEP695GoodDunderNew[T]:
  def __new__(cls, *args: Any, **kwargs: Any) -> Self: ...
-
-
-class CustomClassMethod:
-   # Should be recognised as a classmethod decorator
-   # due to `foo_classmethod being listed in `pep8_naming.classmethod-decorators`
-   # in the settings for this test:
-   @foo_classmethod
-   def foo[S](cls: type[S]) -> S: ...  # PYI019
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI032.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI032.py
@@ -3,8 +3,8 @@ import typing


 class Bad:
-    def __eq__(self, other: Any) -> bool: ...  # PYI032
-    def __ne__(self, other: typing.Any) -> typing.Any: ...  # PYI032
+    def __eq__(self, other: Any) -> bool: ...  # Y032
+    def __ne__(self, other: typing.Any) -> typing.Any: ...  # Y032


 class Good:
@@ -22,7 +22,3 @@ class Unannotated:
  def __eq__(self) -> Any: ...
  def __ne__(self) -> bool: ...

-
-class BadStringized:
-   def __eq__(self, other: "Any") -> bool: ...  # PYI032
-   def __ne__(self, other: "Any") -> bool: ...  # PYI032
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI032.pyi
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI032.pyi
@@ -3,8 +3,8 @@ import typing


 class Bad:
-    def __eq__(self, other: Any) -> bool: ...  # PYI032
-    def __ne__(self, other: typing.Any) -> typing.Any: ...  # PYI032
+    def __eq__(self, other: Any) -> bool: ...  # Y032
+    def __ne__(self, other: typing.Any) -> typing.Any: ...  # Y032


 class Good:
@@ -22,6 +22,3 @@ class Unannotated:
  def __eq__(self) -> Any: ...
  def __ne__(self) -> bool: ...

-class BadStringized:
-   def __eq__(self, other: "Any") -> bool: ...  # PYI032
-   def __ne__(self, other: "Any") -> bool: ...  # PYI032
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI034.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI034.py
@@ -317,7 +317,3 @@ def __ne__(self, other: Any) -> bool:

 def __imul__(self, other: Any) -> list[str]:
    ...
-
-class UsesStringizedAnnotations:
-    def __iadd__(self, other: "UsesStringizedAnnotations") -> "typing.Self":
-        return self
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI034.pyi
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI034.pyi
@@ -212,6 +212,3 @@ def __str__(self) -> str: ...
 def __eq__(self, other: Any) -> bool: ...
 def __ne__(self, other: Any) -> bool: ...
 def __imul__(self, other: Any) -> list[str]: ...
-
-class UsesStringizedAnnotations:
-    def __iadd__(self, other: "UsesStringizedAnnotations") -> "typing.Self": ...
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI050.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI050.py
@@ -30,11 +30,3 @@ def foo_no_return_pos_only(arg: int, /, arg2: NoReturn):

 def foo_never(arg: Never):
    ...
-
-
-def stringized(arg: "NoReturn"):
-    ...
-
-
-def stringized_good(arg: "Never"):
-    ...
--- a/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI050.pyi
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_pyi/PYI050.pyi
@@ -21,5 +21,3 @@ def foo_int_kwargs_no_return(*args: NoReturn, **kwargs: int): ...  # Error: PYI0
 def foo_args_never(*args: Never): ...
 def foo_kwargs_never(**kwargs: Never): ...
 def foo_args_kwargs_never(*args: Never, **kwargs: Never): ...
-def stringized(arg: "NoReturn"): ...
-def stringized_good(arg: "Never"): ...
--- a/crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM115.py
+++ b/crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM115.py
@@ -243,16 +243,3 @@ def aliased():
    from tarfile import TarFile as TF
    f = TF("foo").open()
    f.close()
-
-import dbm.sqlite3
-
-# OK
-with dbm.sqlite3.open("foo.db") as f:
-    print(f.keys())
-
-# OK
-dbm.sqlite3.open("foo.db").close()
-
-# SIM115
-f = dbm.sqlite3.open("foo.db")
-f.close()
--- a/crates/ruff_linter/resources/test/fixtures/pycodestyle/E741.pyi
+++ b/crates/ruff_linter/resources/test/fixtures/pycodestyle/E741.pyi
@@ -1,75 +0,0 @@
-from contextlib import contextmanager
-
-l = 0
-I = 0
-O = 0
-l: int = 0
-
-a, l = 0, 1
-[a, l] = 0, 1
-a, *l = 0, 1, 2
-a = l = 0
-
-o = 0
-i = 0
-
-for l in range(3):
-    pass
-
-
-for a, l in zip(range(3), range(3)):
-    pass
-
-
-def f1():
-    global l
-    l = 0
-
-
-def f2():
-    l = 0
-
-    def f3():
-        nonlocal l
-        l = 1
-
-    f3()
-    return l
-
-
-def f4(l, /, I):
-    return l, I, O
-
-
-def f5(l=0, *, I=1):
-    return l, I
-
-
-def f6(*l, **I):
-    return l, I
-
-
-@contextmanager
-def ctx1():
-    yield 0
-
-
-with ctx1() as l:
-    pass
-
-
-@contextmanager
-def ctx2():
-    yield 0, 1
-
-
-with ctx2() as (a, l):
-    pass
-
-try:
-    pass
-except ValueError as l:
-    pass
-
-if (l := 5) > 0:
-    pass
--- a/crates/ruff_linter/resources/test/fixtures/pydoclint/DOC201_google.py
+++ b/crates/ruff_linter/resources/test/fixtures/pydoclint/DOC201_google.py
@@ -119,91 +119,3 @@ class A(metaclass=abc.abcmeta):
    def f(self):
        """Lorem ipsum."""
        return True
-
-
-# OK - implicit None early return
-def foo(obj: object) -> None:
-    """A very helpful docstring.
-
-    Args:
-        obj (object): An object.
-    """
-    if obj is None:
-        return
-    print(obj)
-
-
-# OK - explicit None early return
-def foo(obj: object) -> None:
-    """A very helpful docstring.
-
-    Args:
-        obj (object): An object.
-    """
-    if obj is None:
-        return None
-    print(obj)
-
-
-# OK - explicit None early return w/o useful type annotations
-def foo(obj):
-    """A very helpful docstring.
-
-    Args:
-        obj (object): An object.
-    """
-    if obj is None:
-        return None
-    print(obj)
-
-
-# OK - multiple explicit None early returns
-def foo(obj: object) -> None:
-    """A very helpful docstring.
-
-    Args:
-        obj (object): An object.
-    """
-    if obj is None:
-        return None
-    if obj == "None":
-        return
-    if obj == 0:
-        return None
-    print(obj)
-
-
-# DOC201 - non-early return explicit None
-def foo(x: int) -> int | None:
-    """A very helpful docstring.
-
-    Args:
-        x (int): An interger.
-    """
-    if x < 0:
-        return None
-    else:
-        return x
-
-
-# DOC201 - non-early return explicit None w/o useful type annotations
-def foo(x):
-    """A very helpful docstring.
-
-    Args:
-        x (int): An interger.
-    """
-    if x < 0:
-        return None
-    else:
-        return x
-
-
-# DOC201 - only returns None, but return annotation is not None
-def foo(s: str) -> str | None:
-    """A very helpful docstring.
-
-    Args:
-        s (str): A string.
-    """
-    return None
--- a/crates/ruff_linter/resources/test/fixtures/pydoclint/DOC201_numpy.py
+++ b/crates/ruff_linter/resources/test/fixtures/pydoclint/DOC201_numpy.py
@@ -85,152 +85,3 @@ class A(metaclass=abc.abcmeta):
    def f(self):
        """Lorem ipsum."""
        return True
-
-
-# OK - implicit None early return
-def foo(obj: object) -> None:
-    """A very helpful docstring.
-
-    Parameters
-    ----------
-    obj : object
-        An object.
-    """
-    if obj is None:
-        return
-    print(obj)
-
-
-# OK - explicit None early return
-def foo(obj: object) -> None:
-    """A very helpful docstring.
-
-    Parameters
-    ----------
-    obj : object
-        An object.
-    """
-    if obj is None:
-        return None
-    print(obj)
-
-
-# OK - explicit None early return w/o useful type annotations
-def foo(obj):
-    """A very helpful docstring.
-
-    Parameters
-    ----------
-    obj : object
-        An object.
-    """
-    if obj is None:
-        return None
-    print(obj)
-
-
-# OK - multiple explicit None early returns
-def foo(obj: object) -> None:
-    """A very helpful docstring.
-
-    Parameters
-    ----------
-    obj : object
-        An object.
-    """
-    if obj is None:
-        return None
-    if obj == "None":
-        return
-    if obj == 0:
-        return None
-    print(obj)
-
-
-# DOC201 - non-early return explicit None
-def foo(x: int) -> int | None:
-    """A very helpful docstring.
-
-    Parameters
-    ----------
-    x : int
-        An interger.
-    """
-    if x < 0:
-        return None
-    else:
-        return x
-
-
-# DOC201 - non-early return explicit None w/o useful type annotations
-def foo(x):
-    """A very helpful docstring.
-
-    Parameters
-    ----------
-    x : int
-        An interger.
-    """
-    if x < 0:
-        return None
-    else:
-        return x
-
-
-# DOC201 - only returns None, but return annotation is not None
-def foo(s: str) -> str | None:
-    """A very helpful docstring.
-
-    Parameters
-    ----------
-    x : str
-        A string.
-    """
-    return None
-
-
-# DOC201
-def bar() -> int | None:
-    """Bar-y method"""
-    return
-
-
-from collections.abc import Iterator, Generator
-
-
-# This is okay -- returning `None` is implied by `Iterator[str]`;
-# no need to document it
-def generator_function() -> Iterator[str]:
-    """Generate some strings"""
-    yield from "abc"
-    return
-
-
-# This is okay -- returning `None` is stated by `Generator[str, None, None]`;
-# no need to document it
-def generator_function_2() -> Generator[str, None, None]:
-    """Generate some strings"""
-    yield from "abc"
-    return
-
-
-# DOC201 -- returns None but `Generator[str, None, int | None]`
-# indicates it could sometimes return `int`
-def generator_function_3() -> Generator[str, None, int | None]:
-    """Generate some strings"""
-    yield from "abc"
-    return
-
-
-# DOC201 -- no type annotation and a non-None return
-# indicates it could sometimes return `int`
-def generator_function_4():
-    """Generate some strings"""
-    yield from "abc"
-    return 42
-
-
-# DOC201 -- no `yield` expressions, so not a generator function
-def not_a_generator() -> Iterator[int]:
-    """"No returns documented here, oh no"""
-    return (x for x in range(42))
--- a/crates/ruff_linter/resources/test/fixtures/pydoclint/DOC202_google.py
+++ b/crates/ruff_linter/resources/test/fixtures/pydoclint/DOC202_google.py
@@ -73,15 +73,3 @@ class A(metaclass=abc.abcmeta):
            dict: The values
        """
        return
-
-
-# DOC202 -- never explicitly returns anything, just short-circuits
-def foo(s: str, condition: bool):
-    """Fooey things.
-
-    Returns:
-        None
-    """
-    if not condition:
-        return
-    print(s)
--- a/crates/ruff_linter/resources/test/fixtures/pydoclint/DOC402_google.py
+++ b/crates/ruff_linter/resources/test/fixtures/pydoclint/DOC402_google.py
@@ -87,22 +87,3 @@ def f(num: int):
        num (int): A number
    """
    yield 1
-
-
-import collections.abc
-
-
-# DOC402
-def foo() -> collections.abc.Generator[int | None, None, None]:
-    """
-    Do something
-    """
-    yield
-
-
-# DOC402
-def bar() -> collections.abc.Iterator[int | None]:
-    """
-    Do something
-    """
-    yield
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Alex Waygood	09edde8e39	Try to reduce false positives more	2024-08-29 12:48:37 +01:00
Alex Waygood	6eafadbcf6	.	2024-08-23 16:47:01 +01:00
Alex Waygood	d4ada3f833	Fix new false positive	2024-08-23 14:15:03 +01:00
Alex Waygood	fdf8fc69ac	[`ruff`] Reduce false positives for `missing-fstring-syntax` (`RUF027`) by analyzing references to the binding when the string is assigned to a variable	2024-08-23 13:34:38 +01:00