here

* origin/main:
  [ty] Reachability constraints: minor documentation fixes (#21774)
  [ty] Fix non-determinism in `ConstraintSet.specialize_constrained` (#21744)
  [ty] Improve `@override`, `@final` and Liskov checks in cases where there are multiple reachable definitions (#21767)
  [ty] Extend `invalid-explicit-override` to also cover properties decorated with `@override` that do not override anything (#21756)
  [ty] Enable LRU collection for parsed module (#21749)
  [ty] Support typevar-specialized dynamic types in generic type aliases (#21730)
  Add token based `parenthesized_ranges` implementation (#21738)
  [ty] Default-specialization of generic type aliases (#21765)
  [ty] Suppress false positives when `dataclasses.dataclass(...)(cls)` is called imperatively (#21729)
  [syntax-error] Default type parameter followed by non-default type parameter (#21657)

.github/renovate.json5

@@ -75,6 +75,14 @@
       matchManagers: ["cargo"],
       enabled: false,
     },
+    {
+      // `mkdocs-material` requires a manual update to keep the version in sync
+      // with `mkdocs-material-insider`.
+      // See: https://squidfunk.github.io/mkdocs-material/insiders/upgrade/
+      matchManagers: ["pip_requirements"],
+      matchPackageNames: ["mkdocs-material"],
+      enabled: false,
+    },
     {
       groupName: "pre-commit dependencies",
       matchManagers: ["pre-commit"],

.github/workflows/ci.yaml

@@ -24,8 +24,6 @@ env:
   PACKAGE_NAME: ruff
   PYTHON_VERSION: "3.14"
   NEXTEST_PROFILE: ci
-  # Enable mdtests that require external dependencies
-  MDTEST_EXTERNAL: "1"
 
 jobs:
   determine_changes:
@@ -781,6 +779,8 @@ jobs:
     name: "mkdocs"
     runs-on: ubuntu-latest
     timeout-minutes: 10
+    env:
+      MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
     steps:
       - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
@@ -788,6 +788,11 @@ jobs:
       - uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
         with:
           save-if: ${{ github.ref == 'refs/heads/main' }}
+      - name: "Add SSH key"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        uses: webfactory/ssh-agent@a6f90b1f127823b31d4d4a8d96047790581349bd # v0.9.1
+        with:
+          ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
       - name: "Install Rust toolchain"
         run: rustup show
       - name: Install uv
@@ -795,7 +800,11 @@ jobs:
         with:
           python-version: 3.13
           activate-environment: true
+      - name: "Install Insiders dependencies"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        run: uv pip install -r docs/requirements-insiders.txt
       - name: "Install dependencies"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
         run: uv pip install -r docs/requirements.txt
       - name: "Update README File"
         run: python scripts/transform_readme.py --target mkdocs
@@ -803,8 +812,12 @@ jobs:
         run: python scripts/generate_mkdocs.py
       - name: "Check docs formatting"
         run: python scripts/check_docs_formatted.py
+      - name: "Build Insiders docs"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        run: mkdocs build --strict -f mkdocs.insiders.yml
       - name: "Build docs"
-        run: mkdocs build --strict -f mkdocs.yml
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
+        run: mkdocs build --strict -f mkdocs.public.yml
 
   check-formatter-instability-and-black-similarity:
     name: "formatter instabilities and black similarity"

.github/workflows/publish-docs.yml

@@ -20,6 +20,8 @@ on:
 jobs:
   mkdocs:
     runs-on: ubuntu-latest
+    env:
+      MKDOCS_INSIDERS_SSH_KEY_EXISTS: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY != '' }}
     steps:
       - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
@@ -57,12 +59,23 @@ jobs:
           echo "branch_name=update-docs-$branch_display_name-$timestamp" >> "$GITHUB_ENV"
           echo "timestamp=$timestamp" >> "$GITHUB_ENV"
 
+      - name: "Add SSH key"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        uses: webfactory/ssh-agent@a6f90b1f127823b31d4d4a8d96047790581349bd # v0.9.1
+        with:
+          ssh-private-key: ${{ secrets.MKDOCS_INSIDERS_SSH_KEY }}
+
       - name: "Install Rust toolchain"
         run: rustup show
 
       - uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
 
+      - name: "Install Insiders dependencies"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        run: pip install -r docs/requirements-insiders.txt
+
       - name: "Install dependencies"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
         run: pip install -r docs/requirements.txt
 
       - name: "Copy README File"
@@ -70,8 +83,13 @@ jobs:
           python scripts/transform_readme.py --target mkdocs
           python scripts/generate_mkdocs.py
 
+      - name: "Build Insiders docs"
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS == 'true' }}
+        run: mkdocs build --strict -f mkdocs.insiders.yml
+
       - name: "Build docs"
-        run: mkdocs build --strict -f mkdocs.yml
+        if: ${{ env.MKDOCS_INSIDERS_SSH_KEY_EXISTS != 'true' }}
+        run: mkdocs build --strict -f mkdocs.public.yml
 
       - name: "Clone docs repo"
         run: git clone https://${{ secrets.ASTRAL_DOCS_PAT }}@github.com/astral-sh/docs.git astral-docs

.github/workflows/publish-pypi.yml

@@ -18,8 +18,7 @@ jobs:
     environment:
       name: release
     permissions:
-      # For PyPI's trusted publishing.
-      id-token: write
+      id-token: write # For PyPI's trusted publishing + PEP 740 attestations
     steps:
       - name: "Install uv"
         uses: astral-sh/setup-uv@1e862dfacbd1d6d858c55d9b792c756523627244 # v7.1.4
@@ -28,5 +27,8 @@ jobs:
           pattern: wheels-*
           path: wheels
           merge-multiple: true
+      - uses: astral-sh/attest-action@2c727738cea36d6c97dd85eb133ea0e0e8fe754b # v0.0.4
+        with:
+          paths: wheels/*
       - name: Publish to PyPi
         run: uv publish -v wheels/*

CHANGELOG.md

@@ -1,34 +1,5 @@
 # Changelog
 
-## 0.14.8
-
-Released on 2025-12-04.
-
-### Preview features
-
-- \[`flake8-bugbear`\] Catch `yield` expressions within other statements (`B901`) ([#21200](https://github.com/astral-sh/ruff/pull/21200))
-- \[`flake8-use-pathlib`\] Mark fixes unsafe for return type changes (`PTH104`, `PTH105`, `PTH109`, `PTH115`) ([#21440](https://github.com/astral-sh/ruff/pull/21440))
-
-### Bug fixes
-
-- Fix syntax error false positives for `await` outside functions ([#21763](https://github.com/astral-sh/ruff/pull/21763))
-- \[`flake8-simplify`\] Fix truthiness assumption for non-iterable arguments in tuple/list/set calls (`SIM222`, `SIM223`) ([#21479](https://github.com/astral-sh/ruff/pull/21479))
-
-### Documentation
-
-- Suggest using `--output-file` option in GitLab integration ([#21706](https://github.com/astral-sh/ruff/pull/21706))
-
-### Other changes
-
-- [syntax-error] Default type parameter followed by non-default type parameter ([#21657](https://github.com/astral-sh/ruff/pull/21657))
-
-### Contributors
-
-- [@kieran-ryan](https://github.com/kieran-ryan)
-- [@11happy](https://github.com/11happy)
-- [@danparizher](https://github.com/danparizher)
-- [@ntBre](https://github.com/ntBre)
-
 ## 0.14.7
 
 Released on 2025-11-28.

CONTRIBUTING.md

@@ -331,6 +331,13 @@ you addressed them.
 
 ## MkDocs
 
+> [!NOTE]
+>
+> The documentation uses Material for MkDocs Insiders, which is closed-source software.
+> This means only members of the Astral organization can preview the documentation exactly as it
+> will appear in production.
+> Outside contributors can still preview the documentation, but there will be some differences. Consult [the Material for MkDocs documentation](https://squidfunk.github.io/mkdocs-material/insiders/benefits/#features) for which features are exclusively available in the insiders version.
+
 To preview any changes to the documentation locally:
 
 1. Install the [Rust toolchain](https://www.rust-lang.org/tools/install).
@@ -344,7 +351,11 @@ To preview any changes to the documentation locally:
 1. Run the development server with:
 
     ```shell
-    uvx --with-requirements docs/requirements.txt -- mkdocs serve -f mkdocs.yml
+    # For contributors.
+    uvx --with-requirements docs/requirements.txt -- mkdocs serve -f mkdocs.public.yml
+
+    # For members of the Astral org, which has access to MkDocs Insiders via sponsorship.
+    uvx --with-requirements docs/requirements-insiders.txt -- mkdocs serve -f mkdocs.insiders.yml
     ```
 
 The documentation should then be available locally at

Cargo.lock

@@ -2859,7 +2859,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.14.8"
+version = "0.14.7"
 dependencies = [
  "anyhow",
  "argfile",
@@ -3117,7 +3117,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_linter"
-version = "0.14.8"
+version = "0.14.7"
 dependencies = [
  "aho-corasick",
  "anyhow",
@@ -3473,7 +3473,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_wasm"
-version = "0.14.8"
+version = "0.14.7"
 dependencies = [
  "console_error_panic_hook",
  "console_log",
@@ -4557,7 +4557,6 @@ dependencies = [
  "anyhow",
  "camino",
  "colored 3.0.0",
- "dunce",
  "insta",
  "memchr",
  "path-slash",

Cargo.toml

@@ -272,12 +272,6 @@ large_stack_arrays = "allow"
 lto = "fat"
 codegen-units = 16
 
-# Profile to build a minimally sized binary for ruff/ty
-[profile.minimal-size]
-inherits = "release"
-opt-level = "z"
-codegen-units = 1
-
 # Some crates don't change as much but benefit more from
 # more expensive optimization passes, so we selectively
 # decrease codegen-units in some cases.

README.md

@@ -147,8 +147,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.14.8/install.sh | sh
-powershell -c "irm https://astral.sh/ruff/0.14.8/install.ps1 | iex"
+curl -LsSf https://astral.sh/ruff/0.14.7/install.sh | sh
+powershell -c "irm https://astral.sh/ruff/0.14.7/install.ps1 | iex"
 ```
 
 You can also install Ruff via [Homebrew](https://formulae.brew.sh/formula/ruff), [Conda](https://anaconda.org/conda-forge/ruff),
@@ -181,7 +181,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.14.8
+  rev: v0.14.7
   hooks:
     # Run the linter.
     - id: ruff-check

crates/ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.14.8"
+version = "0.14.7"
 publish = true
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff/tests/cli/lint.rs

@@ -1440,78 +1440,6 @@ def function():
     Ok(())
 }
 
-#[test]
-fn ignore_noqa() -> Result<()> {
-    let fixture = CliTest::new()?;
-    fixture.write_file(
-        "ruff.toml",
-        r#"
-[lint]
-select = ["F401"]
-"#,
-    )?;
-
-    fixture.write_file(
-        "noqa.py",
-        r#"
-import os  # noqa: F401
-
-# ruff: disable[F401]
-import sys
-"#,
-    )?;
-
-    // without --ignore-noqa
-    assert_cmd_snapshot!(fixture
-        .check_command()
-        .args(["--config", "ruff.toml"])
-        .arg("noqa.py"),
-        @r"
-    success: false
-    exit_code: 1
-    ----- stdout -----
-    noqa.py:5:8: F401 [*] `sys` imported but unused
-    Found 1 error.
-    [*] 1 fixable with the `--fix` option.
-
-    ----- stderr -----
-    ");
-
-    assert_cmd_snapshot!(fixture
-        .check_command()
-        .args(["--config", "ruff.toml"])
-        .arg("noqa.py")
-        .args(["--preview"]),
-        @r"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-    All checks passed!
-
-    ----- stderr -----
-    ");
-
-    // with --ignore-noqa --preview
-    assert_cmd_snapshot!(fixture
-        .check_command()
-        .args(["--config", "ruff.toml"])
-        .arg("noqa.py")
-        .args(["--ignore-noqa", "--preview"]),
-        @r"
-    success: false
-    exit_code: 1
-    ----- stdout -----
-    noqa.py:2:8: F401 [*] `os` imported but unused
-    noqa.py:5:8: F401 [*] `sys` imported but unused
-    Found 2 errors.
-    [*] 2 fixable with the `--fix` option.
-
-    ----- stderr -----
-    ");
-
-    Ok(())
-}
-
 #[test]
 fn add_noqa() -> Result<()> {
     let fixture = CliTest::new()?;
@@ -1704,100 +1632,6 @@ def unused(x):  # noqa: ANN001, ARG001, D103
     Ok(())
 }
 
-#[test]
-fn add_noqa_existing_file_level_noqa() -> Result<()> {
-    let fixture = CliTest::new()?;
-    fixture.write_file(
-        "ruff.toml",
-        r#"
-[lint]
-select = ["F401"]
-"#,
-    )?;
-
-    fixture.write_file(
-        "noqa.py",
-        r#"
-# ruff: noqa F401
-import os
-"#,
-    )?;
-
-    assert_cmd_snapshot!(fixture
-        .check_command()
-        .args(["--config", "ruff.toml"])
-        .arg("noqa.py")
-        .arg("--preview")
-        .args(["--add-noqa"])
-        .arg("-")
-        .pass_stdin(r#"
-
-"#), @r"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-
-    ----- stderr -----
-    ");
-
-    let test_code =
-        fs::read_to_string(fixture.root().join("noqa.py")).expect("should read test file");
-
-    insta::assert_snapshot!(test_code, @r"
-    # ruff: noqa F401
-    import os
-    ");
-
-    Ok(())
-}
-
-#[test]
-fn add_noqa_existing_range_suppression() -> Result<()> {
-    let fixture = CliTest::new()?;
-    fixture.write_file(
-        "ruff.toml",
-        r#"
-[lint]
-select = ["F401"]
-"#,
-    )?;
-
-    fixture.write_file(
-        "noqa.py",
-        r#"
-# ruff: disable[F401]
-import os
-"#,
-    )?;
-
-    assert_cmd_snapshot!(fixture
-        .check_command()
-        .args(["--config", "ruff.toml"])
-        .arg("noqa.py")
-        .arg("--preview")
-        .args(["--add-noqa"])
-        .arg("-")
-        .pass_stdin(r#"
-
-"#), @r"
-    success: true
-    exit_code: 0
-    ----- stdout -----
-
-    ----- stderr -----
-    ");
-
-    let test_code =
-        fs::read_to_string(fixture.root().join("noqa.py")).expect("should read test file");
-
-    insta::assert_snapshot!(test_code, @r"
-    # ruff: disable[F401]
-    import os
-    ");
-
-    Ok(())
-}
-
 #[test]
 fn add_noqa_multiline_comment() -> Result<()> {
     let fixture = CliTest::new()?;

crates/ruff_db/src/diagnostic/mod.rs

@@ -166,8 +166,28 @@ impl Diagnostic {
     /// Returns the primary message for this diagnostic.
     ///
     /// A diagnostic always has a message, but it may be empty.
+    ///
+    /// NOTE: At present, this routine will return the first primary
+    /// annotation's message as the primary message when the main diagnostic
+    /// message is empty. This is meant to facilitate an incremental migration
+    /// in ty over to the new diagnostic data model. (The old data model
+    /// didn't distinguish between messages on the entire diagnostic and
+    /// messages attached to a particular span.)
     pub fn primary_message(&self) -> &str {
-        self.inner.message.as_str()
+        if !self.inner.message.as_str().is_empty() {
+            return self.inner.message.as_str();
+        }
+        // FIXME: As a special case, while we're migrating ty
+        // to the new diagnostic data model, we'll look for a primary
+        // message from the primary annotation. This is because most
+        // ty diagnostics are created with an empty diagnostic
+        // message and instead attach the message to the annotation.
+        // Fixing this will require touching basically every diagnostic
+        // in ty, so we do it this way for now to match the old
+        // semantics. ---AG
+        self.primary_annotation()
+            .and_then(|ann| ann.get_message())
+            .unwrap_or_default()
     }
 
     /// Introspects this diagnostic and returns what kind of "primary" message
@@ -179,6 +199,18 @@ impl Diagnostic {
     /// contains *essential* information or context for understanding the
     /// diagnostic.
     ///
+    /// The reason why we don't just always return both the main diagnostic
+    /// message and the primary annotation message is because this was written
+    /// in the midst of an incremental migration of ty over to the new
+    /// diagnostic data model. At time of writing, diagnostics were still
+    /// constructed in the old model where the main diagnostic message and the
+    /// primary annotation message were not distinguished from each other. So
+    /// for now, we carefully return what kind of messages this diagnostic
+    /// contains. In effect, if this diagnostic has a non-empty main message
+    /// *and* a non-empty primary annotation message, then the diagnostic is
+    /// 100% using the new diagnostic data model and we can format things
+    /// appropriately.
+    ///
     /// The type returned implements the `std::fmt::Display` trait. In most
     /// cases, just converting it to a string (or printing it) will do what
     /// you want.
@@ -192,10 +224,11 @@ impl Diagnostic {
             .primary_annotation()
             .and_then(|ann| ann.get_message())
             .unwrap_or_default();
-        if annotation.is_empty() {
-            ConciseMessage::MainDiagnostic(main)
-        } else {
-            ConciseMessage::Both { main, annotation }
+        match (main.is_empty(), annotation.is_empty()) {
+            (false, true) => ConciseMessage::MainDiagnostic(main),
+            (true, false) => ConciseMessage::PrimaryAnnotation(annotation),
+            (false, false) => ConciseMessage::Both { main, annotation },
+            (true, true) => ConciseMessage::Empty,
         }
     }
 
@@ -660,6 +693,18 @@ impl SubDiagnostic {
     /// contains *essential* information or context for understanding the
     /// diagnostic.
     ///
+    /// The reason why we don't just always return both the main diagnostic
+    /// message and the primary annotation message is because this was written
+    /// in the midst of an incremental migration of ty over to the new
+    /// diagnostic data model. At time of writing, diagnostics were still
+    /// constructed in the old model where the main diagnostic message and the
+    /// primary annotation message were not distinguished from each other. So
+    /// for now, we carefully return what kind of messages this diagnostic
+    /// contains. In effect, if this diagnostic has a non-empty main message
+    /// *and* a non-empty primary annotation message, then the diagnostic is
+    /// 100% using the new diagnostic data model and we can format things
+    /// appropriately.
+    ///
     /// The type returned implements the `std::fmt::Display` trait. In most
     /// cases, just converting it to a string (or printing it) will do what
     /// you want.
@@ -669,10 +714,11 @@ impl SubDiagnostic {
             .primary_annotation()
             .and_then(|ann| ann.get_message())
             .unwrap_or_default();
-        if annotation.is_empty() {
-            ConciseMessage::MainDiagnostic(main)
-        } else {
-            ConciseMessage::Both { main, annotation }
+        match (main.is_empty(), annotation.is_empty()) {
+            (false, true) => ConciseMessage::MainDiagnostic(main),
+            (true, false) => ConciseMessage::PrimaryAnnotation(annotation),
+            (false, false) => ConciseMessage::Both { main, annotation },
+            (true, true) => ConciseMessage::Empty,
         }
     }
 }
@@ -842,10 +888,6 @@ impl Annotation {
     pub fn hide_snippet(&mut self, yes: bool) {
         self.hide_snippet = yes;
     }
-
-    pub fn is_primary(&self) -> bool {
-        self.is_primary
-    }
 }
 
 /// Tags that can be associated with an annotation.
@@ -1466,10 +1508,28 @@ pub enum DiagnosticFormat {
 pub enum ConciseMessage<'a> {
     /// A diagnostic contains a non-empty main message and an empty
     /// primary annotation message.
+    ///
+    /// This strongly suggests that the diagnostic is using the
+    /// "new" data model.
     MainDiagnostic(&'a str),
+    /// A diagnostic contains an empty main message and a non-empty
+    /// primary annotation message.
+    ///
+    /// This strongly suggests that the diagnostic is using the
+    /// "old" data model.
+    PrimaryAnnotation(&'a str),
     /// A diagnostic contains a non-empty main message and a non-empty
     /// primary annotation message.
+    ///
+    /// This strongly suggests that the diagnostic is using the
+    /// "new" data model.
     Both { main: &'a str, annotation: &'a str },
+    /// A diagnostic contains an empty main message and an empty
+    /// primary annotation message.
+    ///
+    /// This indicates that the diagnostic is probably using the old
+    /// model.
+    Empty,
     /// A custom concise message has been provided.
     Custom(&'a str),
 }
@@ -1480,9 +1540,13 @@ impl std::fmt::Display for ConciseMessage<'_> {
             ConciseMessage::MainDiagnostic(main) => {
                 write!(f, "{main}")
             }
+            ConciseMessage::PrimaryAnnotation(annotation) => {
+                write!(f, "{annotation}")
+            }
             ConciseMessage::Both { main, annotation } => {
                 write!(f, "{main}: {annotation}")
             }
+            ConciseMessage::Empty => Ok(()),
             ConciseMessage::Custom(message) => {
                 write!(f, "{message}")
             }

crates/ruff_db/src/system/path.rs

@@ -667,13 +667,6 @@ impl Deref for SystemPathBuf {
     }
 }
 
-impl AsRef<Path> for SystemPathBuf {
-    #[inline]
-    fn as_ref(&self) -> &Path {
-        self.0.as_std_path()
-    }
-}
-
 impl<P: AsRef<SystemPath>> FromIterator<P> for SystemPathBuf {
     fn from_iter<I: IntoIterator<Item = P>>(iter: I) -> Self {
         let mut buf = SystemPathBuf::new();

crates/ruff_graph/src/lib.rs

@@ -49,7 +49,7 @@ impl ModuleImports {
         // Resolve the imports.
         let mut resolved_imports = ModuleImports::default();
         for import in imports {
-            for resolved in Resolver::new(db, path).resolve(import) {
+            for resolved in Resolver::new(db).resolve(import) {
                 if let Some(path) = resolved.as_system_path() {
                     resolved_imports.insert(path.to_path_buf());
                 }

crates/ruff_graph/src/resolver.rs

@@ -1,9 +1,5 @@
-use ruff_db::files::{File, FilePath, system_path_to_file};
-use ruff_db::system::SystemPath;
-use ty_python_semantic::{
-    ModuleName, resolve_module, resolve_module_confident, resolve_real_module,
-    resolve_real_module_confident,
-};
+use ruff_db::files::FilePath;
+use ty_python_semantic::{ModuleName, resolve_module, resolve_real_module};
 
 use crate::ModuleDb;
 use crate::collector::CollectedImport;
@@ -11,15 +7,12 @@ use crate::collector::CollectedImport;
 /// Collect all imports for a given Python file.
 pub(crate) struct Resolver<'a> {
     db: &'a ModuleDb,
-    file: Option<File>,
 }
 
 impl<'a> Resolver<'a> {
     /// Initialize a [`Resolver`] with a given [`ModuleDb`].
-    pub(crate) fn new(db: &'a ModuleDb, path: &SystemPath) -> Self {
-        // If we know the importing file we can potentially resolve more imports
-        let file = system_path_to_file(db, path).ok();
-        Self { db, file }
+    pub(crate) fn new(db: &'a ModuleDb) -> Self {
+        Self { db }
     }
 
     /// Resolve the [`CollectedImport`] into a [`FilePath`].
@@ -77,21 +70,13 @@ impl<'a> Resolver<'a> {
 
     /// Resolves a module name to a module.
     pub(crate) fn resolve_module(&self, module_name: &ModuleName) -> Option<&'a FilePath> {
-        let module = if let Some(file) = self.file {
-            resolve_module(self.db, file, module_name)?
-        } else {
-            resolve_module_confident(self.db, module_name)?
-        };
+        let module = resolve_module(self.db, module_name)?;
         Some(module.file(self.db)?.path(self.db))
     }
 
     /// Resolves a module name to a module (stubs not allowed).
     fn resolve_real_module(&self, module_name: &ModuleName) -> Option<&'a FilePath> {
-        let module = if let Some(file) = self.file {
-            resolve_real_module(self.db, file, module_name)?
-        } else {
-            resolve_real_module_confident(self.db, module_name)?
-        };
+        let module = resolve_real_module(self.db, module_name)?;
         Some(module.file(self.db)?.path(self.db))
     }
 }

crates/ruff_linter/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_linter"
-version = "0.14.8"
+version = "0.14.7"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff_linter/resources/test/fixtures/flake8_bandit/S506.py

@@ -28,11 +28,9 @@ yaml.load("{}", SafeLoader)
 yaml.load("{}", yaml.SafeLoader)
 yaml.load("{}", CSafeLoader)
 yaml.load("{}", yaml.CSafeLoader)
-yaml.load("{}", yaml.cyaml.CSafeLoader)
 yaml.load("{}", NewSafeLoader)
 yaml.load("{}", Loader=SafeLoader)
 yaml.load("{}", Loader=yaml.SafeLoader)
 yaml.load("{}", Loader=CSafeLoader)
 yaml.load("{}", Loader=yaml.CSafeLoader)
-yaml.load("{}", Loader=yaml.cyaml.CSafeLoader)
 yaml.load("{}", Loader=NewSafeLoader)

crates/ruff_linter/resources/test/fixtures/flake8_bugbear/B006_B008.py

@@ -199,9 +199,6 @@ def bytes_okay(value=bytes(1)):
 def int_okay(value=int("12")):
     pass
 
-# Allow immutable slice()
-def slice_okay(value=slice(1,2)):
-    pass
 
 # Allow immutable complex() value
 def complex_okay(value=complex(1,2)):

crates/ruff_linter/resources/test/fixtures/flake8_bugbear/B901.py

@@ -52,16 +52,16 @@ def not_broken5():
     yield inner()
 
 
-def broken3():
+def not_broken6():
     return (yield from [])
 
 
-def broken4():
+def not_broken7():
     x = yield from []
     return x
 
 
-def broken5():
+def not_broken8():
     x = None
 
     def inner(ex):
@@ -76,13 +76,3 @@ class NotBroken9(object):
     def __await__(self):
         yield from function()
         return 42
-
-
-async def broken6():
-    yield 1
-    return foo()
-
-
-async def broken7():
-    yield 1
-    return [1, 2, 3]

crates/ruff_linter/resources/test/fixtures/pydocstyle/D417.py

@@ -218,26 +218,3 @@ def should_not_fail(payload, Args):
         Args:
             The other arguments.
     """
-
-
-# Test cases for Unpack[TypedDict] kwargs
-from typing import TypedDict
-from typing_extensions import Unpack
-
-class User(TypedDict):
-    id: int
-    name: str
-
-def function_with_unpack_args_should_not_fail(query: str, **kwargs: Unpack[User]):
-    """Function with Unpack kwargs.
-
-    Args:
-        query: some arg
-    """
-
-def function_with_unpack_and_missing_arg_doc_should_fail(query: str, **kwargs: Unpack[User]):
-    """Function with Unpack kwargs but missing query arg documentation.
-
-    Args:
-        **kwargs: keyword arguments
-    """

crates/ruff_linter/resources/test/fixtures/ruff/suppressions.py

@@ -1,56 +0,0 @@
-def f():
-    # These should both be ignored by the range suppression.
-    # ruff: disable[E741, F841]
-    I = 1
-    # ruff: enable[E741, F841]
-
-
-def f():
-    # These should both be ignored by the implicit range suppression.
-    # Should also generate an "unmatched suppression" warning.
-    # ruff:disable[E741,F841]
-    I = 1
-
-
-def f():
-    # Neither warning is ignored, and an "unmatched suppression"
-    # should be generated.
-    I = 1
-    # ruff: enable[E741, F841]
-
-
-def f():
-    # One should be ignored by the range suppression, and
-    # the other logged to the user.
-    # ruff: disable[E741]
-    I = 1
-    # ruff: enable[E741]
-
-
-def f():
-    # Test interleaved range suppressions. The first and last
-    # lines should each log a different warning, while the
-    # middle line should be completely silenced.
-    # ruff: disable[E741]
-    l = 0
-    # ruff: disable[F841]
-    O = 1
-    # ruff: enable[E741]
-    I = 2
-    # ruff: enable[F841]
-
-
-def f():
-    # Neither of these are ignored and warnings are
-    # logged to user
-    # ruff: disable[E501]
-    I = 1
-    # ruff: enable[E501]
-
-
-def f():
-    # These should both be ignored by the range suppression,
-    # and an unusued noqa diagnostic should be logged.
-    # ruff:disable[E741,F841]
-    I = 1  # noqa: E741,F841
-    # ruff:enable[E741,F841]

crates/ruff_linter/resources/test/fixtures/syntax_errors/return_in_generator.py

@@ -1,24 +0,0 @@
-async def gen():
-    yield 1
-    return 42
-
-def gen(): # B901 but not a syntax error - not an async generator
-    yield 1
-    return 42
-
-async def gen(): # ok - no value in return
-    yield 1
-    return
-
-async def gen():
-    yield 1
-    return foo()
-
-async def gen():
-    yield 1
-    return [1, 2, 3]
-
-async def gen():
-    if True:
-        yield 1
-    return 10

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -69,7 +69,6 @@ use crate::noqa::NoqaMapping;
 use crate::package::PackageRoot;
 use crate::preview::is_undefined_export_in_dunder_init_enabled;
 use crate::registry::Rule;
-use crate::rules::flake8_bugbear::rules::ReturnInGenerator;
 use crate::rules::pyflakes::rules::{
     LateFutureImport, MultipleStarredExpressions, ReturnOutsideFunction,
     UndefinedLocalWithNestedImportStarUsage, YieldOutsideFunction,
@@ -730,12 +729,6 @@ impl SemanticSyntaxContext for Checker<'_> {
                     self.report_diagnostic(NonlocalWithoutBinding { name }, error.range);
                 }
             }
-            SemanticSyntaxErrorKind::ReturnInGenerator => {
-                // B901
-                if self.is_rule_enabled(Rule::ReturnInGenerator) {
-                    self.report_diagnostic(ReturnInGenerator, error.range);
-                }
-            }
             SemanticSyntaxErrorKind::ReboundComprehensionVariable
             | SemanticSyntaxErrorKind::DuplicateTypeParameter
             | SemanticSyntaxErrorKind::MultipleCaseAssignment(_)

crates/ruff_linter/src/checkers/noqa.rs

@@ -12,20 +12,17 @@ use crate::fix::edits::delete_comment;
 use crate::noqa::{
     Code, Directive, FileExemption, FileNoqaDirectives, NoqaDirectives, NoqaMapping,
 };
-use crate::preview::is_range_suppressions_enabled;
 use crate::registry::Rule;
 use crate::rule_redirects::get_redirect_target;
 use crate::rules::pygrep_hooks;
 use crate::rules::ruff;
 use crate::rules::ruff::rules::{UnusedCodes, UnusedNOQA};
 use crate::settings::LinterSettings;
-use crate::suppression::Suppressions;
 use crate::{Edit, Fix, Locator};
 
 use super::ast::LintContext;
 
 /// RUF100
-#[expect(clippy::too_many_arguments)]
 pub(crate) fn check_noqa(
     context: &mut LintContext,
     path: &Path,
@@ -34,7 +31,6 @@ pub(crate) fn check_noqa(
     noqa_line_for: &NoqaMapping,
     analyze_directives: bool,
     settings: &LinterSettings,
-    suppressions: &Suppressions,
 ) -> Vec<usize> {
     // Identify any codes that are globally exempted (within the current file).
     let file_noqa_directives =
@@ -44,7 +40,7 @@ pub(crate) fn check_noqa(
     let mut noqa_directives =
         NoqaDirectives::from_commented_ranges(comment_ranges, &settings.external, path, locator);
 
-    if file_noqa_directives.is_empty() && noqa_directives.is_empty() && suppressions.is_empty() {
+    if file_noqa_directives.is_empty() && noqa_directives.is_empty() {
         return Vec::new();
     }
 
@@ -64,19 +60,11 @@ pub(crate) fn check_noqa(
             continue;
         }
 
-        // Apply file-level suppressions first
         if exemption.contains_secondary_code(code) {
             ignored_diagnostics.push(index);
             continue;
         }
 
-        // Apply ranged suppressions next
-        if is_range_suppressions_enabled(settings) && suppressions.check_diagnostic(diagnostic) {
-            ignored_diagnostics.push(index);
-            continue;
-        }
-
-        // Apply end-of-line noqa suppressions last
         let noqa_offsets = diagnostic
             .parent()
             .into_iter()

crates/ruff_linter/src/linter.rs

@@ -32,7 +32,6 @@ use crate::rules::ruff::rules::test_rules::{self, TEST_RULES, TestRule};
 use crate::settings::types::UnsafeFixes;
 use crate::settings::{LinterSettings, TargetVersion, flags};
 use crate::source_kind::SourceKind;
-use crate::suppression::Suppressions;
 use crate::{Locator, directives, fs};
 
 pub(crate) mod float;
@@ -129,7 +128,6 @@ pub fn check_path(
     source_type: PySourceType,
     parsed: &Parsed<ModModule>,
     target_version: TargetVersion,
-    suppressions: &Suppressions,
 ) -> Vec<Diagnostic> {
     // Aggregate all diagnostics.
     let mut context = LintContext::new(path, locator.contents(), settings);
@@ -341,7 +339,6 @@ pub fn check_path(
             &directives.noqa_line_for,
             parsed.has_valid_syntax(),
             settings,
-            suppressions,
         );
         if noqa.is_enabled() {
             for index in ignored.iter().rev() {
@@ -403,9 +400,6 @@ pub fn add_noqa_to_path(
         &indexer,
     );
 
-    // Parse range suppression comments
-    let suppressions = Suppressions::from_tokens(settings, locator.contents(), parsed.tokens());
-
     // Generate diagnostics, ignoring any existing `noqa` directives.
     let diagnostics = check_path(
         path,
@@ -420,7 +414,6 @@ pub fn add_noqa_to_path(
         source_type,
         &parsed,
         target_version,
-        &suppressions,
     );
 
     // Add any missing `# noqa` pragmas.
@@ -434,7 +427,6 @@ pub fn add_noqa_to_path(
         &directives.noqa_line_for,
         stylist.line_ending(),
         reason,
-        &suppressions,
     )
 }
 
@@ -469,9 +461,6 @@ pub fn lint_only(
         &indexer,
     );
 
-    // Parse range suppression comments
-    let suppressions = Suppressions::from_tokens(settings, locator.contents(), parsed.tokens());
-
     // Generate diagnostics.
     let diagnostics = check_path(
         path,
@@ -486,7 +475,6 @@ pub fn lint_only(
         source_type,
         &parsed,
         target_version,
-        &suppressions,
     );
 
     LinterResult {
@@ -578,9 +566,6 @@ pub fn lint_fix<'a>(
             &indexer,
         );
 
-        // Parse range suppression comments
-        let suppressions = Suppressions::from_tokens(settings, locator.contents(), parsed.tokens());
-
         // Generate diagnostics.
         let diagnostics = check_path(
             path,
@@ -595,7 +580,6 @@ pub fn lint_fix<'a>(
             source_type,
             &parsed,
             target_version,
-            &suppressions,
         );
 
         if iterations == 0 {
@@ -785,7 +769,6 @@ mod tests {
     use crate::registry::Rule;
     use crate::settings::LinterSettings;
     use crate::source_kind::SourceKind;
-    use crate::suppression::Suppressions;
     use crate::test::{TestedNotebook, assert_notebook_path, test_contents, test_snippet};
     use crate::{Locator, assert_diagnostics, directives, settings};
 
@@ -961,7 +944,6 @@ mod tests {
             &locator,
             &indexer,
         );
-        let suppressions = Suppressions::from_tokens(settings, locator.contents(), parsed.tokens());
         let mut diagnostics = check_path(
             path,
             None,
@@ -975,7 +957,6 @@ mod tests {
             source_type,
             &parsed,
             target_version,
-            &suppressions,
         );
         diagnostics.sort_by(Diagnostic::ruff_start_ordering);
         diagnostics
@@ -1062,7 +1043,6 @@ mod tests {
         Rule::YieldFromInAsyncFunction,
         Path::new("yield_from_in_async_function.py")
     )]
-    #[test_case(Rule::ReturnInGenerator, Path::new("return_in_generator.py"))]
     fn test_syntax_errors(rule: Rule, path: &Path) -> Result<()> {
         let snapshot = path.to_string_lossy().to_string();
         let path = Path::new("resources/test/fixtures/syntax_errors").join(path);

crates/ruff_linter/src/noqa.rs

@@ -20,14 +20,12 @@ use crate::Locator;
 use crate::fs::relativize_path;
 use crate::registry::Rule;
 use crate::rule_redirects::get_redirect_target;
-use crate::suppression::Suppressions;
 
 /// Generates an array of edits that matches the length of `messages`.
 /// Each potential edit in the array is paired, in order, with the associated diagnostic.
 /// Each edit will add a `noqa` comment to the appropriate line in the source to hide
 /// the diagnostic. These edits may conflict with each other and should not be applied
 /// simultaneously.
-#[expect(clippy::too_many_arguments)]
 pub fn generate_noqa_edits(
     path: &Path,
     diagnostics: &[Diagnostic],
@@ -36,19 +34,11 @@ pub fn generate_noqa_edits(
     external: &[String],
     noqa_line_for: &NoqaMapping,
     line_ending: LineEnding,
-    suppressions: &Suppressions,
 ) -> Vec<Option<Edit>> {
     let file_directives = FileNoqaDirectives::extract(locator, comment_ranges, external, path);
     let exemption = FileExemption::from(&file_directives);
     let directives = NoqaDirectives::from_commented_ranges(comment_ranges, external, path, locator);
-    let comments = find_noqa_comments(
-        diagnostics,
-        locator,
-        &exemption,
-        &directives,
-        noqa_line_for,
-        suppressions,
-    );
+    let comments = find_noqa_comments(diagnostics, locator, &exemption, &directives, noqa_line_for);
     build_noqa_edits_by_diagnostic(comments, locator, line_ending, None)
 }
 
@@ -735,7 +725,6 @@ pub(crate) fn add_noqa(
     noqa_line_for: &NoqaMapping,
     line_ending: LineEnding,
     reason: Option<&str>,
-    suppressions: &Suppressions,
 ) -> Result<usize> {
     let (count, output) = add_noqa_inner(
         path,
@@ -746,7 +735,6 @@ pub(crate) fn add_noqa(
         noqa_line_for,
         line_ending,
         reason,
-        suppressions,
     );
 
     fs::write(path, output)?;
@@ -763,7 +751,6 @@ fn add_noqa_inner(
     noqa_line_for: &NoqaMapping,
     line_ending: LineEnding,
     reason: Option<&str>,
-    suppressions: &Suppressions,
 ) -> (usize, String) {
     let mut count = 0;
 
@@ -773,14 +760,7 @@ fn add_noqa_inner(
 
     let directives = NoqaDirectives::from_commented_ranges(comment_ranges, external, path, locator);
 
-    let comments = find_noqa_comments(
-        diagnostics,
-        locator,
-        &exemption,
-        &directives,
-        noqa_line_for,
-        suppressions,
-    );
+    let comments = find_noqa_comments(diagnostics, locator, &exemption, &directives, noqa_line_for);
 
     let edits = build_noqa_edits_by_line(comments, locator, line_ending, reason);
 
@@ -879,7 +859,6 @@ fn find_noqa_comments<'a>(
     exemption: &'a FileExemption,
     directives: &'a NoqaDirectives,
     noqa_line_for: &NoqaMapping,
-    suppressions: &Suppressions,
 ) -> Vec<Option<NoqaComment<'a>>> {
     // List of noqa comments, ordered to match up with `messages`
     let mut comments_by_line: Vec<Option<NoqaComment<'a>>> = vec![];
@@ -896,12 +875,6 @@ fn find_noqa_comments<'a>(
             continue;
         }
 
-        // Apply ranged suppressions next
-        if suppressions.check_diagnostic(message) {
-            comments_by_line.push(None);
-            continue;
-        }
-
         // Is the violation ignored by a `noqa` directive on the parent line?
         if let Some(parent) = message.parent() {
             if let Some(directive_line) =
@@ -1280,7 +1253,6 @@ mod tests {
     use crate::rules::pycodestyle::rules::{AmbiguousVariableName, UselessSemicolon};
     use crate::rules::pyflakes::rules::UnusedVariable;
     use crate::rules::pyupgrade::rules::PrintfStringFormatting;
-    use crate::suppression::Suppressions;
     use crate::{Edit, Violation};
     use crate::{Locator, generate_noqa_edits};
 
@@ -2876,7 +2848,6 @@ mod tests {
             &noqa_line_for,
             LineEnding::Lf,
             None,
-            &Suppressions::default(),
         );
         assert_eq!(count, 0);
         assert_eq!(output, format!("{contents}"));
@@ -2901,7 +2872,6 @@ mod tests {
             &noqa_line_for,
             LineEnding::Lf,
             None,
-            &Suppressions::default(),
         );
         assert_eq!(count, 1);
         assert_eq!(output, "x = 1  # noqa: F841\n");
@@ -2933,7 +2903,6 @@ mod tests {
             &noqa_line_for,
             LineEnding::Lf,
             None,
-            &Suppressions::default(),
         );
         assert_eq!(count, 1);
         assert_eq!(output, "x = 1  # noqa: E741, F841\n");
@@ -2965,7 +2934,6 @@ mod tests {
             &noqa_line_for,
             LineEnding::Lf,
             None,
-            &Suppressions::default(),
         );
         assert_eq!(count, 0);
         assert_eq!(output, "x = 1  # noqa");
@@ -2988,7 +2956,6 @@ print(
         let messages = [PrintfStringFormatting
             .into_diagnostic(TextRange::new(12.into(), 79.into()), &source_file)];
         let comment_ranges = CommentRanges::default();
-        let suppressions = Suppressions::default();
         let edits = generate_noqa_edits(
             path,
             &messages,
@@ -2997,7 +2964,6 @@ print(
             &[],
             &noqa_line_for,
             LineEnding::Lf,
-            &suppressions,
         );
         assert_eq!(
             edits,
@@ -3021,7 +2987,6 @@ bar =
             [UselessSemicolon.into_diagnostic(TextRange::new(4.into(), 5.into()), &source_file)];
         let noqa_line_for = NoqaMapping::default();
         let comment_ranges = CommentRanges::default();
-        let suppressions = Suppressions::default();
         let edits = generate_noqa_edits(
             path,
             &messages,
@@ -3030,7 +2995,6 @@ bar =
             &[],
             &noqa_line_for,
             LineEnding::Lf,
-            &suppressions,
         );
         assert_eq!(
             edits,

crates/ruff_linter/src/preview.rs

@@ -286,8 +286,3 @@ pub(crate) const fn is_s310_resolve_string_literal_bindings_enabled(
 ) -> bool {
     settings.preview.is_enabled()
 }
-
-// https://github.com/astral-sh/ruff/pull/21623
-pub(crate) const fn is_range_suppressions_enabled(settings: &LinterSettings) -> bool {
-    settings.preview.is_enabled()
-}

crates/ruff_linter/src/rules/flake8_bandit/rules/unsafe_yaml_load.rs

@@ -75,7 +75,6 @@ pub(crate) fn unsafe_yaml_load(checker: &Checker, call: &ast::ExprCall) {
                         qualified_name.segments(),
                         ["yaml", "SafeLoader" | "CSafeLoader"]
                             | ["yaml", "loader", "SafeLoader" | "CSafeLoader"]
-                            | ["yaml", "cyaml", "CSafeLoader"]
                     )
                 })
             {

crates/ruff_linter/src/rules/flake8_bugbear/rules/return_in_generator.rs

@@ -1,5 +1,6 @@
 use ruff_macros::{ViolationMetadata, derive_message_formats};
-use ruff_python_ast::visitor::{Visitor, walk_expr, walk_stmt};
+use ruff_python_ast::statement_visitor;
+use ruff_python_ast::statement_visitor::StatementVisitor;
 use ruff_python_ast::{self as ast, Expr, Stmt, StmtFunctionDef};
 use ruff_text_size::TextRange;
 
@@ -95,11 +96,6 @@ pub(crate) fn return_in_generator(checker: &Checker, function_def: &StmtFunction
         return;
     }
 
-    // Async functions are flagged by the `ReturnInGenerator` semantic syntax error.
-    if function_def.is_async {
-        return;
-    }
-
     let mut visitor = ReturnInGeneratorVisitor::default();
     visitor.visit_body(&function_def.body);
 
@@ -116,9 +112,15 @@ struct ReturnInGeneratorVisitor {
     has_yield: bool,
 }
 
-impl Visitor<'_> for ReturnInGeneratorVisitor {
+impl StatementVisitor<'_> for ReturnInGeneratorVisitor {
     fn visit_stmt(&mut self, stmt: &Stmt) {
         match stmt {
+            Stmt::Expr(ast::StmtExpr { value, .. }) => match **value {
+                Expr::Yield(_) | Expr::YieldFrom(_) => {
+                    self.has_yield = true;
+                }
+                _ => {}
+            },
             Stmt::FunctionDef(_) => {
                 // Do not recurse into nested functions; they're evaluated separately.
             }
@@ -128,19 +130,8 @@ impl Visitor<'_> for ReturnInGeneratorVisitor {
                 node_index: _,
             }) => {
                 self.return_ = Some(*range);
-                walk_stmt(self, stmt);
             }
-            _ => walk_stmt(self, stmt),
-        }
-    }
-
-    fn visit_expr(&mut self, expr: &Expr) {
-        match expr {
-            Expr::Lambda(_) => {}
-            Expr::Yield(_) | Expr::YieldFrom(_) => {
-                self.has_yield = true;
-            }
-            _ => walk_expr(self, expr),
+            _ => statement_visitor::walk_stmt(self, stmt),
         }
     }
 }

crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linter__rules__flake8_bugbear__tests__B006_B006_B008.py.snap

@@ -236,227 +236,227 @@ help: Replace with `None`; initialize within function
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:242:20
+   --> B006_B008.py:239:20
     |
-240 | # B006 and B008
-241 | # We should handle arbitrary nesting of these B008.
-242 | def nested_combo(a=[float(3), dt.datetime.now()]):
+237 | # B006 and B008
+238 | # We should handle arbitrary nesting of these B008.
+239 | def nested_combo(a=[float(3), dt.datetime.now()]):
     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-243 |     pass
+240 |     pass
     |
 help: Replace with `None`; initialize within function
-239 | 
-240 | # B006 and B008
-241 | # We should handle arbitrary nesting of these B008.
+236 | 
+237 | # B006 and B008
+238 | # We should handle arbitrary nesting of these B008.
     - def nested_combo(a=[float(3), dt.datetime.now()]):
-242 + def nested_combo(a=None):
-243 |     pass
-244 | 
-245 | 
+239 + def nested_combo(a=None):
+240 |     pass
+241 | 
+242 | 
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:279:27
+   --> B006_B008.py:276:27
     |
-278 | def mutable_annotations(
-279 |     a: list[int] | None = [],
+275 | def mutable_annotations(
+276 |     a: list[int] | None = [],
     |                           ^^
-280 |     b: Optional[Dict[int, int]] = {},
-281 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+277 |     b: Optional[Dict[int, int]] = {},
+278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
     |
 help: Replace with `None`; initialize within function
-276 | 
-277 | 
-278 | def mutable_annotations(
+273 | 
+274 | 
+275 | def mutable_annotations(
     -     a: list[int] | None = [],
-279 +     a: list[int] | None = None,
-280 |     b: Optional[Dict[int, int]] = {},
-281 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-282 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+276 +     a: list[int] | None = None,
+277 |     b: Optional[Dict[int, int]] = {},
+278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+279 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:280:35
+   --> B006_B008.py:277:35
     |
-278 | def mutable_annotations(
-279 |     a: list[int] | None = [],
-280 |     b: Optional[Dict[int, int]] = {},
+275 | def mutable_annotations(
+276 |     a: list[int] | None = [],
+277 |     b: Optional[Dict[int, int]] = {},
     |                                   ^^
-281 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-282 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+279 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
     |
 help: Replace with `None`; initialize within function
-277 | 
-278 | def mutable_annotations(
-279 |     a: list[int] | None = [],
+274 | 
+275 | def mutable_annotations(
+276 |     a: list[int] | None = [],
     -     b: Optional[Dict[int, int]] = {},
-280 +     b: Optional[Dict[int, int]] = None,
-281 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-282 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-283 | ):
+277 +     b: Optional[Dict[int, int]] = None,
+278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+279 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+280 | ):
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:281:62
+   --> B006_B008.py:278:62
     |
-279 |     a: list[int] | None = [],
-280 |     b: Optional[Dict[int, int]] = {},
-281 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+276 |     a: list[int] | None = [],
+277 |     b: Optional[Dict[int, int]] = {},
+278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
     |                                                              ^^^^^
-282 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-283 | ):
+279 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+280 | ):
     |
 help: Replace with `None`; initialize within function
-278 | def mutable_annotations(
-279 |     a: list[int] | None = [],
-280 |     b: Optional[Dict[int, int]] = {},
+275 | def mutable_annotations(
+276 |     a: list[int] | None = [],
+277 |     b: Optional[Dict[int, int]] = {},
     -     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-281 +     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = None,
-282 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-283 | ):
-284 |     pass
+278 +     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = None,
+279 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+280 | ):
+281 |     pass
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:282:80
+   --> B006_B008.py:279:80
     |
-280 |     b: Optional[Dict[int, int]] = {},
-281 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-282 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+277 |     b: Optional[Dict[int, int]] = {},
+278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+279 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
     |                                                                                ^^^^^
-283 | ):
-284 |     pass
+280 | ):
+281 |     pass
     |
 help: Replace with `None`; initialize within function
-279 |     a: list[int] | None = [],
-280 |     b: Optional[Dict[int, int]] = {},
-281 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+276 |     a: list[int] | None = [],
+277 |     b: Optional[Dict[int, int]] = {},
+278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
     -     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-282 +     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = None,
-283 | ):
-284 |     pass
-285 | 
+279 +     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = None,
+280 | ):
+281 |     pass
+282 | 
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:287:52
+   --> B006_B008.py:284:52
     |
-287 | def single_line_func_wrong(value: dict[str, str] = {}):
+284 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^
-288 |     """Docstring"""
+285 |     """Docstring"""
     |
 help: Replace with `None`; initialize within function
-284 |     pass
-285 | 
+281 |     pass
+282 | 
+283 | 
+    - def single_line_func_wrong(value: dict[str, str] = {}):
+284 + def single_line_func_wrong(value: dict[str, str] = None):
+285 |     """Docstring"""
 286 | 
-    - def single_line_func_wrong(value: dict[str, str] = {}):
-287 + def single_line_func_wrong(value: dict[str, str] = None):
-288 |     """Docstring"""
-289 | 
-290 | 
+287 | 
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:291:52
+   --> B006_B008.py:288:52
     |
-291 | def single_line_func_wrong(value: dict[str, str] = {}):
+288 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^
-292 |     """Docstring"""
-293 |     ...
+289 |     """Docstring"""
+290 |     ...
     |
 help: Replace with `None`; initialize within function
-288 |     """Docstring"""
-289 | 
-290 | 
+285 |     """Docstring"""
+286 | 
+287 | 
     - def single_line_func_wrong(value: dict[str, str] = {}):
-291 + def single_line_func_wrong(value: dict[str, str] = None):
-292 |     """Docstring"""
-293 |     ...
-294 | 
+288 + def single_line_func_wrong(value: dict[str, str] = None):
+289 |     """Docstring"""
+290 |     ...
+291 | 
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:296:52
+   --> B006_B008.py:293:52
     |
-296 | def single_line_func_wrong(value: dict[str, str] = {}):
+293 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^
-297 |     """Docstring"""; ...
+294 |     """Docstring"""; ...
     |
 help: Replace with `None`; initialize within function
-293 |     ...
-294 | 
+290 |     ...
+291 | 
+292 | 
+    - def single_line_func_wrong(value: dict[str, str] = {}):
+293 + def single_line_func_wrong(value: dict[str, str] = None):
+294 |     """Docstring"""; ...
 295 | 
-    - def single_line_func_wrong(value: dict[str, str] = {}):
-296 + def single_line_func_wrong(value: dict[str, str] = None):
-297 |     """Docstring"""; ...
-298 | 
-299 | 
+296 | 
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:300:52
+   --> B006_B008.py:297:52
     |
-300 | def single_line_func_wrong(value: dict[str, str] = {}):
+297 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^
-301 |     """Docstring"""; \
-302 |         ...
+298 |     """Docstring"""; \
+299 |         ...
     |
 help: Replace with `None`; initialize within function
-297 |     """Docstring"""; ...
-298 | 
-299 | 
+294 |     """Docstring"""; ...
+295 | 
+296 | 
     - def single_line_func_wrong(value: dict[str, str] = {}):
-300 + def single_line_func_wrong(value: dict[str, str] = None):
-301 |     """Docstring"""; \
-302 |         ...
-303 | 
+297 + def single_line_func_wrong(value: dict[str, str] = None):
+298 |     """Docstring"""; \
+299 |         ...
+300 | 
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:305:52
+   --> B006_B008.py:302:52
     |
-305 |   def single_line_func_wrong(value: dict[str, str] = {
+302 |   def single_line_func_wrong(value: dict[str, str] = {
     |  ____________________________________________________^
-306 | |     # This is a comment
-307 | | }):
+303 | |     # This is a comment
+304 | | }):
     | |_^
-308 |       """Docstring"""
+305 |       """Docstring"""
     |
 help: Replace with `None`; initialize within function
-302 |         ...
-303 | 
-304 | 
+299 |         ...
+300 | 
+301 | 
     - def single_line_func_wrong(value: dict[str, str] = {
     -     # This is a comment
     - }):
-305 + def single_line_func_wrong(value: dict[str, str] = None):
-306 |     """Docstring"""
-307 | 
-308 | 
+302 + def single_line_func_wrong(value: dict[str, str] = None):
+303 |     """Docstring"""
+304 | 
+305 | 
 note: This is an unsafe fix and may change runtime behavior
 
 B006 Do not use mutable data structures for argument defaults
-   --> B006_B008.py:311:52
+   --> B006_B008.py:308:52
     |
-311 | def single_line_func_wrong(value: dict[str, str] = {}) \
+308 | def single_line_func_wrong(value: dict[str, str] = {}) \
     |                                                    ^^
-312 |     : \
-313 |     """Docstring"""
+309 |     : \
+310 |     """Docstring"""
     |
 help: Replace with `None`; initialize within function
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:316:52
+   --> B006_B008.py:313:52
     |
-316 | def single_line_func_wrong(value: dict[str, str] = {}):
+313 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^
-317 |     """Docstring without newline"""
+314 |     """Docstring without newline"""
     |
 help: Replace with `None`; initialize within function
-313 |     """Docstring"""
-314 | 
-315 | 
+310 |     """Docstring"""
+311 | 
+312 | 
     - def single_line_func_wrong(value: dict[str, str] = {}):
-316 + def single_line_func_wrong(value: dict[str, str] = None):
-317 |     """Docstring without newline"""
+313 + def single_line_func_wrong(value: dict[str, str] = None):
+314 |     """Docstring without newline"""
 note: This is an unsafe fix and may change runtime behavior

crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linter__rules__flake8_bugbear__tests__B008_B006_B008.py.snap

@@ -53,39 +53,39 @@ B008 Do not perform function call in argument defaults; instead, perform the cal
     |
 
 B008 Do not perform function call `dt.datetime.now` in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable
-   --> B006_B008.py:242:31
+   --> B006_B008.py:239:31
     |
-240 | # B006 and B008
-241 | # We should handle arbitrary nesting of these B008.
-242 | def nested_combo(a=[float(3), dt.datetime.now()]):
+237 | # B006 and B008
+238 | # We should handle arbitrary nesting of these B008.
+239 | def nested_combo(a=[float(3), dt.datetime.now()]):
     |                               ^^^^^^^^^^^^^^^^^
-243 |     pass
+240 |     pass
     |
 
 B008 Do not perform function call `map` in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable
-   --> B006_B008.py:248:22
+   --> B006_B008.py:245:22
     |
-246 | # Don't flag nested B006 since we can't guarantee that
-247 | # it isn't made mutable by the outer operation.
-248 | def no_nested_b006(a=map(lambda s: s.upper(), ["a", "b", "c"])):
+243 | # Don't flag nested B006 since we can't guarantee that
+244 | # it isn't made mutable by the outer operation.
+245 | def no_nested_b006(a=map(lambda s: s.upper(), ["a", "b", "c"])):
     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-249 |     pass
+246 |     pass
     |
 
 B008 Do not perform function call `random.randint` in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable
-   --> B006_B008.py:253:19
+   --> B006_B008.py:250:19
     |
-252 | # B008-ception.
-253 | def nested_b008(a=random.randint(0, dt.datetime.now().year)):
+249 | # B008-ception.
+250 | def nested_b008(a=random.randint(0, dt.datetime.now().year)):
     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-254 |     pass
+251 |     pass
     |
 
 B008 Do not perform function call `dt.datetime.now` in argument defaults; instead, perform the call within the function, or read the default from a module-level singleton variable
-   --> B006_B008.py:253:37
+   --> B006_B008.py:250:37
     |
-252 | # B008-ception.
-253 | def nested_b008(a=random.randint(0, dt.datetime.now().year)):
+249 | # B008-ception.
+250 | def nested_b008(a=random.randint(0, dt.datetime.now().year)):
     |                                     ^^^^^^^^^^^^^^^^^
-254 |     pass
+251 |     pass
     |

crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linter__rules__flake8_bugbear__tests__B901_B901.py.snap

@@ -21,46 +21,3 @@ B901 Using `yield` and `return {value}` in a generator function can lead to conf
 37 |
 38 |     yield from not_broken()
    |
-
-B901 Using `yield` and `return {value}` in a generator function can lead to confusing behavior
-  --> B901.py:56:5
-   |
-55 | def broken3():
-56 |     return (yield from [])
-   |     ^^^^^^^^^^^^^^^^^^^^^^
-   |
-
-B901 Using `yield` and `return {value}` in a generator function can lead to confusing behavior
-  --> B901.py:61:5
-   |
-59 | def broken4():
-60 |     x = yield from []
-61 |     return x
-   |     ^^^^^^^^
-   |
-
-B901 Using `yield` and `return {value}` in a generator function can lead to confusing behavior
-  --> B901.py:72:5
-   |
-71 |     inner((yield from []))
-72 |     return x
-   |     ^^^^^^^^
-   |
-
-B901 Using `yield` and `return {value}` in a generator function can lead to confusing behavior
-  --> B901.py:83:5
-   |
-81 | async def broken6():
-82 |     yield 1
-83 |     return foo()
-   |     ^^^^^^^^^^^^
-   |
-
-B901 Using `yield` and `return {value}` in a generator function can lead to confusing behavior
-  --> B901.py:88:5
-   |
-86 | async def broken7():
-87 |     yield 1
-88 |     return [1, 2, 3]
-   |     ^^^^^^^^^^^^^^^^
-   |

crates/ruff_linter/src/rules/flake8_bugbear/snapshots/ruff_linter__rules__flake8_bugbear__tests__preview__B006_B006_B008.py.snap

@@ -236,227 +236,227 @@ help: Replace with `None`; initialize within function
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:242:20
+   --> B006_B008.py:239:20
     |
-240 | # B006 and B008
-241 | # We should handle arbitrary nesting of these B008.
-242 | def nested_combo(a=[float(3), dt.datetime.now()]):
+237 | # B006 and B008
+238 | # We should handle arbitrary nesting of these B008.
+239 | def nested_combo(a=[float(3), dt.datetime.now()]):
     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-243 |     pass
+240 |     pass
     |
 help: Replace with `None`; initialize within function
-239 | 
-240 | # B006 and B008
-241 | # We should handle arbitrary nesting of these B008.
+236 | 
+237 | # B006 and B008
+238 | # We should handle arbitrary nesting of these B008.
     - def nested_combo(a=[float(3), dt.datetime.now()]):
-242 + def nested_combo(a=None):
-243 |     pass
-244 | 
-245 | 
+239 + def nested_combo(a=None):
+240 |     pass
+241 | 
+242 | 
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:279:27
+   --> B006_B008.py:276:27
     |
-278 | def mutable_annotations(
-279 |     a: list[int] | None = [],
+275 | def mutable_annotations(
+276 |     a: list[int] | None = [],
     |                           ^^
-280 |     b: Optional[Dict[int, int]] = {},
-281 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+277 |     b: Optional[Dict[int, int]] = {},
+278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
     |
 help: Replace with `None`; initialize within function
-276 | 
-277 | 
-278 | def mutable_annotations(
+273 | 
+274 | 
+275 | def mutable_annotations(
     -     a: list[int] | None = [],
-279 +     a: list[int] | None = None,
-280 |     b: Optional[Dict[int, int]] = {},
-281 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-282 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+276 +     a: list[int] | None = None,
+277 |     b: Optional[Dict[int, int]] = {},
+278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+279 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:280:35
+   --> B006_B008.py:277:35
     |
-278 | def mutable_annotations(
-279 |     a: list[int] | None = [],
-280 |     b: Optional[Dict[int, int]] = {},
+275 | def mutable_annotations(
+276 |     a: list[int] | None = [],
+277 |     b: Optional[Dict[int, int]] = {},
     |                                   ^^
-281 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-282 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+279 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
     |
 help: Replace with `None`; initialize within function
-277 | 
-278 | def mutable_annotations(
-279 |     a: list[int] | None = [],
+274 | 
+275 | def mutable_annotations(
+276 |     a: list[int] | None = [],
     -     b: Optional[Dict[int, int]] = {},
-280 +     b: Optional[Dict[int, int]] = None,
-281 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-282 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-283 | ):
+277 +     b: Optional[Dict[int, int]] = None,
+278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+279 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+280 | ):
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:281:62
+   --> B006_B008.py:278:62
     |
-279 |     a: list[int] | None = [],
-280 |     b: Optional[Dict[int, int]] = {},
-281 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+276 |     a: list[int] | None = [],
+277 |     b: Optional[Dict[int, int]] = {},
+278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
     |                                                              ^^^^^
-282 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-283 | ):
+279 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+280 | ):
     |
 help: Replace with `None`; initialize within function
-278 | def mutable_annotations(
-279 |     a: list[int] | None = [],
-280 |     b: Optional[Dict[int, int]] = {},
+275 | def mutable_annotations(
+276 |     a: list[int] | None = [],
+277 |     b: Optional[Dict[int, int]] = {},
     -     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-281 +     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = None,
-282 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-283 | ):
-284 |     pass
+278 +     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = None,
+279 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+280 | ):
+281 |     pass
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:282:80
+   --> B006_B008.py:279:80
     |
-280 |     b: Optional[Dict[int, int]] = {},
-281 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-282 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+277 |     b: Optional[Dict[int, int]] = {},
+278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+279 |     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
     |                                                                                ^^^^^
-283 | ):
-284 |     pass
+280 | ):
+281 |     pass
     |
 help: Replace with `None`; initialize within function
-279 |     a: list[int] | None = [],
-280 |     b: Optional[Dict[int, int]] = {},
-281 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
+276 |     a: list[int] | None = [],
+277 |     b: Optional[Dict[int, int]] = {},
+278 |     c: Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
     -     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = set(),
-282 +     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = None,
-283 | ):
-284 |     pass
-285 | 
+279 +     d: typing_extensions.Annotated[Union[Set[str], abc.Sized], "annotation"] = None,
+280 | ):
+281 |     pass
+282 | 
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:287:52
+   --> B006_B008.py:284:52
     |
-287 | def single_line_func_wrong(value: dict[str, str] = {}):
+284 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^
-288 |     """Docstring"""
+285 |     """Docstring"""
     |
 help: Replace with `None`; initialize within function
-284 |     pass
-285 | 
+281 |     pass
+282 | 
+283 | 
+    - def single_line_func_wrong(value: dict[str, str] = {}):
+284 + def single_line_func_wrong(value: dict[str, str] = None):
+285 |     """Docstring"""
 286 | 
-    - def single_line_func_wrong(value: dict[str, str] = {}):
-287 + def single_line_func_wrong(value: dict[str, str] = None):
-288 |     """Docstring"""
-289 | 
-290 | 
+287 | 
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:291:52
+   --> B006_B008.py:288:52
     |
-291 | def single_line_func_wrong(value: dict[str, str] = {}):
+288 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^
-292 |     """Docstring"""
-293 |     ...
+289 |     """Docstring"""
+290 |     ...
     |
 help: Replace with `None`; initialize within function
-288 |     """Docstring"""
-289 | 
-290 | 
+285 |     """Docstring"""
+286 | 
+287 | 
     - def single_line_func_wrong(value: dict[str, str] = {}):
-291 + def single_line_func_wrong(value: dict[str, str] = None):
-292 |     """Docstring"""
-293 |     ...
-294 | 
+288 + def single_line_func_wrong(value: dict[str, str] = None):
+289 |     """Docstring"""
+290 |     ...
+291 | 
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:296:52
+   --> B006_B008.py:293:52
     |
-296 | def single_line_func_wrong(value: dict[str, str] = {}):
+293 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^
-297 |     """Docstring"""; ...
+294 |     """Docstring"""; ...
     |
 help: Replace with `None`; initialize within function
-293 |     ...
-294 | 
+290 |     ...
+291 | 
+292 | 
+    - def single_line_func_wrong(value: dict[str, str] = {}):
+293 + def single_line_func_wrong(value: dict[str, str] = None):
+294 |     """Docstring"""; ...
 295 | 
-    - def single_line_func_wrong(value: dict[str, str] = {}):
-296 + def single_line_func_wrong(value: dict[str, str] = None):
-297 |     """Docstring"""; ...
-298 | 
-299 | 
+296 | 
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:300:52
+   --> B006_B008.py:297:52
     |
-300 | def single_line_func_wrong(value: dict[str, str] = {}):
+297 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^
-301 |     """Docstring"""; \
-302 |         ...
+298 |     """Docstring"""; \
+299 |         ...
     |
 help: Replace with `None`; initialize within function
-297 |     """Docstring"""; ...
-298 | 
-299 | 
+294 |     """Docstring"""; ...
+295 | 
+296 | 
     - def single_line_func_wrong(value: dict[str, str] = {}):
-300 + def single_line_func_wrong(value: dict[str, str] = None):
-301 |     """Docstring"""; \
-302 |         ...
-303 | 
+297 + def single_line_func_wrong(value: dict[str, str] = None):
+298 |     """Docstring"""; \
+299 |         ...
+300 | 
 note: This is an unsafe fix and may change runtime behavior
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:305:52
+   --> B006_B008.py:302:52
     |
-305 |   def single_line_func_wrong(value: dict[str, str] = {
+302 |   def single_line_func_wrong(value: dict[str, str] = {
     |  ____________________________________________________^
-306 | |     # This is a comment
-307 | | }):
+303 | |     # This is a comment
+304 | | }):
     | |_^
-308 |       """Docstring"""
+305 |       """Docstring"""
     |
 help: Replace with `None`; initialize within function
-302 |         ...
-303 | 
-304 | 
+299 |         ...
+300 | 
+301 | 
     - def single_line_func_wrong(value: dict[str, str] = {
     -     # This is a comment
     - }):
-305 + def single_line_func_wrong(value: dict[str, str] = None):
-306 |     """Docstring"""
-307 | 
-308 | 
+302 + def single_line_func_wrong(value: dict[str, str] = None):
+303 |     """Docstring"""
+304 | 
+305 | 
 note: This is an unsafe fix and may change runtime behavior
 
 B006 Do not use mutable data structures for argument defaults
-   --> B006_B008.py:311:52
+   --> B006_B008.py:308:52
     |
-311 | def single_line_func_wrong(value: dict[str, str] = {}) \
+308 | def single_line_func_wrong(value: dict[str, str] = {}) \
     |                                                    ^^
-312 |     : \
-313 |     """Docstring"""
+309 |     : \
+310 |     """Docstring"""
     |
 help: Replace with `None`; initialize within function
 
 B006 [*] Do not use mutable data structures for argument defaults
-   --> B006_B008.py:316:52
+   --> B006_B008.py:313:52
     |
-316 | def single_line_func_wrong(value: dict[str, str] = {}):
+313 | def single_line_func_wrong(value: dict[str, str] = {}):
     |                                                    ^^
-317 |     """Docstring without newline"""
+314 |     """Docstring without newline"""
     |
 help: Replace with `None`; initialize within function
-313 |     """Docstring"""
-314 | 
-315 | 
+310 |     """Docstring"""
+311 | 
+312 | 
     - def single_line_func_wrong(value: dict[str, str] = {}):
-316 + def single_line_func_wrong(value: dict[str, str] = None):
-317 |     """Docstring without newline"""
+313 + def single_line_func_wrong(value: dict[str, str] = None):
+314 |     """Docstring without newline"""
 note: This is an unsafe fix and may change runtime behavior

crates/ruff_linter/src/rules/pydocstyle/rules/sections.rs

@@ -4,9 +4,7 @@ use rustc_hash::FxHashSet;
 use std::sync::LazyLock;
 
 use ruff_macros::{ViolationMetadata, derive_message_formats};
-use ruff_python_ast::Parameter;
 use ruff_python_ast::docstrings::{clean_space, leading_space};
-use ruff_python_ast::helpers::map_subscript;
 use ruff_python_ast::identifier::Identifier;
 use ruff_python_semantic::analyze::visibility::is_staticmethod;
 use ruff_python_trivia::textwrap::dedent;
@@ -1186,9 +1184,6 @@ impl AlwaysFixableViolation for MissingSectionNameColon {
 /// This rule is enabled when using the `google` convention, and disabled when
 /// using the `pep257` and `numpy` conventions.
 ///
-/// Parameters annotated with `typing.Unpack` are exempt from this rule.
-/// This follows the Python typing specification for unpacking keyword arguments.
-///
 /// ## Example
 /// ```python
 /// def calculate_speed(distance: float, time: float) -> float:
@@ -1238,7 +1233,6 @@ impl AlwaysFixableViolation for MissingSectionNameColon {
 /// - [PEP 257 – Docstring Conventions](https://peps.python.org/pep-0257/)
 /// - [PEP 287 – reStructuredText Docstring Format](https://peps.python.org/pep-0287/)
 /// - [Google Python Style Guide - Docstrings](https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings)
-/// - [Python - Unpack for keyword arguments](https://typing.python.org/en/latest/spec/callables.html#unpack-kwargs)
 #[derive(ViolationMetadata)]
 #[violation_metadata(stable_since = "v0.0.73")]
 pub(crate) struct UndocumentedParam {
@@ -1814,9 +1808,7 @@ fn missing_args(checker: &Checker, docstring: &Docstring, docstrings_args: &FxHa
                 missing_arg_names.insert(starred_arg_name);
             }
         }
-        if let Some(arg) = function.parameters.kwarg.as_ref()
-            && !has_unpack_annotation(checker, arg)
-        {
+        if let Some(arg) = function.parameters.kwarg.as_ref() {
             let arg_name = arg.name.as_str();
             let starred_arg_name = format!("**{arg_name}");
             if !arg_name.starts_with('_')
@@ -1842,15 +1834,6 @@ fn missing_args(checker: &Checker, docstring: &Docstring, docstrings_args: &FxHa
     }
 }
 
-/// Returns `true` if the parameter is annotated with `typing.Unpack`
-fn has_unpack_annotation(checker: &Checker, parameter: &Parameter) -> bool {
-    parameter.annotation.as_ref().is_some_and(|annotation| {
-        checker
-            .semantic()
-            .match_typing_expr(map_subscript(annotation), "Unpack")
-    })
-}
-
 // See: `GOOGLE_ARGS_REGEX` in `pydocstyle/checker.py`.
 static GOOGLE_ARGS_REGEX: LazyLock<Regex> =
     LazyLock::new(|| Regex::new(r"^\s*(\*?\*?\w+)\s*(\(.*?\))?\s*:(\r\n|\n)?\s*.+").unwrap());

crates/ruff_linter/src/rules/pydocstyle/snapshots/ruff_linter__rules__pydocstyle__tests__d417_google.snap

@@ -101,13 +101,3 @@ D417 Missing argument description in the docstring for `should_fail`: `Args`
 200 |     """
 201 |     Send a message.
     |
-
-D417 Missing argument description in the docstring for `function_with_unpack_and_missing_arg_doc_should_fail`: `query`
-   --> D417.py:238:5
-    |
-236 |     """
-237 |
-238 | def function_with_unpack_and_missing_arg_doc_should_fail(query: str, **kwargs: Unpack[User]):
-    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-239 |     """Function with Unpack kwargs but missing query arg documentation.
-    |

crates/ruff_linter/src/rules/pydocstyle/snapshots/ruff_linter__rules__pydocstyle__tests__d417_google_ignore_var_parameters.snap

@@ -83,13 +83,3 @@ D417 Missing argument description in the docstring for `should_fail`: `Args`
 200 |     """
 201 |     Send a message.
     |
-
-D417 Missing argument description in the docstring for `function_with_unpack_and_missing_arg_doc_should_fail`: `query`
-   --> D417.py:238:5
-    |
-236 |     """
-237 |
-238 | def function_with_unpack_and_missing_arg_doc_should_fail(query: str, **kwargs: Unpack[User]):
-    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-239 |     """Function with Unpack kwargs but missing query arg documentation.
-    |

crates/ruff_linter/src/rules/pydocstyle/snapshots/ruff_linter__rules__pydocstyle__tests__d417_unspecified.snap

@@ -101,13 +101,3 @@ D417 Missing argument description in the docstring for `should_fail`: `Args`
 200 |     """
 201 |     Send a message.
     |
-
-D417 Missing argument description in the docstring for `function_with_unpack_and_missing_arg_doc_should_fail`: `query`
-   --> D417.py:238:5
-    |
-236 |     """
-237 |
-238 | def function_with_unpack_and_missing_arg_doc_should_fail(query: str, **kwargs: Unpack[User]):
-    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-239 |     """Function with Unpack kwargs but missing query arg documentation.
-    |

crates/ruff_linter/src/rules/pydocstyle/snapshots/ruff_linter__rules__pydocstyle__tests__d417_unspecified_ignore_var_parameters.snap

@@ -101,13 +101,3 @@ D417 Missing argument description in the docstring for `should_fail`: `Args`
 200 |     """
 201 |     Send a message.
     |
-
-D417 Missing argument description in the docstring for `function_with_unpack_and_missing_arg_doc_should_fail`: `query`
-   --> D417.py:238:5
-    |
-236 |     """
-237 |
-238 | def function_with_unpack_and_missing_arg_doc_should_fail(query: str, **kwargs: Unpack[User]):
-    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-239 |     """Function with Unpack kwargs but missing query arg documentation.
-    |

crates/ruff_linter/src/rules/pyflakes/mod.rs

@@ -28,7 +28,6 @@ mod tests {
     use crate::settings::types::PreviewMode;
     use crate::settings::{LinterSettings, flags};
     use crate::source_kind::SourceKind;
-    use crate::suppression::Suppressions;
     use crate::test::{test_contents, test_path, test_snippet};
     use crate::{Locator, assert_diagnostics, assert_diagnostics_diff, directives};
 
@@ -956,8 +955,6 @@ mod tests {
             &locator,
             &indexer,
         );
-        let suppressions =
-            Suppressions::from_tokens(&settings, locator.contents(), parsed.tokens());
         let mut messages = check_path(
             Path::new("<filename>"),
             None,
@@ -971,7 +968,6 @@ mod tests {
             source_type,
             &parsed,
             target_version,
-            &suppressions,
         );
         messages.sort_by(Diagnostic::ruff_start_ordering);
         let actual = messages

crates/ruff_linter/src/rules/ruff/mod.rs

@@ -305,25 +305,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn range_suppressions() -> Result<()> {
-        assert_diagnostics_diff!(
-            Path::new("ruff/suppressions.py"),
-            &settings::LinterSettings::for_rules(vec![
-                Rule::UnusedVariable,
-                Rule::AmbiguousVariableName,
-                Rule::UnusedNOQA,
-            ]),
-            &settings::LinterSettings::for_rules(vec![
-                Rule::UnusedVariable,
-                Rule::AmbiguousVariableName,
-                Rule::UnusedNOQA,
-            ])
-            .with_preview_mode(),
-        );
-        Ok(())
-    }
-
     #[test]
     fn ruf100_0() -> Result<()> {
         let diagnostics = test_path(

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__range_suppressions.snap

@@ -1,168 +0,0 @@
----
-source: crates/ruff_linter/src/rules/ruff/mod.rs
----
---- Linter settings ---
--linter.preview = disabled
-+linter.preview = enabled
-
---- Summary ---
-Removed: 9
-Added: 1
-
---- Removed ---
-E741 Ambiguous variable name: `I`
- --> suppressions.py:4:5
-  |
-2 |     # These should both be ignored by the range suppression.
-3 |     # ruff: disable[E741, F841]
-4 |     I = 1
-  |     ^
-5 |     # ruff: enable[E741, F841]
-  |
-
-
-F841 [*] Local variable `I` is assigned to but never used
- --> suppressions.py:4:5
-  |
-2 |     # These should both be ignored by the range suppression.
-3 |     # ruff: disable[E741, F841]
-4 |     I = 1
-  |     ^
-5 |     # ruff: enable[E741, F841]
-  |
-help: Remove assignment to unused variable `I`
-1 | def f():
-2 |     # These should both be ignored by the range suppression.
-3 |     # ruff: disable[E741, F841]
-  -     I = 1
-4 +     pass
-5 |     # ruff: enable[E741, F841]
-6 | 
-7 | 
-note: This is an unsafe fix and may change runtime behavior
-
-
-E741 Ambiguous variable name: `I`
-  --> suppressions.py:12:5
-   |
-10 |     # Should also generate an "unmatched suppression" warning.
-11 |     # ruff:disable[E741,F841]
-12 |     I = 1
-   |     ^
-   |
-
-
-F841 [*] Local variable `I` is assigned to but never used
-  --> suppressions.py:12:5
-   |
-10 |     # Should also generate an "unmatched suppression" warning.
-11 |     # ruff:disable[E741,F841]
-12 |     I = 1
-   |     ^
-   |
-help: Remove assignment to unused variable `I`
-9  |     # These should both be ignored by the implicit range suppression.
-10 |     # Should also generate an "unmatched suppression" warning.
-11 |     # ruff:disable[E741,F841]
-   -     I = 1
-12 +     pass
-13 | 
-14 | 
-15 | def f():
-note: This is an unsafe fix and may change runtime behavior
-
-
-E741 Ambiguous variable name: `I`
-  --> suppressions.py:26:5
-   |
-24 |     # the other logged to the user.
-25 |     # ruff: disable[E741]
-26 |     I = 1
-   |     ^
-27 |     # ruff: enable[E741]
-   |
-
-
-E741 Ambiguous variable name: `l`
-  --> suppressions.py:35:5
-   |
-33 |     # middle line should be completely silenced.
-34 |     # ruff: disable[E741]
-35 |     l = 0
-   |     ^
-36 |     # ruff: disable[F841]
-37 |     O = 1
-   |
-
-
-E741 Ambiguous variable name: `O`
-  --> suppressions.py:37:5
-   |
-35 |     l = 0
-36 |     # ruff: disable[F841]
-37 |     O = 1
-   |     ^
-38 |     # ruff: enable[E741]
-39 |     I = 2
-   |
-
-
-F841 [*] Local variable `O` is assigned to but never used
-  --> suppressions.py:37:5
-   |
-35 |     l = 0
-36 |     # ruff: disable[F841]
-37 |     O = 1
-   |     ^
-38 |     # ruff: enable[E741]
-39 |     I = 2
-   |
-help: Remove assignment to unused variable `O`
-34 |     # ruff: disable[E741]
-35 |     l = 0
-36 |     # ruff: disable[F841]
-   -     O = 1
-37 |     # ruff: enable[E741]
-38 |     I = 2
-39 |     # ruff: enable[F841]
-note: This is an unsafe fix and may change runtime behavior
-
-
-F841 [*] Local variable `I` is assigned to but never used
-  --> suppressions.py:39:5
-   |
-37 |     O = 1
-38 |     # ruff: enable[E741]
-39 |     I = 2
-   |     ^
-40 |     # ruff: enable[F841]
-   |
-help: Remove assignment to unused variable `I`
-36 |     # ruff: disable[F841]
-37 |     O = 1
-38 |     # ruff: enable[E741]
-   -     I = 2
-39 |     # ruff: enable[F841]
-40 | 
-41 | 
-note: This is an unsafe fix and may change runtime behavior
-
-
-
---- Added ---
-RUF100 [*] Unused `noqa` directive (unused: `E741`, `F841`)
-  --> suppressions.py:55:12
-   |
-53 |     # and an unusued noqa diagnostic should be logged.
-54 |     # ruff:disable[E741,F841]
-55 |     I = 1  # noqa: E741,F841
-   |            ^^^^^^^^^^^^^^^^^
-56 |     # ruff:enable[E741,F841]
-   |
-help: Remove unused `noqa` directive
-52 |     # These should both be ignored by the range suppression,
-53 |     # and an unusued noqa diagnostic should be logged.
-54 |     # ruff:disable[E741,F841]
-   -     I = 1  # noqa: E741,F841
-55 +     I = 1
-56 |     # ruff:enable[E741,F841]

crates/ruff_linter/src/settings/mod.rs

@@ -465,12 +465,6 @@ impl LinterSettings {
         self
     }
 
-    #[must_use]
-    pub fn with_preview_mode(mut self) -> Self {
-        self.preview = PreviewMode::Enabled;
-        self
-    }
-
     /// Resolve the [`TargetVersion`] to use for linting.
     ///
     /// This method respects the per-file version overrides in

crates/ruff_linter/src/snapshots/ruff_linter__linter__tests__return_in_generator.py.snap

@@ -1,55 +0,0 @@
----
-source: crates/ruff_linter/src/linter.rs
----
-B901 Using `yield` and `return {value}` in a generator function can lead to confusing behavior
- --> resources/test/fixtures/syntax_errors/return_in_generator.py:3:5
-  |
-1 | async def gen():
-2 |     yield 1
-3 |     return 42
-  |     ^^^^^^^^^
-4 |
-5 | def gen(): # B901 but not a syntax error - not an async generator
-  |
-
-B901 Using `yield` and `return {value}` in a generator function can lead to confusing behavior
- --> resources/test/fixtures/syntax_errors/return_in_generator.py:7:5
-  |
-5 | def gen(): # B901 but not a syntax error - not an async generator
-6 |     yield 1
-7 |     return 42
-  |     ^^^^^^^^^
-8 |
-9 | async def gen(): # ok - no value in return
-  |
-
-B901 Using `yield` and `return {value}` in a generator function can lead to confusing behavior
-  --> resources/test/fixtures/syntax_errors/return_in_generator.py:15:5
-   |
-13 | async def gen():
-14 |     yield 1
-15 |     return foo()
-   |     ^^^^^^^^^^^^
-16 |
-17 | async def gen():
-   |
-
-B901 Using `yield` and `return {value}` in a generator function can lead to confusing behavior
-  --> resources/test/fixtures/syntax_errors/return_in_generator.py:19:5
-   |
-17 | async def gen():
-18 |     yield 1
-19 |     return [1, 2, 3]
-   |     ^^^^^^^^^^^^^^^^
-20 |
-21 | async def gen():
-   |
-
-B901 Using `yield` and `return {value}` in a generator function can lead to confusing behavior
-  --> resources/test/fixtures/syntax_errors/return_in_generator.py:24:5
-   |
-22 |     if True:
-23 |         yield 1
-24 |     return 10
-   |     ^^^^^^^^^
-   |

crates/ruff_linter/src/suppression.rs

@@ -1,6 +1,5 @@
 use compact_str::CompactString;
 use core::fmt;
-use ruff_db::diagnostic::Diagnostic;
 use ruff_python_ast::token::{TokenKind, Tokens};
 use ruff_python_ast::whitespace::indentation;
 use std::{error::Error, fmt::Formatter};
@@ -10,9 +9,6 @@ use ruff_python_trivia::Cursor;
 use ruff_text_size::{Ranged, TextLen, TextRange, TextSize, TextSlice};
 use smallvec::{SmallVec, smallvec};
 
-use crate::preview::is_range_suppressions_enabled;
-use crate::settings::LinterSettings;
-
 #[allow(unused)]
 #[derive(Clone, Debug, Eq, PartialEq)]
 enum SuppressionAction {
@@ -102,8 +98,8 @@ pub(crate) struct InvalidSuppression {
 }
 
 #[allow(unused)]
-#[derive(Debug, Default)]
-pub struct Suppressions {
+#[derive(Debug)]
+pub(crate) struct Suppressions {
     /// Valid suppression ranges with associated comments
     valid: Vec<Suppression>,
 
@@ -116,41 +112,9 @@ pub struct Suppressions {
 
 #[allow(unused)]
 impl Suppressions {
-    pub fn from_tokens(settings: &LinterSettings, source: &str, tokens: &Tokens) -> Suppressions {
-        if is_range_suppressions_enabled(settings) {
-            let builder = SuppressionsBuilder::new(source);
-            builder.load_from_tokens(tokens)
-        } else {
-            Suppressions::default()
-        }
-    }
-
-    pub(crate) fn is_empty(&self) -> bool {
-        self.valid.is_empty()
-    }
-
-    /// Check if a diagnostic is suppressed by any known range suppressions
-    pub(crate) fn check_diagnostic(&self, diagnostic: &Diagnostic) -> bool {
-        if self.valid.is_empty() {
-            return false;
-        }
-
-        let Some(code) = diagnostic.secondary_code() else {
-            return false;
-        };
-        let Some(span) = diagnostic.primary_span() else {
-            return false;
-        };
-        let Some(range) = span.range() else {
-            return false;
-        };
-
-        for suppression in &self.valid {
-            if *code == suppression.code.as_str() && suppression.range.contains_range(range) {
-                return true;
-            }
-        }
-        false
+    pub(crate) fn from_tokens(source: &str, tokens: &Tokens) -> Suppressions {
+        let builder = SuppressionsBuilder::new(source);
+        builder.load_from_tokens(tokens)
     }
 }
 
@@ -493,12 +457,9 @@ mod tests {
     use ruff_text_size::{TextRange, TextSize};
     use similar::DiffableStr;
 
-    use crate::{
-        settings::LinterSettings,
-        suppression::{
-            InvalidSuppression, ParseError, Suppression, SuppressionAction, SuppressionComment,
-            SuppressionParser, Suppressions,
-        },
+    use crate::suppression::{
+        InvalidSuppression, ParseError, Suppression, SuppressionAction, SuppressionComment,
+        SuppressionParser, Suppressions,
     };
 
     #[test]
@@ -1415,11 +1376,7 @@ def bar():
         /// Parse all suppressions and errors in a module for testing
         fn debug(source: &'_ str) -> DebugSuppressions<'_> {
             let parsed = parse(source, ParseOptions::from(Mode::Module)).unwrap();
-            let suppressions = Suppressions::from_tokens(
-                &LinterSettings::default().with_preview_mode(),
-                source,
-                parsed.tokens(),
-            );
+            let suppressions = Suppressions::from_tokens(source, parsed.tokens());
             DebugSuppressions {
                 source,
                 suppressions,

crates/ruff_linter/src/test.rs

@@ -32,7 +32,6 @@ use crate::packaging::detect_package_root;
 use crate::settings::types::UnsafeFixes;
 use crate::settings::{LinterSettings, flags};
 use crate::source_kind::SourceKind;
-use crate::suppression::Suppressions;
 use crate::{Applicability, FixAvailability};
 use crate::{Locator, directives};
 
@@ -235,7 +234,6 @@ pub(crate) fn test_contents<'a>(
         &locator,
         &indexer,
     );
-    let suppressions = Suppressions::from_tokens(settings, locator.contents(), parsed.tokens());
     let messages = check_path(
         path,
         path.parent()
@@ -251,7 +249,6 @@ pub(crate) fn test_contents<'a>(
         source_type,
         &parsed,
         target_version,
-        &suppressions,
     );
 
     let source_has_errors = parsed.has_invalid_syntax();
@@ -302,8 +299,6 @@ pub(crate) fn test_contents<'a>(
                 &indexer,
             );
 
-            let suppressions =
-                Suppressions::from_tokens(settings, locator.contents(), parsed.tokens());
             let fixed_messages = check_path(
                 path,
                 None,
@@ -317,7 +312,6 @@ pub(crate) fn test_contents<'a>(
                 source_type,
                 &parsed,
                 target_version,
-                &suppressions,
             );
 
             if parsed.has_invalid_syntax() && !source_has_errors {

crates/ruff_python_parser/src/semantic_errors.rs

@@ -3,13 +3,12 @@
 //! This checker is not responsible for traversing the AST itself. Instead, its
 //! [`SemanticSyntaxChecker::visit_stmt`] and [`SemanticSyntaxChecker::visit_expr`] methods should
 //! be called in a parent `Visitor`'s `visit_stmt` and `visit_expr` methods, respectively.
-
 use ruff_python_ast::{
     self as ast, Expr, ExprContext, IrrefutablePatternKind, Pattern, PythonVersion, Stmt, StmtExpr,
-    StmtFunctionDef, StmtImportFrom,
+    StmtImportFrom,
     comparable::ComparableExpr,
     helpers,
-    visitor::{Visitor, walk_expr, walk_stmt},
+    visitor::{Visitor, walk_expr},
 };
 use ruff_text_size::{Ranged, TextRange, TextSize};
 use rustc_hash::{FxBuildHasher, FxHashSet};
@@ -740,21 +739,7 @@ impl SemanticSyntaxChecker {
                     self.seen_futures_boundary = true;
                 }
             }
-            Stmt::FunctionDef(StmtFunctionDef { is_async, body, .. }) => {
-                if *is_async {
-                    let mut visitor = ReturnVisitor::default();
-                    visitor.visit_body(body);
-
-                    if visitor.has_yield {
-                        if let Some(return_range) = visitor.return_range {
-                            Self::add_error(
-                                ctx,
-                                SemanticSyntaxErrorKind::ReturnInGenerator,
-                                return_range,
-                            );
-                        }
-                    }
-                }
+            Stmt::FunctionDef(_) => {
                 self.seen_futures_boundary = true;
             }
             _ => {
@@ -1228,9 +1213,6 @@ impl Display for SemanticSyntaxError {
             SemanticSyntaxErrorKind::NonlocalWithoutBinding(name) => {
                 write!(f, "no binding for nonlocal `{name}` found")
             }
-            SemanticSyntaxErrorKind::ReturnInGenerator => {
-                write!(f, "`return` with value in async generator")
-            }
         }
     }
 }
@@ -1637,9 +1619,6 @@ pub enum SemanticSyntaxErrorKind {
 
     /// Represents a default type parameter followed by a non-default type parameter.
     TypeParameterDefaultOrder(String),
-
-    /// Represents a `return` statement with a value in an asynchronous generator.
-    ReturnInGenerator,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, get_size2::GetSize)]
@@ -1756,40 +1735,6 @@ impl Visitor<'_> for ReboundComprehensionVisitor<'_> {
     }
 }
 
-#[derive(Default)]
-struct ReturnVisitor {
-    return_range: Option<TextRange>,
-    has_yield: bool,
-}
-
-impl Visitor<'_> for ReturnVisitor {
-    fn visit_stmt(&mut self, stmt: &Stmt) {
-        match stmt {
-            // Do not recurse into nested functions; they're evaluated separately.
-            Stmt::FunctionDef(_) | Stmt::ClassDef(_) => {}
-            Stmt::Return(ast::StmtReturn {
-                value: Some(_),
-                range,
-                ..
-            }) => {
-                self.return_range = Some(*range);
-                walk_stmt(self, stmt);
-            }
-            _ => walk_stmt(self, stmt),
-        }
-    }
-
-    fn visit_expr(&mut self, expr: &Expr) {
-        match expr {
-            Expr::Lambda(_) => {}
-            Expr::Yield(_) | Expr::YieldFrom(_) => {
-                self.has_yield = true;
-            }
-            _ => walk_expr(self, expr),
-        }
-    }
-}
-
 struct MatchPatternVisitor<'a, Ctx> {
     names: FxHashSet<&'a ast::name::Name>,
     ctx: &'a Ctx,

crates/ruff_python_stdlib/src/typing.rs

@@ -326,15 +326,7 @@ pub fn is_immutable_return_type(qualified_name: &[&str]) -> bool {
             | ["re", "compile"]
             | [
                 "",
-                "bool"
-                    | "bytes"
-                    | "complex"
-                    | "float"
-                    | "frozenset"
-                    | "int"
-                    | "str"
-                    | "tuple"
-                    | "slice"
+                "bool" | "bytes" | "complex" | "float" | "frozenset" | "int" | "str" | "tuple"
             ]
     )
 }

crates/ruff_server/src/lint.rs

@@ -20,7 +20,6 @@ use ruff_linter::{
     packaging::detect_package_root,
     settings::flags,
     source_kind::SourceKind,
-    suppression::Suppressions,
 };
 use ruff_notebook::Notebook;
 use ruff_python_codegen::Stylist;
@@ -119,10 +118,6 @@ pub(crate) fn check(
     // Extract the `# noqa` and `# isort: skip` directives from the source.
     let directives = extract_directives(parsed.tokens(), Flags::all(), &locator, &indexer);
 
-    // Parse range suppression comments
-    let suppressions =
-        Suppressions::from_tokens(&settings.linter, locator.contents(), parsed.tokens());
-
     // Generate checks.
     let diagnostics = check_path(
         &document_path,
@@ -137,7 +132,6 @@ pub(crate) fn check(
         source_type,
         &parsed,
         target_version,
-        &suppressions,
     );
 
     let noqa_edits = generate_noqa_edits(
@@ -148,7 +142,6 @@ pub(crate) fn check(
         &settings.linter.external,
         &directives.noqa_line_for,
         stylist.line_ending(),
-        &suppressions,
     );
 
     let mut diagnostics_map = DiagnosticsMap::default();

crates/ruff_source_file/src/line_index.rs

@@ -33,29 +33,26 @@ impl LineIndex {
         line_starts.push(TextSize::default());
 
         let bytes = text.as_bytes();
+        let mut utf8 = false;
 
         assert!(u32::try_from(bytes.len()).is_ok());
 
-        for i in memchr::memchr2_iter(b'\n', b'\r', bytes) {
-            // Skip `\r` in `\r\n` sequences (only count the `\n`).
-            if bytes[i] == b'\r' && bytes.get(i + 1) == Some(&b'\n') {
-                continue;
+        for (i, byte) in bytes.iter().enumerate() {
+            utf8 |= !byte.is_ascii();
+
+            match byte {
+                // Only track one line break for `\r\n`.
+                b'\r' if bytes.get(i + 1) == Some(&b'\n') => continue,
+                b'\n' | b'\r' => {
+                    // SAFETY: Assertion above guarantees `i <= u32::MAX`
+                    #[expect(clippy::cast_possible_truncation)]
+                    line_starts.push(TextSize::from(i as u32) + TextSize::from(1));
+                }
+                _ => {}
             }
-            // SAFETY: Assertion above guarantees `i <= u32::MAX`
-            #[expect(clippy::cast_possible_truncation)]
-            line_starts.push(TextSize::from(i as u32) + TextSize::from(1));
         }
 
-        // Determine whether the source text is ASCII.
-        //
-        // Empirically, this simple loop is auto-vectorized by LLVM and benchmarks faster than both
-        // `str::is_ascii()` and hand-written SIMD.
-        let mut has_non_ascii = false;
-        for byte in bytes {
-            has_non_ascii |= !byte.is_ascii();
-        }
-
-        let kind = if has_non_ascii {
+        let kind = if utf8 {
             IndexKind::Utf8
         } else {
             IndexKind::Ascii

crates/ruff_wasm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_wasm"
-version = "0.14.8"
+version = "0.14.7"
 publish = false
 authors = { workspace = true }
 edition = { workspace = true }

crates/ruff_wasm/src/lib.rs

@@ -2,7 +2,6 @@ use std::path::Path;
 
 use js_sys::Error;
 use ruff_linter::settings::types::PythonVersion;
-use ruff_linter::suppression::Suppressions;
 use serde::{Deserialize, Serialize};
 use wasm_bindgen::prelude::*;
 
@@ -213,9 +212,6 @@ impl Workspace {
             &indexer,
         );
 
-        let suppressions =
-            Suppressions::from_tokens(&self.settings.linter, locator.contents(), parsed.tokens());
-
         // Generate checks.
         let diagnostics = check_path(
             Path::new("<filename>"),
@@ -230,7 +226,6 @@ impl Workspace {
             source_type,
             &parsed,
             target_version,
-            &suppressions,
         );
 
         let source_code = locator.to_source_code();

crates/ty/tests/cli/python_environment.rs

@@ -43,7 +43,7 @@ fn config_override_python_version() -> anyhow::Result<()> {
       |
     2 | [tool.ty.environment]
     3 | python-version = "3.11"
-      |                  ^^^^^^ Python version configuration
+      |                  ^^^^^^ Python 3.11 assumed due to this configuration setting
       |
     info: rule `unresolved-attribute` is enabled by default
 
@@ -143,7 +143,7 @@ fn config_file_annotation_showing_where_python_version_set_typing_error() -> any
         ),
     ])?;
 
-    assert_cmd_snapshot!(case.command(), @r#"
+    assert_cmd_snapshot!(case.command(), @r###"
     success: false
     exit_code: 1
     ----- stdout -----
@@ -159,14 +159,14 @@ fn config_file_annotation_showing_where_python_version_set_typing_error() -> any
       |
     2 | [tool.ty.environment]
     3 | python-version = "3.8"
-      |                  ^^^^^ Python version configuration
+      |                  ^^^^^ Python 3.8 assumed due to this configuration setting
       |
     info: rule `unresolved-reference` is enabled by default
 
     Found 1 diagnostic
 
     ----- stderr -----
-    "#);
+    "###);
 
     assert_cmd_snapshot!(case.command().arg("--python-version=3.9"), @r###"
     success: false
@@ -772,7 +772,7 @@ fn pyvenv_cfg_file_annotation_showing_where_python_version_set() -> anyhow::Resu
         ("test.py", "aiter"),
     ])?;
 
-    assert_cmd_snapshot!(case.command(), @r"
+    assert_cmd_snapshot!(case.command(), @r###"
     success: false
     exit_code: 1
     ----- stdout -----
@@ -787,7 +787,7 @@ fn pyvenv_cfg_file_annotation_showing_where_python_version_set() -> anyhow::Resu
      --> venv/pyvenv.cfg:2:11
       |
     2 | version = 3.8
-      |           ^^^ Virtual environment metadata
+      |           ^^^ Python version inferred from virtual environment metadata file
     3 | home = foo/bar/bin
       |
     info: No Python version was specified on the command line or in a configuration file
@@ -796,7 +796,7 @@ fn pyvenv_cfg_file_annotation_showing_where_python_version_set() -> anyhow::Resu
     Found 1 diagnostic
 
     ----- stderr -----
-    ");
+    "###);
 
     Ok(())
 }
@@ -831,7 +831,7 @@ fn pyvenv_cfg_file_annotation_no_trailing_newline() -> anyhow::Result<()> {
         ("test.py", "aiter"),
     ])?;
 
-    assert_cmd_snapshot!(case.command(), @r"
+    assert_cmd_snapshot!(case.command(), @r###"
     success: false
     exit_code: 1
     ----- stdout -----
@@ -846,7 +846,7 @@ fn pyvenv_cfg_file_annotation_no_trailing_newline() -> anyhow::Result<()> {
      --> venv/pyvenv.cfg:4:23
       |
     4 |             version = 3.8
-      |                       ^^^ Virtual environment metadata
+      |                       ^^^ Python version inferred from virtual environment metadata file
       |
     info: No Python version was specified on the command line or in a configuration file
     info: rule `unresolved-reference` is enabled by default
@@ -854,7 +854,7 @@ fn pyvenv_cfg_file_annotation_no_trailing_newline() -> anyhow::Result<()> {
     Found 1 diagnostic
 
     ----- stderr -----
-    ");
+    "###);
 
     Ok(())
 }
@@ -898,7 +898,7 @@ fn config_file_annotation_showing_where_python_version_set_syntax_error() -> any
       |
     2 | [project]
     3 | requires-python = ">=3.8"
-      |                   ^^^^^^^ Python version configuration
+      |                   ^^^^^^^ Python 3.8 assumed due to this configuration setting
       |
 
     Found 1 diagnostic
@@ -1206,7 +1206,7 @@ fn defaults_to_a_new_python_version() -> anyhow::Result<()> {
       |
     2 | [environment]
     3 | python-version = "3.10"
-      |                  ^^^^^^ Python version configuration
+      |                  ^^^^^^ Python 3.10 assumed due to this configuration setting
     4 | python-platform = "linux"
       |
     info: rule `unresolved-attribute` is enabled by default
@@ -1225,7 +1225,7 @@ fn defaults_to_a_new_python_version() -> anyhow::Result<()> {
       |
     2 | [environment]
     3 | python-version = "3.10"
-      |                  ^^^^^^ Python version configuration
+      |                  ^^^^^^ Python 3.10 assumed due to this configuration setting
     4 | python-platform = "linux"
       |
     info: rule `unresolved-import` is enabled by default

crates/ty/tests/file_watching.rs

@@ -15,7 +15,7 @@ use ty_project::metadata::pyproject::{PyProject, Tool};
 use ty_project::metadata::value::{RangedValue, RelativePathBuf};
 use ty_project::watch::{ChangeEvent, ProjectWatcher, directory_watcher};
 use ty_project::{Db, ProjectDatabase, ProjectMetadata};
-use ty_python_semantic::{Module, ModuleName, PythonPlatform, resolve_module_confident};
+use ty_python_semantic::{Module, ModuleName, PythonPlatform, resolve_module};
 
 struct TestCase {
     db: ProjectDatabase,
@@ -232,8 +232,7 @@ impl TestCase {
     }
 
     fn module<'c>(&'c self, name: &str) -> Module<'c> {
-        resolve_module_confident(self.db(), &ModuleName::new(name).unwrap())
-            .expect("module to be present")
+        resolve_module(self.db(), &ModuleName::new(name).unwrap()).expect("module to be present")
     }
 
     fn sorted_submodule_names(&self, parent_module_name: &str) -> Vec<String> {
@@ -812,8 +811,7 @@ fn directory_moved_to_project() -> anyhow::Result<()> {
         .with_context(|| "Failed to create __init__.py")?;
     std::fs::write(a_original_path.as_std_path(), "").with_context(|| "Failed to create a.py")?;
 
-    let sub_a_module =
-        resolve_module_confident(case.db(), &ModuleName::new_static("sub.a").unwrap());
+    let sub_a_module = resolve_module(case.db(), &ModuleName::new_static("sub.a").unwrap());
 
     assert_eq!(sub_a_module, None);
     case.assert_indexed_project_files([bar]);
@@ -834,9 +832,7 @@ fn directory_moved_to_project() -> anyhow::Result<()> {
         .expect("a.py to exist");
 
     // `import sub.a` should now resolve
-    assert!(
-        resolve_module_confident(case.db(), &ModuleName::new_static("sub.a").unwrap()).is_some()
-    );
+    assert!(resolve_module(case.db(), &ModuleName::new_static("sub.a").unwrap()).is_some());
 
     case.assert_indexed_project_files([bar, init_file, a_file]);
 
@@ -852,9 +848,7 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
     ])?;
     let bar = case.system_file(case.project_path("bar.py")).unwrap();
 
-    assert!(
-        resolve_module_confident(case.db(), &ModuleName::new_static("sub.a").unwrap()).is_some()
-    );
+    assert!(resolve_module(case.db(), &ModuleName::new_static("sub.a").unwrap()).is_some());
 
     let sub_path = case.project_path("sub");
     let init_file = case
@@ -876,9 +870,7 @@ fn directory_moved_to_trash() -> anyhow::Result<()> {
     case.apply_changes(changes, None);
 
     // `import sub.a` should no longer resolve
-    assert!(
-        resolve_module_confident(case.db(), &ModuleName::new_static("sub.a").unwrap()).is_none()
-    );
+    assert!(resolve_module(case.db(), &ModuleName::new_static("sub.a").unwrap()).is_none());
 
     assert!(!init_file.exists(case.db()));
     assert!(!a_file.exists(case.db()));
@@ -898,12 +890,8 @@ fn directory_renamed() -> anyhow::Result<()> {
 
     let bar = case.system_file(case.project_path("bar.py")).unwrap();
 
-    assert!(
-        resolve_module_confident(case.db(), &ModuleName::new_static("sub.a").unwrap()).is_some()
-    );
-    assert!(
-        resolve_module_confident(case.db(), &ModuleName::new_static("foo.baz").unwrap()).is_none()
-    );
+    assert!(resolve_module(case.db(), &ModuleName::new_static("sub.a").unwrap()).is_some());
+    assert!(resolve_module(case.db(), &ModuleName::new_static("foo.baz").unwrap()).is_none());
 
     let sub_path = case.project_path("sub");
     let sub_init = case
@@ -927,13 +915,9 @@ fn directory_renamed() -> anyhow::Result<()> {
     case.apply_changes(changes, None);
 
     // `import sub.a` should no longer resolve
-    assert!(
-        resolve_module_confident(case.db(), &ModuleName::new_static("sub.a").unwrap()).is_none()
-    );
+    assert!(resolve_module(case.db(), &ModuleName::new_static("sub.a").unwrap()).is_none());
     // `import foo.baz` should now resolve
-    assert!(
-        resolve_module_confident(case.db(), &ModuleName::new_static("foo.baz").unwrap()).is_some()
-    );
+    assert!(resolve_module(case.db(), &ModuleName::new_static("foo.baz").unwrap()).is_some());
 
     // The old paths are no longer tracked
     assert!(!sub_init.exists(case.db()));
@@ -966,9 +950,7 @@ fn directory_deleted() -> anyhow::Result<()> {
 
     let bar = case.system_file(case.project_path("bar.py")).unwrap();
 
-    assert!(
-        resolve_module_confident(case.db(), &ModuleName::new_static("sub.a").unwrap()).is_some()
-    );
+    assert!(resolve_module(case.db(), &ModuleName::new_static("sub.a").unwrap()).is_some());
 
     let sub_path = case.project_path("sub");
 
@@ -988,9 +970,7 @@ fn directory_deleted() -> anyhow::Result<()> {
     case.apply_changes(changes, None);
 
     // `import sub.a` should no longer resolve
-    assert!(
-        resolve_module_confident(case.db(), &ModuleName::new_static("sub.a").unwrap()).is_none()
-    );
+    assert!(resolve_module(case.db(), &ModuleName::new_static("sub.a").unwrap()).is_none());
 
     assert!(!init_file.exists(case.db()));
     assert!(!a_file.exists(case.db()));
@@ -1019,7 +999,7 @@ fn search_path() -> anyhow::Result<()> {
     let site_packages = case.root_path().join("site_packages");
 
     assert_eq!(
-        resolve_module_confident(case.db(), &ModuleName::new("a").unwrap()),
+        resolve_module(case.db(), &ModuleName::new("a").unwrap()),
         None
     );
 
@@ -1029,7 +1009,7 @@ fn search_path() -> anyhow::Result<()> {
 
     case.apply_changes(changes, None);
 
-    assert!(resolve_module_confident(case.db(), &ModuleName::new_static("a").unwrap()).is_some());
+    assert!(resolve_module(case.db(), &ModuleName::new_static("a").unwrap()).is_some());
     case.assert_indexed_project_files([case.system_file(case.project_path("bar.py")).unwrap()]);
 
     Ok(())
@@ -1042,7 +1022,7 @@ fn add_search_path() -> anyhow::Result<()> {
     let site_packages = case.project_path("site_packages");
     std::fs::create_dir_all(site_packages.as_std_path())?;
 
-    assert!(resolve_module_confident(case.db(), &ModuleName::new_static("a").unwrap()).is_none());
+    assert!(resolve_module(case.db(), &ModuleName::new_static("a").unwrap()).is_none());
 
     // Register site-packages as a search path.
     case.update_options(Options {
@@ -1060,7 +1040,7 @@ fn add_search_path() -> anyhow::Result<()> {
 
     case.apply_changes(changes, None);
 
-    assert!(resolve_module_confident(case.db(), &ModuleName::new_static("a").unwrap()).is_some());
+    assert!(resolve_module(case.db(), &ModuleName::new_static("a").unwrap()).is_some());
 
     Ok(())
 }
@@ -1192,7 +1172,7 @@ fn changed_versions_file() -> anyhow::Result<()> {
 
     // Unset the custom typeshed directory.
     assert_eq!(
-        resolve_module_confident(case.db(), &ModuleName::new("os").unwrap()),
+        resolve_module(case.db(), &ModuleName::new("os").unwrap()),
         None
     );
 
@@ -1207,7 +1187,7 @@ fn changed_versions_file() -> anyhow::Result<()> {
 
     case.apply_changes(changes, None);
 
-    assert!(resolve_module_confident(case.db(), &ModuleName::new("os").unwrap()).is_some());
+    assert!(resolve_module(case.db(), &ModuleName::new("os").unwrap()).is_some());
 
     Ok(())
 }
@@ -1430,7 +1410,7 @@ mod unix {
             Ok(())
         })?;
 
-        let baz = resolve_module_confident(case.db(), &ModuleName::new_static("bar.baz").unwrap())
+        let baz = resolve_module(case.db(), &ModuleName::new_static("bar.baz").unwrap())
             .expect("Expected bar.baz to exist in site-packages.");
         let baz_project = case.project_path("bar/baz.py");
         let baz_file = baz.file(case.db()).unwrap();
@@ -1506,7 +1486,7 @@ mod unix {
             Ok(())
         })?;
 
-        let baz = resolve_module_confident(case.db(), &ModuleName::new_static("bar.baz").unwrap())
+        let baz = resolve_module(case.db(), &ModuleName::new_static("bar.baz").unwrap())
             .expect("Expected bar.baz to exist in site-packages.");
         let baz_file = baz.file(case.db()).unwrap();
         let bar_baz = case.project_path("bar/baz.py");
@@ -1611,7 +1591,7 @@ mod unix {
             Ok(())
         })?;
 
-        let baz = resolve_module_confident(case.db(), &ModuleName::new_static("bar.baz").unwrap())
+        let baz = resolve_module(case.db(), &ModuleName::new_static("bar.baz").unwrap())
             .expect("Expected bar.baz to exist in site-packages.");
         let baz_site_packages_path =
             case.project_path(".venv/lib/python3.12/site-packages/bar/baz.py");
@@ -1874,11 +1854,11 @@ fn rename_files_casing_only() -> anyhow::Result<()> {
     let mut case = setup([("lib.py", "class Foo: ...")])?;
 
     assert!(
-        resolve_module_confident(case.db(), &ModuleName::new("lib").unwrap()).is_some(),
+        resolve_module(case.db(), &ModuleName::new("lib").unwrap()).is_some(),
         "Expected `lib` module to exist."
     );
     assert_eq!(
-        resolve_module_confident(case.db(), &ModuleName::new("Lib").unwrap()),
+        resolve_module(case.db(), &ModuleName::new("Lib").unwrap()),
         None,
         "Expected `Lib` module not to exist"
     );
@@ -1911,13 +1891,13 @@ fn rename_files_casing_only() -> anyhow::Result<()> {
 
     // Resolving `lib` should now fail but `Lib` should now succeed
     assert_eq!(
-        resolve_module_confident(case.db(), &ModuleName::new("lib").unwrap()),
+        resolve_module(case.db(), &ModuleName::new("lib").unwrap()),
         None,
         "Expected `lib` module to no longer exist."
     );
 
     assert!(
-        resolve_module_confident(case.db(), &ModuleName::new("Lib").unwrap()).is_some(),
+        resolve_module(case.db(), &ModuleName::new("Lib").unwrap()).is_some(),
         "Expected `Lib` module to exist"
     );
 

crates/ty_completion_eval/completion-evaluation-tasks.csv

@@ -1,7 +1,4 @@
 name,file,index,rank
-auto-import-includes-modules,main.py,0,1
-auto-import-includes-modules,main.py,1,7
-auto-import-includes-modules,main.py,2,1
 auto-import-skips-current-module,main.py,0,1
 fstring-completions,main.py,0,1
 higher-level-symbols-preferred,main.py,0,
@@ -14,9 +11,9 @@ import-deprioritizes-type_check_only,main.py,2,1
 import-deprioritizes-type_check_only,main.py,3,2
 import-deprioritizes-type_check_only,main.py,4,3
 import-keyword-completion,main.py,0,1
-internal-typeshed-hidden,main.py,0,2
+internal-typeshed-hidden,main.py,0,4
 none-completion,main.py,0,2
-numpy-array,main.py,0,159
+numpy-array,main.py,0,
 numpy-array,main.py,1,1
 object-attr-instance-methods,main.py,0,1
 object-attr-instance-methods,main.py,1,1
@@ -26,6 +23,6 @@ scope-existing-over-new-import,main.py,0,1
 scope-prioritize-closer,main.py,0,2
 scope-simple-long-identifier,main.py,0,1
 tstring-completions,main.py,0,1
-ty-extensions-lower-stdlib,main.py,0,9
+ty-extensions-lower-stdlib,main.py,0,8
 type-var-typing-over-ast,main.py,0,3
-type-var-typing-over-ast,main.py,1,251
+type-var-typing-over-ast,main.py,1,275

crates/ty_completion_eval/src/main.rs

@@ -506,21 +506,9 @@ struct CompletionAnswer {
 impl CompletionAnswer {
     /// Returns true when this answer matches the completion given.
     fn matches(&self, completion: &Completion) -> bool {
-        if let Some(ref qualified) = completion.qualified {
-            if qualified.as_str() == self.qualified() {
-                return true;
-            }
-        }
         self.symbol == completion.name.as_str()
             && self.module.as_deref() == completion.module_name.map(ModuleName::as_str)
     }
-
-    fn qualified(&self) -> String {
-        self.module
-            .as_ref()
-            .map(|module| format!("{module}.{}", self.symbol))
-            .unwrap_or_else(|| self.symbol.clone())
-    }
 }
 
 /// Copy the Python project from `src_dir` to `dst_dir`.

crates/ty_completion_eval/truth/auto-import-includes-modules/completion.toml

@@ -1,2 +0,0 @@
-[settings]
-auto-import = true

crates/ty_completion_eval/truth/auto-import-includes-modules/main.py

@@ -1,3 +0,0 @@
-multiprocess<CURSOR: multiprocessing>
-collect<CURSOR: collections>
-collabc<CURSOR: collections.abc>

crates/ty_completion_eval/truth/auto-import-includes-modules/pyproject.toml

@@ -1,5 +0,0 @@
-[project]
-name = "test"
-version = "0.1.0"
-requires-python = ">=3.13"
-dependencies = []

crates/ty_completion_eval/truth/auto-import-includes-modules/uv.lock

@@ -1,8 +0,0 @@
-version = 1
-revision = 3
-requires-python = ">=3.13"
-
-[[package]]
-name = "test"
-version = "0.1.0"
-source = { virtual = "." }

crates/ty_ide/src/all_symbols.rs

@@ -2,10 +2,7 @@ use ruff_db::files::File;
 use ty_project::Db;
 use ty_python_semantic::{Module, ModuleName, all_modules, resolve_real_shadowable_module};
 
-use crate::{
-    SymbolKind,
-    symbols::{QueryPattern, SymbolInfo, symbols_for_file_global_only},
-};
+use crate::symbols::{QueryPattern, SymbolInfo, symbols_for_file_global_only};
 
 /// Get all symbols matching the query string.
 ///
@@ -23,7 +20,7 @@ pub fn all_symbols<'db>(
 
     let typing_extensions = ModuleName::new("typing_extensions").unwrap();
     let is_typing_extensions_available = importing_from.is_stub(db)
-        || resolve_real_shadowable_module(db, importing_from, &typing_extensions).is_some();
+        || resolve_real_shadowable_module(db, &typing_extensions).is_some();
 
     let results = std::sync::Mutex::new(Vec::new());
     {
@@ -39,39 +36,18 @@ pub fn all_symbols<'db>(
                 let Some(file) = module.file(&*db) else {
                     continue;
                 };
-                // By convention, modules starting with an underscore
-                // are generally considered unexported. However, we
-                // should consider first party modules fair game.
-                //
-                // Note that we apply this recursively. e.g.,
-                // `numpy._core.multiarray` is considered private
-                // because it's a child of `_core`.
-                if module.name(&*db).components().any(|c| c.starts_with('_'))
-                    && module
-                        .search_path(&*db)
-                        .is_none_or(|sp| !sp.is_first_party())
-                {
-                    continue;
-                }
                 // TODO: also make it available in `TYPE_CHECKING` blocks
                 // (we'd need https://github.com/astral-sh/ty/issues/1553 to do this well)
                 if !is_typing_extensions_available && module.name(&*db) == &typing_extensions {
                     continue;
                 }
                 s.spawn(move |_| {
-                    if query.is_match_symbol_name(module.name(&*db)) {
-                        results.lock().unwrap().push(AllSymbolInfo {
-                            symbol: None,
-                            module,
-                            file,
-                        });
-                    }
                     for (_, symbol) in symbols_for_file_global_only(&*db, file).search(query) {
                         // It seems like we could do better here than
                         // locking `results` for every single symbol,
                         // but this works pretty well as it is.
                         results.lock().unwrap().push(AllSymbolInfo {
-                            symbol: Some(symbol.to_owned()),
+                            symbol: symbol.to_owned(),
                             module,
                             file,
                         });
@@ -83,16 +59,8 @@ pub fn all_symbols<'db>(
 
     let mut results = results.into_inner().unwrap();
     results.sort_by(|s1, s2| {
-        let key1 = (
-            s1.name_in_file()
-                .unwrap_or_else(|| s1.module().name(db).as_str()),
-            s1.file.path(db).as_str(),
-        );
-        let key2 = (
-            s2.name_in_file()
-                .unwrap_or_else(|| s2.module().name(db).as_str()),
-            s2.file.path(db).as_str(),
-        );
+        let key1 = (&s1.symbol.name, s1.file.path(db).as_str());
+        let key2 = (&s2.symbol.name, s2.file.path(db).as_str());
         key1.cmp(&key2)
     });
     results
@@ -103,53 +71,14 @@ pub fn all_symbols<'db>(
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct AllSymbolInfo<'db> {
     /// The symbol information.
-    ///
-    /// When absent, this implies the symbol is the module itself.
-    symbol: Option<SymbolInfo<'static>>,
+    pub symbol: SymbolInfo<'static>,
     /// The module containing the symbol.
-    module: Module<'db>,
+    pub module: Module<'db>,
     /// The file containing the symbol.
     ///
     /// This `File` is guaranteed to be the same
     /// as the `File` underlying `module`.
-    file: File,
-}
-
-impl<'db> AllSymbolInfo<'db> {
-    /// Returns the name of this symbol as it exists in a file.
-    ///
-    /// When absent, there is no concrete symbol in a module
-    /// somewhere. Instead, this represents importing a module.
-    /// In this case, if the caller needs a symbol name, they
-    /// should use `AllSymbolInfo::module().name()`.
-    pub fn name_in_file(&self) -> Option<&str> {
-        self.symbol.as_ref().map(|symbol| &*symbol.name)
-    }
-
-    /// Returns the "kind" of this symbol.
-    ///
-    /// The kind of a symbol in the context of auto-import is
-    /// determined on a best effort basis. It may be imprecise
-    /// in some cases, e.g., reporting a module as a variable.
-    pub fn kind(&self) -> SymbolKind {
-        self.symbol
-            .as_ref()
-            .map(|symbol| symbol.kind)
-            .unwrap_or(SymbolKind::Module)
-    }
-
-    /// Returns the module this symbol is exported from.
-    pub fn module(&self) -> Module<'db> {
-        self.module
-    }
-
-    /// Returns the `File` corresponding to the module.
-    ///
-    /// This is always equivalent to
-    /// `AllSymbolInfo::module().file().unwrap()`.
-    pub fn file(&self) -> File {
-        self.file
-    }
+    pub file: File,
 }
 
 #[cfg(test)]
@@ -233,31 +162,25 @@ ABCDEFGHIJKLMNOP = 'https://api.example.com'
                 return "No symbols found".to_string();
             }
 
-            self.render_diagnostics(symbols.into_iter().map(|symbol_info| AllSymbolDiagnostic {
-                db: &self.db,
-                symbol_info,
-            }))
+            self.render_diagnostics(symbols.into_iter().map(AllSymbolDiagnostic::new))
         }
     }
 
     struct AllSymbolDiagnostic<'db> {
-        db: &'db dyn Db,
         symbol_info: AllSymbolInfo<'db>,
     }
 
+    impl<'db> AllSymbolDiagnostic<'db> {
+        fn new(symbol_info: AllSymbolInfo<'db>) -> Self {
+            Self { symbol_info }
+        }
+    }
+
     impl IntoDiagnostic for AllSymbolDiagnostic<'_> {
         fn into_diagnostic(self) -> Diagnostic {
-            let symbol_kind_str = self.symbol_info.kind().to_string();
+            let symbol_kind_str = self.symbol_info.symbol.kind.to_string();
 
-            let info_text = format!(
-                "{} {}",
-                symbol_kind_str,
-                self.symbol_info.name_in_file().unwrap_or_else(|| self
-                    .symbol_info
-                    .module()
-                    .name(self.db)
-                    .as_str())
-            );
+            let info_text = format!("{} {}", symbol_kind_str, self.symbol_info.symbol.name);
 
             let sub = SubDiagnostic::new(SubDiagnosticSeverity::Info, info_text);
 
@@ -266,12 +189,9 @@ ABCDEFGHIJKLMNOP = 'https://api.example.com'
                 Severity::Info,
                 "AllSymbolInfo".to_string(),
             );
-
-            let mut span = Span::from(self.symbol_info.file());
-            if let Some(ref symbol) = self.symbol_info.symbol {
-                span = span.with_range(symbol.name_range);
-            }
-            main.annotate(Annotation::primary(span));
+            main.annotate(Annotation::primary(
+                Span::from(self.symbol_info.file).with_range(self.symbol_info.symbol.name_range),
+            ));
             main.sub(sub);
 
             main

crates/ty_ide/src/code_action.rs

@@ -5,8 +5,7 @@ use ruff_diagnostics::Edit;
 use ruff_text_size::TextRange;
 use ty_project::Db;
 use ty_python_semantic::create_suppression_fix;
-use ty_python_semantic::lint::LintId;
-use ty_python_semantic::types::{UNDEFINED_REVEAL, UNRESOLVED_REFERENCE};
+use ty_python_semantic::types::UNRESOLVED_REFERENCE;
 
 /// A `QuickFix` Code Action
 #[derive(Debug, Clone)]
@@ -29,17 +28,12 @@ pub fn code_actions(
 
     let mut actions = Vec::new();
 
-    // Suggest imports for unresolved references (often ideal)
-    // TODO: suggest qualifying with an already imported symbol
-    let is_unresolved_reference =
-        lint_id == LintId::of(&UNRESOLVED_REFERENCE) || lint_id == LintId::of(&UNDEFINED_REVEAL);
-    if is_unresolved_reference
+    if lint_id.name() == UNRESOLVED_REFERENCE.name()
         && let Some(import_quick_fix) = create_import_symbol_quick_fix(db, file, diagnostic_range)
     {
         actions.extend(import_quick_fix);
     }
 
-    // Suggest just suppressing the lint (always a valid option, but never ideal)
     actions.push(QuickFix {
         title: format!("Ignore '{}' for this line", lint_id.name()),
         edits: create_suppression_fix(db, file, lint_id, diagnostic_range).into_edits(),

crates/ty_ide/src/completion.rs

@@ -9,7 +9,6 @@ use ruff_python_ast::token::{Token, TokenAt, TokenKind, Tokens};
 use ruff_python_ast::{self as ast, AnyNodeRef};
 use ruff_python_codegen::Stylist;
 use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
-use rustc_hash::FxHashSet;
 use ty_python_semantic::types::UnionType;
 use ty_python_semantic::{
     Completion as SemanticCompletion, KnownModule, ModuleName, NameKind, SemanticModel,
@@ -21,7 +20,7 @@ use crate::find_node::covering_node;
 use crate::goto::Definitions;
 use crate::importer::{ImportRequest, Importer};
 use crate::symbols::QueryPattern;
-use crate::{Db, all_symbols, signature_help};
+use crate::{Db, all_symbols};
 
 /// A collection of completions built up from various sources.
 #[derive(Clone)]
@@ -75,7 +74,7 @@ impl<'db> Completions<'db> {
             .into_iter()
             .filter_map(|item| {
                 Some(ImportEdit {
-                    label: format!("import {}", item.qualified?),
+                    label: format!("import {}.{}", item.module_name?, item.name),
                     edit: item.import?,
                 })
             })
@@ -161,10 +160,6 @@ impl<'db> Extend<Completion<'db>> for Completions<'db> {
 pub struct Completion<'db> {
     /// The label shown to the user for this suggestion.
     pub name: Name,
-    /// The fully qualified name, when available.
-    ///
-    /// This is only set when `module_name` is available.
-    pub qualified: Option<Name>,
     /// The text that should be inserted at the cursor
     /// when the completion is selected.
     ///
@@ -230,7 +225,6 @@ impl<'db> Completion<'db> {
         let is_type_check_only = semantic.is_type_check_only(db);
         Completion {
             name: semantic.name,
-            qualified: None,
             insert: None,
             ty: semantic.ty,
             kind: None,
@@ -312,7 +306,6 @@ impl<'db> Completion<'db> {
     fn keyword(name: &str) -> Self {
         Completion {
             name: name.into(),
-            qualified: None,
             insert: None,
             ty: None,
             kind: Some(CompletionKind::Keyword),
@@ -328,7 +321,6 @@ impl<'db> Completion<'db> {
     fn value_keyword(name: &str, ty: Type<'db>) -> Completion<'db> {
         Completion {
             name: name.into(),
-            qualified: None,
             insert: None,
             ty: Some(ty),
             kind: Some(CompletionKind::Keyword),
@@ -437,10 +429,6 @@ pub fn completion<'db>(
                 );
             }
         }
-
-        if let Some(arg_completions) = detect_function_arg_completions(db, file, &parsed, offset) {
-            completions.extend(arg_completions);
-        }
     }
 
     if is_raising_exception(tokens) {
@@ -456,89 +444,10 @@ pub fn completion<'db>(
             !ty.is_notimplemented(db)
         });
     }
+
     completions.into_completions()
 }
 
-/// Detect and construct completions for unset function arguments.
-///
-/// Suggestions are only provided if the cursor is currently inside a
-/// function call and the function arguments have not 1) already been
-/// set and 2) been defined as positional-only.
-fn detect_function_arg_completions<'db>(
-    db: &'db dyn Db,
-    file: File,
-    parsed: &ParsedModuleRef,
-    offset: TextSize,
-) -> Option<Vec<Completion<'db>>> {
-    let sig_help = signature_help(db, file, offset)?;
-    let set_function_args = detect_set_function_args(parsed, offset);
-
-    let completions = sig_help
-        .signatures
-        .iter()
-        .flat_map(|sig| &sig.parameters)
-        .filter(|p| !p.is_positional_only && !set_function_args.contains(&p.name.as_str()))
-        .map(|p| {
-            let name = Name::new(&p.name);
-            let documentation = p
-                .documentation
-                .as_ref()
-                .map(|d| Docstring::new(d.to_owned()));
-            let insert = Some(format!("{name}=").into_boxed_str());
-            Completion {
-                name,
-                qualified: None,
-                insert,
-                ty: p.ty,
-                kind: Some(CompletionKind::Variable),
-                module_name: None,
-                import: None,
-                builtin: false,
-                is_type_check_only: false,
-                is_definitively_raisable: false,
-                documentation,
-            }
-        })
-        .collect();
-    Some(completions)
-}
-
-/// Returns function arguments that have already been set.
-///
-/// If `offset` is inside an arguments node, this returns
-/// the list of argument names that are already set.
-///
-/// For example, given:
-///
-/// ```python
-/// def abc(foo, bar, baz): ...
-/// abc(foo=1, bar=2, b<CURSOR>)
-/// ```
-///
-/// the resulting value is `["foo", "bar"]`
-///
-/// This is useful to be able to exclude autocomplete suggestions
-/// for arguments that have already been set to some value.
-///
-/// If the parent node is not an arguments node, the return value
-/// is an empty Vec.
-fn detect_set_function_args(parsed: &ParsedModuleRef, offset: TextSize) -> FxHashSet<&str> {
-    let range = TextRange::empty(offset);
-    covering_node(parsed.syntax().into(), range)
-        .parent()
-        .and_then(|node| match node {
-            ast::AnyNodeRef::Arguments(args) => Some(args),
-            _ => None,
-        })
-        .map(|args| {
-            args.keywords
-                .iter()
-                .filter_map(|kw| kw.arg.as_ref().map(|ident| ident.id.as_str()))
-                .collect()
-        })
-        .unwrap_or_default()
-}
-
 pub(crate) struct ImportEdit {
     pub label: String,
     pub edit: Edit,
@@ -628,22 +537,12 @@ fn add_unimported_completions<'db>(
     let members = importer.members_in_scope_at(scoped.node, scoped.node.start());
 
     for symbol in all_symbols(db, file, &completions.query) {
-        if symbol.file() == file || symbol.module().is_known(db, KnownModule::Builtins) {
+        if symbol.module.file(db) == Some(file) || symbol.module.is_known(db, KnownModule::Builtins)
+        {
             continue;
         }
 
-        let module_name = symbol.module().name(db);
-        let (name, qualified, request) = symbol
-            .name_in_file()
-            .map(|name| {
-                let qualified = format!("{module_name}.{name}");
-                (name, qualified, create_import_request(module_name, name))
-            })
-            .unwrap_or_else(|| {
-                let name = module_name.as_str();
-                let qualified = name.to_string();
-                (name, qualified, ImportRequest::module(name))
-            });
+        let request = create_import_request(symbol.module.name(db), &symbol.symbol.name);
         // FIXME: `all_symbols` doesn't account for wildcard imports.
         // Since we're looking at every module, this is probably
         // "fine," but it might mean that we import a symbol from the
@@ -652,12 +551,11 @@ fn add_unimported_completions<'db>(
         // N.B. We use `add` here because `all_symbols` already
         // takes our query into account.
         completions.force_add(Completion {
-            name: ast::name::Name::new(name),
-            qualified: Some(ast::name::Name::new(qualified)),
+            name: ast::name::Name::new(&symbol.symbol.name),
             insert: Some(import_action.symbol_text().into()),
             ty: None,
-            kind: symbol.kind().to_completion_kind(),
-            module_name: Some(module_name),
+            kind: symbol.symbol.kind.to_completion_kind(),
+            module_name: Some(symbol.module.name(db)),
             import: import_action.import().cloned(),
             builtin: false,
             // TODO: `is_type_check_only` requires inferring the type of the symbol
@@ -2470,11 +2368,10 @@ def frob(): ...
 ",
         );
 
+        // FIXME: Should include `foo`.
         assert_snapshot!(
             builder.skip_keywords().skip_builtins().build().snapshot(),
-            @r"
-            foo
-            ",
+            @"<No completions found after filtering out completions>",
         );
     }
 
@@ -2486,11 +2383,10 @@ def frob(): ...
 ",
         );
 
+        // FIXME: Should include `foo`.
         assert_snapshot!(
             builder.skip_keywords().skip_builtins().build().snapshot(),
-            @r"
-            foo
-            ",
+            @"<No completions found after filtering out completions>",
         );
     }
 
@@ -3125,6 +3021,7 @@ quux.<CURSOR>
         ");
     }
 
+    // We don't yet take function parameters into account.
     #[test]
     fn call_prefix1() {
         let builder = completion_test_builder(
@@ -3137,157 +3034,7 @@ bar(o<CURSOR>
 ",
         );
 
-        assert_snapshot!(
-            builder.skip_keywords().skip_builtins().build().snapshot(),
-            @r"
-        foo
-        okay
-        "
-        );
-    }
-
-    #[test]
-    fn call_keyword_only_argument() {
-        let builder = completion_test_builder(
-            "\
-def bar(*, okay): ...
-
-foo = 1
-
-bar(o<CURSOR>
-",
-        );
-
-        assert_snapshot!(
-            builder.skip_keywords().skip_builtins().build().snapshot(),
-            @r"
-        foo
-        okay
-        "
-        );
-    }
-
-    #[test]
-    fn call_multiple_keyword_arguments() {
-        let builder = completion_test_builder(
-            "\
-def foo(bar, baz, barbaz): ...
-
-foo(b<CURSOR>
-",
-        );
-
-        assert_snapshot!(
-            builder.skip_keywords().skip_builtins().build().snapshot(),
-            @r"
-        bar
-        barbaz
-        baz
-        "
-        );
-    }
-
-    #[test]
-    fn call_multiple_keyword_arguments_some_set() {
-        let builder = completion_test_builder(
-            "\
-def foo(bar, baz): ...
-
-foo(bar=1, b<CURSOR>
-",
-        );
-
-        assert_snapshot!(
-            builder.skip_keywords().skip_builtins().build().snapshot(),
-            @r"
-        baz
-        "
-        );
-    }
-
-    #[test]
-    fn call_arguments_multi_def() {
-        let builder = completion_test_builder(
-            "\
-def abc(okay, x): ...
-def bar(not_okay, y): ...
-def baz(foobarbaz, z): ...
-
-abc(o<CURSOR>
-",
-        );
-
-        assert_snapshot!(
-            builder.skip_keywords().skip_builtins().build().snapshot(),
-            @r"
-        okay
-        "
-        );
-    }
-
-    #[test]
-    fn call_arguments_cursor_middle() {
-        let builder = completion_test_builder(
-            "\
-def abc(okay, foo, bar, baz): ...
-
-abc(okay=1, ba<CURSOR> baz=5
-",
-        );
-
-        assert_snapshot!(
-            builder.skip_keywords().skip_builtins().build().snapshot(),
-            @r"
-        bar
-        "
-        );
-    }
-
-    #[test]
-    fn call_positional_only_argument() {
-        // If the parameter is positional only we don't
-        // want to suggest it as specifying by name
-        // is not valid.
-        let builder = completion_test_builder(
-            "\
-def bar(okay, /): ...
-
-foo = 1
-
-bar(o<CURSOR>
-",
-        );
-
-        assert_snapshot!(
-            builder.skip_keywords().skip_builtins().build().snapshot(),
-            @"foo"
-        );
-    }
-
-    #[test]
-    fn call_positional_only_keyword_only_argument_mix() {
-        // If the parameter is positional only we don't
-        // want to suggest it as specifying by name
-        // is not valid.
-        let builder = completion_test_builder(
-            "\
-def bar(not_okay, no, /, okay, *, okay_abc, okay_okay): ...
-
-foo = 1
-
-bar(o<CURSOR>
-",
-        );
-
-        assert_snapshot!(
-            builder.skip_keywords().skip_builtins().build().snapshot(),
-            @r"
-        foo
-        okay
-        okay_abc
-        okay_okay
-        "
-        );
+        assert_snapshot!(builder.skip_keywords().skip_builtins().build().snapshot(), @"foo");
     }
 
     #[test]
@@ -3305,7 +3052,6 @@ bar(<CURSOR>
         assert_snapshot!(builder.skip_keywords().skip_builtins().build().snapshot(), @r"
         bar
         foo
-        okay
         ");
     }
 
@@ -4604,7 +4350,7 @@ from os.<CURSOR>
             .build()
             .snapshot();
         assert_snapshot!(snapshot, @r"
-        Kadabra :: Literal[1] :: <no import required>
+        Kadabra :: Literal[1] :: Current module
         AbraKadabra :: Unavailable :: package
         ");
     }
@@ -5788,7 +5534,7 @@ def foo(param: s<CURSOR>)
         // Even though long_namea is alphabetically before long_nameb,
         // long_nameb is currently imported and should be preferred.
         assert_snapshot!(snapshot, @r"
-        long_nameb :: Literal[1] :: <no import required>
+        long_nameb :: Literal[1] :: Current module
         long_namea :: Unavailable :: foo
         ");
     }
@@ -6058,7 +5804,7 @@ from .imp<CURSOR>
     #[test]
     fn typing_extensions_excluded_from_import() {
         let builder = completion_test_builder("from typing<CURSOR>").module_names();
-        assert_snapshot!(builder.build().snapshot(), @"typing :: <no import required>");
+        assert_snapshot!(builder.build().snapshot(), @"typing :: Current module");
     }
 
     #[test]
@@ -6066,7 +5812,13 @@ from .imp<CURSOR>
         let builder = completion_test_builder("deprecated<CURSOR>")
             .auto_import()
             .module_names();
-        assert_snapshot!(builder.build().snapshot(), @"deprecated :: warnings");
+        assert_snapshot!(builder.build().snapshot(), @r"
+        Deprecated :: importlib.metadata
+        DeprecatedList :: importlib.metadata
+        DeprecatedNonAbstract :: importlib.metadata
+        DeprecatedTuple :: importlib.metadata
+        deprecated :: warnings
+        ");
     }
 
     #[test]
@@ -6077,8 +5829,8 @@ from .imp<CURSOR>
             .completion_test_builder()
             .module_names();
         assert_snapshot!(builder.build().snapshot(), @r"
-        typing :: <no import required>
-        typing_extensions :: <no import required>
+        typing :: Current module
+        typing_extensions :: Current module
         ");
     }
 
@@ -6091,6 +5843,10 @@ from .imp<CURSOR>
             .auto_import()
             .module_names();
         assert_snapshot!(builder.build().snapshot(), @r"
+        Deprecated :: importlib.metadata
+        DeprecatedList :: importlib.metadata
+        DeprecatedNonAbstract :: importlib.metadata
+        DeprecatedTuple :: importlib.metadata
         deprecated :: typing_extensions
         deprecated :: warnings
         ");
@@ -6103,8 +5859,8 @@ from .imp<CURSOR>
             .completion_test_builder()
             .module_names();
         assert_snapshot!(builder.build().snapshot(), @r"
-        typing :: <no import required>
-        typing_extensions :: <no import required>
+        typing :: Current module
+        typing_extensions :: Current module
         ");
     }
 
@@ -6116,284 +5872,15 @@ from .imp<CURSOR>
             .auto_import()
             .module_names();
         assert_snapshot!(builder.build().snapshot(), @r"
+        Deprecated :: importlib.metadata
+        DeprecatedList :: importlib.metadata
+        DeprecatedNonAbstract :: importlib.metadata
+        DeprecatedTuple :: importlib.metadata
         deprecated :: typing_extensions
         deprecated :: warnings
         ");
     }
 
-    #[test]
-    fn reexport_simple_import_noauto() {
-        let snapshot = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-import foo
-foo.ZQ<CURSOR>
-"#,
-            )
-            .source("foo.py", r#"from bar import ZQZQ"#)
-            .source("bar.py", r#"ZQZQ = 1"#)
-            .completion_test_builder()
-            .module_names()
-            .build()
-            .snapshot();
-        assert_snapshot!(snapshot, @"ZQZQ :: <no import required>");
-    }
-
-    #[test]
-    fn reexport_simple_import_auto() {
-        let snapshot = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-ZQ<CURSOR>
-"#,
-            )
-            .source("foo.py", r#"from bar import ZQZQ"#)
-            .source("bar.py", r#"ZQZQ = 1"#)
-            .completion_test_builder()
-            .auto_import()
-            .module_names()
-            .build()
-            .snapshot();
-        // We're specifically looking for `ZQZQ` in `bar`
-        // here but *not* in `foo`. Namely, in `foo`,
-        // `ZQZQ` is a "regular" import that is not by
-        // convention considered a re-export.
-        assert_snapshot!(snapshot, @"ZQZQ :: bar");
-    }
-
-    #[test]
-    fn reexport_redundant_convention_import_noauto() {
-        let snapshot = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-import foo
-foo.ZQ<CURSOR>
-"#,
-            )
-            .source("foo.py", r#"from bar import ZQZQ as ZQZQ"#)
-            .source("bar.py", r#"ZQZQ = 1"#)
-            .completion_test_builder()
-            .module_names()
-            .build()
-            .snapshot();
-        assert_snapshot!(snapshot, @"ZQZQ :: <no import required>");
-    }
-
-    #[test]
-    fn reexport_redundant_convention_import_auto() {
-        let snapshot = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-ZQ<CURSOR>
-"#,
-            )
-            .source("foo.py", r#"from bar import ZQZQ as ZQZQ"#)
-            .source("bar.py", r#"ZQZQ = 1"#)
-            .completion_test_builder()
-            .auto_import()
-            .module_names()
-            .build()
-            .snapshot();
-        assert_snapshot!(snapshot, @r"
-        ZQZQ :: bar
-        ZQZQ :: foo
-        ");
-    }
-
-    #[test]
-    fn auto_import_respects_all() {
-        let snapshot = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-ZQ<CURSOR>
-"#,
-            )
-            .source(
-                "bar.py",
-                r#"
-                ZQZQ1 = 1
-                ZQZQ2 = 1
-                __all__ = ['ZQZQ1']
-            "#,
-            )
-            .completion_test_builder()
-            .auto_import()
-            .module_names()
-            .build()
-            .snapshot();
-        // We specifically do not want `ZQZQ2` here, since
-        // it is not part of `__all__`.
-        assert_snapshot!(snapshot, @r"
-        ZQZQ1 :: bar
-        ");
-    }
-
-    // This test confirms current behavior (as of 2025-12-04), but
-    // it's not consistent with auto-import. That is, it doesn't
-    // strictly respect `__all__` on `bar`, but perhaps it should.
-    //
-    // See: https://github.com/astral-sh/ty/issues/1757
-    #[test]
-    fn object_attr_ignores_all() {
-        let snapshot = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-import bar
-bar.ZQ<CURSOR>
-"#,
-            )
-            .source(
-                "bar.py",
-                r#"
-                ZQZQ1 = 1
-                ZQZQ2 = 1
-                __all__ = ['ZQZQ1']
-            "#,
-            )
-            .completion_test_builder()
-            .auto_import()
-            .module_names()
-            .build()
-            .snapshot();
-        // We specifically do not want `ZQZQ2` here, since
-        // it is not part of `__all__`.
-        assert_snapshot!(snapshot, @r"
-        ZQZQ1 :: <no import required>
-        ZQZQ2 :: <no import required>
-        ");
-    }
-
-    #[test]
-    fn auto_import_ignores_modules_with_leading_underscore() {
-        let snapshot = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-Quitter<CURSOR>
-"#,
-            )
-            .completion_test_builder()
-            .auto_import()
-            .module_names()
-            .build()
-            .snapshot();
-        // There is a `Quitter` in `_sitebuiltins` in the standard
-        // library. But this is skipped by auto-import because it's
-        // 1) not first party and 2) starts with an `_`.
-        assert_snapshot!(snapshot, @"<No completions found>");
-    }
-
-    #[test]
-    fn auto_import_includes_modules_with_leading_underscore_in_first_party() {
-        let snapshot = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-ZQ<CURSOR>
-"#,
-            )
-            .source(
-                "bar.py",
-                r#"
-                ZQZQ1 = 1
-            "#,
-            )
-            .source(
-                "_foo.py",
-                r#"
-                ZQZQ1 = 1
-            "#,
-            )
-            .completion_test_builder()
-            .auto_import()
-            .module_names()
-            .build()
-            .snapshot();
-        assert_snapshot!(snapshot, @r"
-        ZQZQ1 :: _foo
-        ZQZQ1 :: bar
-        ");
-    }
-
-    #[test]
-    fn auto_import_includes_stdlib_modules_as_suggestions() {
-        let snapshot = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-multiprocess<CURSOR>
-"#,
-            )
-            .completion_test_builder()
-            .auto_import()
-            .build()
-            .snapshot();
-        assert_snapshot!(snapshot, @r"
-        multiprocessing
-        multiprocessing.connection
-        multiprocessing.context
-        multiprocessing.dummy
-        multiprocessing.dummy.connection
-        multiprocessing.forkserver
-        multiprocessing.heap
-        multiprocessing.managers
-        multiprocessing.pool
-        multiprocessing.popen_fork
-        multiprocessing.popen_forkserver
-        multiprocessing.popen_spawn_posix
-        multiprocessing.popen_spawn_win32
-        multiprocessing.process
-        multiprocessing.queues
-        multiprocessing.reduction
-        multiprocessing.resource_sharer
-        multiprocessing.resource_tracker
-        multiprocessing.shared_memory
-        multiprocessing.sharedctypes
-        multiprocessing.spawn
-        multiprocessing.synchronize
-        multiprocessing.util
-        ");
-    }
-
-    #[test]
-    fn auto_import_includes_first_party_modules_as_suggestions() {
-        let snapshot = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-zqzqzq<CURSOR>
-"#,
-            )
-            .source("zqzqzqzqzq.py", "")
-            .completion_test_builder()
-            .auto_import()
-            .build()
-            .snapshot();
-        assert_snapshot!(snapshot, @"zqzqzqzqzq");
-    }
-
-    #[test]
-    fn auto_import_includes_sub_modules_as_suggestions() {
-        let snapshot = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-collabc<CURSOR>
-"#,
-            )
-            .completion_test_builder()
-            .auto_import()
-            .build()
-            .snapshot();
-        assert_snapshot!(snapshot, @"collections.abc");
-    }
-
     /// A way to create a simple single-file (named `main.py`) completion test
     /// builder.
     ///
@@ -6568,7 +6055,7 @@ collabc<CURSOR>
                         let module_name = c
                             .module_name
                             .map(ModuleName::as_str)
-                            .unwrap_or("<no import required>");
+                            .unwrap_or("Current module");
                         snapshot = format!("{snapshot} :: {module_name}");
                     }
                     snapshot

crates/ty_ide/src/doc_highlights.rs

@@ -230,58 +230,10 @@ calc = Calculator()
             "
 def test():
     # Cursor on a position with no symbol
-    <CURSOR>
+    <CURSOR>  
 ",
         );
 
         assert_snapshot!(test.document_highlights(), @"No highlights found");
     }
-
-    // TODO: Should only highlight the last use and the last declaration
-    #[test]
-    fn redeclarations() {
-        let test = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-                a: str = "test"
-
-                a: int = 10
-
-                print(a<CURSOR>)
-                "#,
-            )
-            .build();
-
-        assert_snapshot!(test.document_highlights(), @r#"
-        info[document_highlights]: Highlight 1 (Write)
-         --> main.py:2:1
-          |
-        2 | a: str = "test"
-          | ^
-        3 |
-        4 | a: int = 10
-          |
-
-        info[document_highlights]: Highlight 2 (Write)
-         --> main.py:4:1
-          |
-        2 | a: str = "test"
-        3 |
-        4 | a: int = 10
-          | ^
-        5 |
-        6 | print(a)
-          |
-
-        info[document_highlights]: Highlight 3 (Read)
-         --> main.py:6:7
-          |
-        4 | a: int = 10
-        5 |
-        6 | print(a)
-          |       ^
-          |
-        "#);
-    }
 }

crates/ty_ide/src/docstring.rs

@@ -824,12 +824,12 @@ mod tests {
         Check out this great example code::
 
             x_y = "hello"
-
+            
             if len(x_y) > 4:
                 print(x_y)
             else:
                 print("too short :(")
-
+            
             print("done")
 
         You love to see it.
@@ -862,12 +862,12 @@ mod tests {
         Check out this great example code ::
 
             x_y = "hello"
-
+            
             if len(x_y) > 4:
                 print(x_y)
             else:
                 print("too short :(")
-
+            
             print("done")
 
         You love to see it.
@@ -901,12 +901,12 @@ mod tests {
             ::
 
             x_y = "hello"
-
+            
             if len(x_y) > 4:
                 print(x_y)
             else:
                 print("too short :(")
-
+            
             print("done")
 
         You love to see it.
@@ -939,12 +939,12 @@ mod tests {
         let docstring = r#"
         Check out this great example code::
             x_y = "hello"
-
+            
             if len(x_y) > 4:
                 print(x_y)
             else:
                 print("too short :(")
-
+            
             print("done")
         You love to see it.
         "#;
@@ -975,12 +975,12 @@ mod tests {
         Check out this great example code::
 
             x_y = "hello"
-
+            
             if len(x_y) > 4:
                 print(x_y)
             else:
                 print("too short :(")
-
+            
             print("done")"#;
 
         let docstring = Docstring::new(docstring.to_owned());

crates/ty_ide/src/find_references.rs

@@ -898,42 +898,6 @@ cls = MyClass
         assert_snapshot!(test.references(), @"No references found");
     }
 
-    #[test]
-    fn references_string_annotation_recursive() {
-        let test = cursor_test(
-            r#"
-        ab: "a<CURSOR>b"
-        "#,
-        );
-
-        assert_snapshot!(test.references(), @r#"
-        info[references]: Reference 1
-         --> main.py:2:1
-          |
-        2 | ab: "ab"
-          | ^^
-          |
-
-        info[references]: Reference 2
-         --> main.py:2:6
-          |
-        2 | ab: "ab"
-          |      ^^
-          |
-        "#);
-    }
-
-    #[test]
-    fn references_string_annotation_unknown() {
-        let test = cursor_test(
-            r#"
-        x: "foo<CURSOR>bar"
-        "#,
-        );
-
-        assert_snapshot!(test.references(), @"No references found");
-    }
-
     #[test]
     fn references_match_name_stmt() {
         let test = cursor_test(
@@ -1906,259 +1870,4 @@ func<CURSOR>_alias()
           |
         ");
     }
-
-    #[test]
-    fn references_submodule_import_from_use() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg.submod import val
-
-                x = sub<CURSOR>pkg
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // TODO(submodule-imports): this should light up both instances of `subpkg`
-        assert_snapshot!(test.references(), @r"
-        info[references]: Reference 1
-         --> mypackage/__init__.py:4:5
-          |
-        2 | from .subpkg.submod import val
-        3 |
-        4 | x = subpkg
-          |     ^^^^^^
-          |
-        ");
-    }
-
-    #[test]
-    fn references_submodule_import_from_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .sub<CURSOR>pkg.submod import val
-
-                x = subpkg
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // TODO(submodule-imports): this should light up both instances of `subpkg`
-        assert_snapshot!(test.references(), @"No references found");
-    }
-
-    #[test]
-    fn references_submodule_import_from_wrong_use() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg.submod import val
-
-                x = sub<CURSOR>mod
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // No references is actually correct (or it should only see itself)
-        assert_snapshot!(test.references(), @"No references found");
-    }
-
-    #[test]
-    fn references_submodule_import_from_wrong_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg.sub<CURSOR>mod import val
-
-                x = submod
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // No references is actually correct (or it should only see itself)
-        assert_snapshot!(test.references(), @"No references found");
-    }
-
-    #[test]
-    fn references_submodule_import_from_confusing_shadowed_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .sub<CURSOR>pkg import subpkg
-
-                x = subpkg
-                "#,
-            )
-            .source(
-                "mypackage/subpkg/__init__.py",
-                r#"
-                subpkg: int = 10
-                "#,
-            )
-            .build();
-
-        // No references is actually correct (or it should only see itself)
-        assert_snapshot!(test.references(), @"No references found");
-    }
-
-    #[test]
-    fn references_submodule_import_from_confusing_real_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg import sub<CURSOR>pkg
-
-                x = subpkg
-                "#,
-            )
-            .source(
-                "mypackage/subpkg/__init__.py",
-                r#"
-                subpkg: int = 10
-                "#,
-            )
-            .build();
-
-        assert_snapshot!(test.references(), @r"
-        info[references]: Reference 1
-         --> mypackage/__init__.py:2:21
-          |
-        2 | from .subpkg import subpkg
-          |                     ^^^^^^
-        3 |
-        4 | x = subpkg
-          |
-
-        info[references]: Reference 2
-         --> mypackage/__init__.py:4:5
-          |
-        2 | from .subpkg import subpkg
-        3 |
-        4 | x = subpkg
-          |     ^^^^^^
-          |
-
-        info[references]: Reference 3
-         --> mypackage/subpkg/__init__.py:2:1
-          |
-        2 | subpkg: int = 10
-          | ^^^^^^
-          |
-        ");
-    }
-
-    #[test]
-    fn references_submodule_import_from_confusing_use() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg import subpkg
-
-                x = sub<CURSOR>pkg
-                "#,
-            )
-            .source(
-                "mypackage/subpkg/__init__.py",
-                r#"
-                subpkg: int = 10
-                "#,
-            )
-            .build();
-
-        // TODO: this should also highlight the RHS subpkg in the import
-        assert_snapshot!(test.references(), @r"
-        info[references]: Reference 1
-         --> mypackage/__init__.py:4:5
-          |
-        2 | from .subpkg import subpkg
-        3 |
-        4 | x = subpkg
-          |     ^^^^^^
-          |
-        ");
-    }
-
-    // TODO: Should only return references to the last declaration
-    #[test]
-    fn declarations() {
-        let test = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-                a: str = "test"
-
-                a: int = 10
-
-                print(a<CURSOR>)
-                "#,
-            )
-            .build();
-
-        assert_snapshot!(test.references(), @r#"
-        info[references]: Reference 1
-         --> main.py:2:1
-          |
-        2 | a: str = "test"
-          | ^
-        3 |
-        4 | a: int = 10
-          |
-
-        info[references]: Reference 2
-         --> main.py:4:1
-          |
-        2 | a: str = "test"
-        3 |
-        4 | a: int = 10
-          | ^
-        5 |
-        6 | print(a)
-          |
-
-        info[references]: Reference 3
-         --> main.py:6:7
-          |
-        4 | a: int = 10
-        5 |
-        6 | print(a)
-          |       ^
-          |
-        "#);
-    }
 }

crates/ty_ide/src/goto.rs

@@ -73,29 +73,19 @@ pub(crate) enum GotoTarget<'a> {
     /// ```
     ImportModuleAlias {
         alias: &'a ast::Alias,
-        asname: &'a ast::Identifier,
-    },
-
-    /// In an import statement, the named under which the symbol is exported
-    /// in the imported file.
-    ///
-    /// ```py
-    /// from foo import bar as baz
-    ///                 ^^^
-    /// ```
-    ImportExportedName {
-        alias: &'a ast::Alias,
-        import_from: &'a ast::StmtImportFrom,
     },
 
     /// Import alias in from import statement
     /// ```py
     /// from foo import bar as baz
+    ///                 ^^^
+    /// from foo import bar as baz
     ///                        ^^^
     /// ```
     ImportSymbolAlias {
         alias: &'a ast::Alias,
-        asname: &'a ast::Identifier,
+        range: TextRange,
+        import_from: &'a ast::StmtImportFrom,
     },
 
     /// Go to on the exception handler variable
@@ -300,9 +290,8 @@ impl GotoTarget<'_> {
             GotoTarget::FunctionDef(function) => function.inferred_type(model),
             GotoTarget::ClassDef(class) => class.inferred_type(model),
             GotoTarget::Parameter(parameter) => parameter.inferred_type(model),
-            GotoTarget::ImportSymbolAlias { alias, .. }
-            | GotoTarget::ImportModuleAlias { alias, .. }
-            | GotoTarget::ImportExportedName { alias, .. } => alias.inferred_type(model),
+            GotoTarget::ImportSymbolAlias { alias, .. } => alias.inferred_type(model),
+            GotoTarget::ImportModuleAlias { alias } => alias.inferred_type(model),
             GotoTarget::ExceptVariable(except) => except.inferred_type(model),
             GotoTarget::KeywordArgument { keyword, .. } => keyword.value.inferred_type(model),
             // When asking the type of a callable, usually you want the callable itself?
@@ -389,9 +378,7 @@ impl GotoTarget<'_> {
         alias_resolution: ImportAliasResolution,
     ) -> Option<Definitions<'db>> {
         let definitions = match self {
-            GotoTarget::Expression(expression) => {
-                definitions_for_expression(model, *expression, alias_resolution)
-            }
+            GotoTarget::Expression(expression) => definitions_for_expression(model, *expression),
             // For already-defined symbols, they are their own definitions
             GotoTarget::FunctionDef(function) => Some(vec![ResolvedDefinition::Definition(
                 function.definition(model),
@@ -406,21 +393,22 @@ impl GotoTarget<'_> {
             )]),
 
             // For import aliases (offset within 'y' or 'z' in "from x import y as z")
-            GotoTarget::ImportSymbolAlias { asname, .. } => Some(definitions_for_name(
-                model,
-                asname.as_str(),
-                AnyNodeRef::from(*asname),
-                alias_resolution,
-            )),
-
-            GotoTarget::ImportExportedName { alias, import_from } => {
-                let symbol_name = alias.name.as_str();
-                Some(definitions_for_imported_symbol(
-                    model,
-                    import_from,
-                    symbol_name,
-                    alias_resolution,
-                ))
+            GotoTarget::ImportSymbolAlias {
+                alias, import_from, ..
+            } => {
+                if let Some(asname) = alias.asname.as_ref()
+                    && alias_resolution == ImportAliasResolution::PreserveAliases
+                {
+                    Some(definitions_for_name(model, asname.as_str(), asname.into()))
+                } else {
+                    let symbol_name = alias.name.as_str();
+                    Some(definitions_for_imported_symbol(
+                        model,
+                        import_from,
+                        symbol_name,
+                        alias_resolution,
+                    ))
+                }
             }
 
             GotoTarget::ImportModuleComponent {
@@ -435,12 +423,15 @@ impl GotoTarget<'_> {
             }
 
             // Handle import aliases (offset within 'z' in "import x.y as z")
-            GotoTarget::ImportModuleAlias { asname, .. } => Some(definitions_for_name(
-                model,
-                asname.as_str(),
-                AnyNodeRef::from(*asname),
-                alias_resolution,
-            )),
+            GotoTarget::ImportModuleAlias { alias } => {
+                if let Some(asname) = alias.asname.as_ref()
+                    && alias_resolution == ImportAliasResolution::PreserveAliases
+                {
+                    Some(definitions_for_name(model, asname.as_str(), asname.into()))
+                } else {
+                    definitions_for_module(model, Some(alias.name.as_str()), 0)
+                }
+            }
 
             // Handle keyword arguments in call expressions
             GotoTarget::KeywordArgument {
@@ -463,22 +454,12 @@ impl GotoTarget<'_> {
             // because they're not expressions
             GotoTarget::PatternMatchRest(pattern_mapping) => {
                 pattern_mapping.rest.as_ref().map(|name| {
-                    definitions_for_name(
-                        model,
-                        name.as_str(),
-                        AnyNodeRef::Identifier(name),
-                        alias_resolution,
-                    )
+                    definitions_for_name(model, name.as_str(), AnyNodeRef::Identifier(name))
                 })
             }
 
             GotoTarget::PatternMatchAsName(pattern_as) => pattern_as.name.as_ref().map(|name| {
-                definitions_for_name(
-                    model,
-                    name.as_str(),
-                    AnyNodeRef::Identifier(name),
-                    alias_resolution,
-                )
+                definitions_for_name(model, name.as_str(), AnyNodeRef::Identifier(name))
             }),
 
             GotoTarget::PatternKeywordArgument(pattern_keyword) => {
@@ -487,18 +468,12 @@ impl GotoTarget<'_> {
                     model,
                     name.as_str(),
                     AnyNodeRef::Identifier(name),
-                    alias_resolution,
                 ))
             }
 
             GotoTarget::PatternMatchStarName(pattern_star) => {
                 pattern_star.name.as_ref().map(|name| {
-                    definitions_for_name(
-                        model,
-                        name.as_str(),
-                        AnyNodeRef::Identifier(name),
-                        alias_resolution,
-                    )
+                    definitions_for_name(model, name.as_str(), AnyNodeRef::Identifier(name))
                 })
             }
 
@@ -506,18 +481,9 @@ impl GotoTarget<'_> {
             //
             // Prefer the function impl over the callable so that its docstrings win if defined.
             GotoTarget::Call { callable, call } => {
-                let mut definitions = Vec::new();
-
-                // We prefer the specific overload for hover, go-to-def etc. However,
-                // `definitions_for_callable` always resolves import aliases. That's why we
-                // skip it in cases import alias resolution is turned of (rename, highlight references).
-                if alias_resolution == ImportAliasResolution::ResolveAliases {
-                    definitions.extend(definitions_for_callable(model, call));
-                }
-
+                let mut definitions = definitions_for_callable(model, call);
                 let expr_definitions =
-                    definitions_for_expression(model, *callable, alias_resolution)
-                        .unwrap_or_default();
+                    definitions_for_expression(model, *callable).unwrap_or_default();
                 definitions.extend(expr_definitions);
 
                 if definitions.is_empty() {
@@ -551,7 +517,7 @@ impl GotoTarget<'_> {
                 let subexpr = covering_node(subast.syntax().into(), *subrange)
                     .node()
                     .as_expr_ref()?;
-                definitions_for_expression(&submodel, subexpr, alias_resolution)
+                definitions_for_expression(&submodel, subexpr)
             }
 
             // nonlocal and global are essentially loads, but again they're statements,
@@ -561,7 +527,6 @@ impl GotoTarget<'_> {
                     model,
                     identifier.as_str(),
                     AnyNodeRef::Identifier(identifier),
-                    alias_resolution,
                 ))
             }
 
@@ -572,7 +537,6 @@ impl GotoTarget<'_> {
                     model,
                     name.as_str(),
                     AnyNodeRef::Identifier(name),
-                    alias_resolution,
                 ))
             }
 
@@ -582,7 +546,6 @@ impl GotoTarget<'_> {
                     model,
                     name.as_str(),
                     AnyNodeRef::Identifier(name),
-                    alias_resolution,
                 ))
             }
 
@@ -592,7 +555,6 @@ impl GotoTarget<'_> {
                     model,
                     name.as_str(),
                     AnyNodeRef::Identifier(name),
-                    alias_resolution,
                 ))
             }
         };
@@ -618,9 +580,12 @@ impl GotoTarget<'_> {
             GotoTarget::FunctionDef(function) => Some(Cow::Borrowed(function.name.as_str())),
             GotoTarget::ClassDef(class) => Some(Cow::Borrowed(class.name.as_str())),
             GotoTarget::Parameter(parameter) => Some(Cow::Borrowed(parameter.name.as_str())),
-            GotoTarget::ImportSymbolAlias { asname, .. } => Some(Cow::Borrowed(asname.as_str())),
-            GotoTarget::ImportExportedName { alias, .. } => {
-                Some(Cow::Borrowed(alias.name.as_str()))
+            GotoTarget::ImportSymbolAlias { alias, .. } => {
+                if let Some(asname) = &alias.asname {
+                    Some(Cow::Borrowed(asname.as_str()))
+                } else {
+                    Some(Cow::Borrowed(alias.name.as_str()))
+                }
             }
             GotoTarget::ImportModuleComponent {
                 module_name,
@@ -634,7 +599,13 @@ impl GotoTarget<'_> {
                     Some(Cow::Borrowed(module_name))
                 }
             }
-            GotoTarget::ImportModuleAlias { asname, .. } => Some(Cow::Borrowed(asname.as_str())),
+            GotoTarget::ImportModuleAlias { alias } => {
+                if let Some(asname) = &alias.asname {
+                    Some(Cow::Borrowed(asname.as_str()))
+                } else {
+                    Some(Cow::Borrowed(alias.name.as_str()))
+                }
+            }
             GotoTarget::ExceptVariable(except) => {
                 Some(Cow::Borrowed(except.name.as_ref()?.as_str()))
             }
@@ -696,7 +667,7 @@ impl GotoTarget<'_> {
                             // Is the offset within the alias name (asname) part?
                             if let Some(asname) = &alias.asname {
                                 if asname.range.contains_inclusive(offset) {
-                                    return Some(GotoTarget::ImportModuleAlias { alias, asname });
+                                    return Some(GotoTarget::ImportModuleAlias { alias });
                                 }
                             }
 
@@ -728,13 +699,21 @@ impl GotoTarget<'_> {
                             // Is the offset within the alias name (asname) part?
                             if let Some(asname) = &alias.asname {
                                 if asname.range.contains_inclusive(offset) {
-                                    return Some(GotoTarget::ImportSymbolAlias { alias, asname });
+                                    return Some(GotoTarget::ImportSymbolAlias {
+                                        alias,
+                                        range: asname.range,
+                                        import_from,
+                                    });
                                 }
                             }
 
                             // Is the offset in the original name part?
                             if alias.name.range.contains_inclusive(offset) {
-                                return Some(GotoTarget::ImportExportedName { alias, import_from });
+                                return Some(GotoTarget::ImportSymbolAlias {
+                                    alias,
+                                    range: alias.name.range,
+                                    import_from,
+                                });
                             }
 
                             None
@@ -914,13 +893,12 @@ impl Ranged for GotoTarget<'_> {
             GotoTarget::FunctionDef(function) => function.name.range,
             GotoTarget::ClassDef(class) => class.name.range,
             GotoTarget::Parameter(parameter) => parameter.name.range,
-            GotoTarget::ImportSymbolAlias { asname, .. } => asname.range,
-            Self::ImportExportedName { alias, .. } => alias.name.range,
+            GotoTarget::ImportSymbolAlias { range, .. } => *range,
             GotoTarget::ImportModuleComponent {
                 component_range, ..
             } => *component_range,
             GotoTarget::StringAnnotationSubexpr { subrange, .. } => *subrange,
-            GotoTarget::ImportModuleAlias { asname, .. } => asname.range,
+            GotoTarget::ImportModuleAlias { alias } => alias.asname.as_ref().unwrap().range,
             GotoTarget::ExceptVariable(except) => except.name.as_ref().unwrap().range,
             GotoTarget::KeywordArgument { keyword, .. } => keyword.arg.as_ref().unwrap().range,
             GotoTarget::PatternMatchRest(rest) => rest.rest.as_ref().unwrap().range,
@@ -977,14 +955,12 @@ fn convert_resolved_definitions_to_targets<'db>(
 fn definitions_for_expression<'db>(
     model: &SemanticModel<'db>,
     expression: ruff_python_ast::ExprRef<'_>,
-    alias_resolution: ImportAliasResolution,
 ) -> Option<Vec<ResolvedDefinition<'db>>> {
     match expression {
         ast::ExprRef::Name(name) => Some(definitions_for_name(
             model,
             name.id.as_str(),
             expression.into(),
-            alias_resolution,
         )),
         ast::ExprRef::Attribute(attribute) => Some(ty_python_semantic::definitions_for_attribute(
             model, attribute,

crates/ty_ide/src/goto_declaration.rs

@@ -273,7 +273,7 @@ mod tests {
             r#"
 class A:
     x = 1
-
+    
     def method(self):
         def inner():
             return <CURSOR>x  # Should NOT find class variable x
@@ -1073,41 +1073,6 @@ def another_helper(path):
         assert_snapshot!(test.goto_declaration(), @"No goto target found");
     }
 
-    #[test]
-    fn goto_declaration_string_annotation_recursive() {
-        let test = cursor_test(
-            r#"
-        ab: "a<CURSOR>b"
-        "#,
-        );
-
-        assert_snapshot!(test.goto_declaration(), @r#"
-        info[goto-declaration]: Declaration
-         --> main.py:2:1
-          |
-        2 | ab: "ab"
-          | ^^
-          |
-        info: Source
-         --> main.py:2:6
-          |
-        2 | ab: "ab"
-          |      ^^
-          |
-        "#);
-    }
-
-    #[test]
-    fn goto_declaration_string_annotation_unknown() {
-        let test = cursor_test(
-            r#"
-        x: "foo<CURSOR>bar"
-        "#,
-        );
-
-        assert_snapshot!(test.goto_declaration(), @"No goto target found");
-    }
-
     #[test]
     fn goto_declaration_nested_instance_attribute() {
         let test = cursor_test(
@@ -1255,12 +1220,12 @@ x: i<CURSOR>nt = 42
             r#"
 def outer():
     x = "outer_value"
-
+    
     def inner():
         nonlocal x
         x = "modified"
         return x<CURSOR>  # Should find the nonlocal x declaration in outer scope
-
+    
     return inner
 "#,
         );
@@ -1295,12 +1260,12 @@ def outer():
             r#"
 def outer():
     xy = "outer_value"
-
+    
     def inner():
         nonlocal x<CURSOR>y
         xy = "modified"
         return x  # Should find the nonlocal x declaration in outer scope
-
+    
     return inner
 "#,
         );
@@ -1636,7 +1601,7 @@ def function():
                 def __init__(self, pos, btn):
                     self.position: int = pos
                     self.button: str = btn
-
+            
             def my_func(event: Click):
                 match event:
                     case Click(x, button=a<CURSOR>b):
@@ -1675,7 +1640,7 @@ def function():
                 def __init__(self, pos, btn):
                     self.position: int = pos
                     self.button: str = btn
-
+            
             def my_func(event: Click):
                 match event:
                     case Click(x, button=ab):
@@ -1713,7 +1678,7 @@ def function():
                 def __init__(self, pos, btn):
                     self.position: int = pos
                     self.button: str = btn
-
+            
             def my_func(event: Click):
                 match event:
                     case Cl<CURSOR>ick(x, button=ab):
@@ -1751,7 +1716,7 @@ def function():
                 def __init__(self, pos, btn):
                     self.position: int = pos
                     self.button: str = btn
-
+            
             def my_func(event: Click):
                 match event:
                     case Click(x, but<CURSOR>ton=ab):
@@ -1919,7 +1884,7 @@ def function():
             class C:
                 def __init__(self):
                     self._value = 0
-
+                
                 @property
                 def value(self):
                     return self._value
@@ -2029,7 +1994,7 @@ def function():
             r#"
 class MyClass:
     ClassType = int
-
+    
     def generic_method[T](self, value: Class<CURSOR>Type) -> T:
         return value
 "#,
@@ -2602,378 +2567,6 @@ def ab(a: int, *, c: int): ...
         ");
     }
 
-    #[test]
-    fn goto_declaration_submodule_import_from_use() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg.submod import val
-
-                x = sub<CURSOR>pkg
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // TODO(submodule-imports): this should only highlight `subpkg` in the import statement
-        // This happens because DefinitionKind::ImportFromSubmodule claims the entire ImportFrom node,
-        // which is correct but unhelpful. Unfortunately even if it only claimed the LHS identifier it
-        // would highlight `subpkg.submod` which is strictly better but still isn't what we want.
-        assert_snapshot!(test.goto_declaration(), @r"
-        info[goto-declaration]: Declaration
-         --> mypackage/__init__.py:2:1
-          |
-        2 | from .subpkg.submod import val
-          | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-        3 |
-        4 | x = subpkg
-          |
-        info: Source
-         --> mypackage/__init__.py:4:5
-          |
-        2 | from .subpkg.submod import val
-        3 |
-        4 | x = subpkg
-          |     ^^^^^^
-          |
-        ");
-    }
-
-    #[test]
-    fn goto_declaration_submodule_import_from_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .sub<CURSOR>pkg.submod import val
-
-                x = subpkg
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // TODO(submodule-imports): I don't *think* this is what we want..?
-        // It's a bit confusing because this symbol is essentially the LHS *and* RHS of
-        // `subpkg = mypackage.subpkg`. As in, it's both defining a local `subpkg` and
-        // loading the module `mypackage.subpkg`, so, it's understandable to get confused!
-        assert_snapshot!(test.goto_declaration(), @r"
-        info[goto-declaration]: Declaration
-        --> mypackage/subpkg/__init__.py:1:1
-         |
-         |
-        info: Source
-         --> mypackage/__init__.py:2:7
-          |
-        2 | from .subpkg.submod import val
-          |       ^^^^^^
-        3 |
-        4 | x = subpkg
-          |
-        ");
-    }
-
-    #[test]
-    fn goto_declaration_submodule_import_from_wrong_use() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg.submod import val
-
-                x = sub<CURSOR>mod
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // No result is correct!
-        assert_snapshot!(test.goto_declaration(), @"No goto target found");
-    }
-
-    #[test]
-    fn goto_declaration_submodule_import_from_wrong_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg.sub<CURSOR>mod import val
-
-                x = submod
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // Going to the submod module is correct!
-        assert_snapshot!(test.goto_declaration(), @r"
-        info[goto-declaration]: Declaration
-         --> mypackage/subpkg/submod.py:1:1
-          |
-        1 |
-          | ^
-        2 | val: int = 0
-          |
-        info: Source
-         --> mypackage/__init__.py:2:14
-          |
-        2 | from .subpkg.submod import val
-          |              ^^^^^^
-        3 |
-        4 | x = submod
-          |
-        ");
-    }
-
-    #[test]
-    fn goto_declaration_submodule_import_from_confusing_shadowed_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .sub<CURSOR>pkg import subpkg
-
-                x = subpkg
-                "#,
-            )
-            .source(
-                "mypackage/subpkg/__init__.py",
-                r#"
-                subpkg: int = 10
-                "#,
-            )
-            .build();
-
-        // Going to the subpkg module is correct!
-        assert_snapshot!(test.goto_declaration(), @r"
-        info[goto-declaration]: Declaration
-         --> mypackage/subpkg/__init__.py:1:1
-          |
-        1 |
-          | ^
-        2 | subpkg: int = 10
-          |
-        info: Source
-         --> mypackage/__init__.py:2:7
-          |
-        2 | from .subpkg import subpkg
-          |       ^^^^^^
-        3 |
-        4 | x = subpkg
-          |
-        ");
-    }
-
-    #[test]
-    fn goto_declaration_submodule_import_from_confusing_real_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg import sub<CURSOR>pkg
-
-                x = subpkg
-                "#,
-            )
-            .source(
-                "mypackage/subpkg/__init__.py",
-                r#"
-                subpkg: int = 10
-                "#,
-            )
-            .build();
-
-        // Going to the subpkg `int` is correct!
-        assert_snapshot!(test.goto_declaration(), @r"
-        info[goto-declaration]: Declaration
-         --> mypackage/subpkg/__init__.py:2:1
-          |
-        2 | subpkg: int = 10
-          | ^^^^^^
-          |
-        info: Source
-         --> mypackage/__init__.py:2:21
-          |
-        2 | from .subpkg import subpkg
-          |                     ^^^^^^
-        3 |
-        4 | x = subpkg
-          |
-        ");
-    }
-
-    #[test]
-    fn goto_declaration_submodule_import_from_confusing_use() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg import subpkg
-
-                x = sub<CURSOR>pkg
-                "#,
-            )
-            .source(
-                "mypackage/subpkg/__init__.py",
-                r#"
-                subpkg: int = 10
-                "#,
-            )
-            .build();
-
-        // TODO(submodule-imports): Ok this one is FASCINATING and it's kinda right but confusing!
-        //
-        // So there's 3 relevant definitions here:
-        //
-        // * `subpkg: int = 10` in the other file is in fact the original definition
-        //
-        // *  the LHS `subpkg` in the import is an instance of `subpkg = ...`
-        //    because it's a `DefinitionKind::ImportFromSubmodle`.
-        //    This is the span that covers the entire import.
-        //
-        // * `the RHS `subpkg` in the import is a second instance of `subpkg = ...`
-        //    that *immediately* overwrites the `ImportFromSubmodule`'s definition
-        //    This span seemingly doesn't appear at all!? Is it getting hidden by the LHS span?
-        assert_snapshot!(test.goto_declaration(), @r"
-        info[goto-declaration]: Declaration
-         --> mypackage/__init__.py:2:1
-          |
-        2 | from .subpkg import subpkg
-          | ^^^^^^^^^^^^^^^^^^^^^^^^^^
-        3 |
-        4 | x = subpkg
-          |
-        info: Source
-         --> mypackage/__init__.py:4:5
-          |
-        2 | from .subpkg import subpkg
-        3 |
-        4 | x = subpkg
-          |     ^^^^^^
-          |
-
-        info[goto-declaration]: Declaration
-         --> mypackage/subpkg/__init__.py:2:1
-          |
-        2 | subpkg: int = 10
-          | ^^^^^^
-          |
-        info: Source
-         --> mypackage/__init__.py:4:5
-          |
-        2 | from .subpkg import subpkg
-        3 |
-        4 | x = subpkg
-          |     ^^^^^^
-          |
-        ");
-    }
-
-    // TODO: Should only return `a: int`
-    #[test]
-    fn redeclarations() {
-        let test = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-                a: str = "test"
-
-                a: int = 10
-
-                print(a<CURSOR>)
-
-                a: bool = True
-                "#,
-            )
-            .build();
-
-        assert_snapshot!(test.goto_declaration(), @r#"
-        info[goto-declaration]: Declaration
-         --> main.py:2:1
-          |
-        2 | a: str = "test"
-          | ^
-        3 |
-        4 | a: int = 10
-          |
-        info: Source
-         --> main.py:6:7
-          |
-        4 | a: int = 10
-        5 |
-        6 | print(a)
-          |       ^
-        7 |
-        8 | a: bool = True
-          |
-
-        info[goto-declaration]: Declaration
-         --> main.py:4:1
-          |
-        2 | a: str = "test"
-        3 |
-        4 | a: int = 10
-          | ^
-        5 |
-        6 | print(a)
-          |
-        info: Source
-         --> main.py:6:7
-          |
-        4 | a: int = 10
-        5 |
-        6 | print(a)
-          |       ^
-        7 |
-        8 | a: bool = True
-          |
-
-        info[goto-declaration]: Declaration
-         --> main.py:8:1
-          |
-        6 | print(a)
-        7 |
-        8 | a: bool = True
-          | ^
-          |
-        info: Source
-         --> main.py:6:7
-          |
-        4 | a: int = 10
-        5 |
-        6 | print(a)
-          |       ^
-        7 |
-        8 | a: bool = True
-          |
-        "#);
-    }
-
     impl CursorTest {
         fn goto_declaration(&self) -> String {
             let Some(targets) = goto_declaration(&self.db, self.cursor.file, self.cursor.offset)

crates/ty_ide/src/goto_definition.rs

@@ -1714,86 +1714,6 @@ Traceb<CURSOR>ackType
         assert_snapshot!(test.goto_definition(), @"No goto target found");
     }
 
-    // TODO: Should only list `a: int`
-    #[test]
-    fn redeclarations() {
-        let test = CursorTest::builder()
-            .source(
-                "main.py",
-                r#"
-                a: str = "test"
-
-                a: int = 10
-
-                print(a<CURSOR>)
-
-                a: bool = True
-                "#,
-            )
-            .build();
-
-        assert_snapshot!(test.goto_definition(), @r#"
-        info[goto-definition]: Definition
-         --> main.py:2:1
-          |
-        2 | a: str = "test"
-          | ^
-        3 |
-        4 | a: int = 10
-          |
-        info: Source
-         --> main.py:6:7
-          |
-        4 | a: int = 10
-        5 |
-        6 | print(a)
-          |       ^
-        7 |
-        8 | a: bool = True
-          |
-
-        info[goto-definition]: Definition
-         --> main.py:4:1
-          |
-        2 | a: str = "test"
-        3 |
-        4 | a: int = 10
-          | ^
-        5 |
-        6 | print(a)
-          |
-        info: Source
-         --> main.py:6:7
-          |
-        4 | a: int = 10
-        5 |
-        6 | print(a)
-          |       ^
-        7 |
-        8 | a: bool = True
-          |
-
-        info[goto-definition]: Definition
-         --> main.py:8:1
-          |
-        6 | print(a)
-        7 |
-        8 | a: bool = True
-          | ^
-          |
-        info: Source
-         --> main.py:6:7
-          |
-        4 | a: int = 10
-        5 |
-        6 | print(a)
-          |       ^
-        7 |
-        8 | a: bool = True
-          |
-        "#);
-    }
-
     impl CursorTest {
         fn goto_definition(&self) -> String {
             let Some(targets) = goto_definition(&self.db, self.cursor.file, self.cursor.offset)

crates/ty_ide/src/goto_type_definition.rs

@@ -145,14 +145,14 @@ mod tests {
 
         assert_snapshot!(test.goto_type_definition(), @r"
         info[goto-type-definition]: Type definition
-           --> stdlib/typing.pyi:781:1
+           --> stdlib/typing.pyi:770:1
             |
-        779 |         def __class_getitem__(cls, args: TypeVar | tuple[TypeVar, ...]) -> _Final: ...
-        780 |
-        781 | Generic: type[_Generic]
+        768 |         def __class_getitem__(cls, args: TypeVar | tuple[TypeVar, ...]) -> _Final: ...
+        769 |
+        770 | Generic: type[_Generic]
             | ^^^^^^^
-        782 |
-        783 | class _ProtocolMeta(ABCMeta):
+        771 |
+        772 | class _ProtocolMeta(ABCMeta):
             |
         info: Source
          --> main.py:4:1
@@ -964,60 +964,6 @@ mod tests {
         assert_snapshot!(test.goto_type_definition(), @"No goto target found");
     }
 
-    #[test]
-    fn goto_type_string_annotation_recursive() {
-        let test = cursor_test(
-            r#"
-        ab: "a<CURSOR>b"
-        "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r#"
-        info[goto-type-definition]: Type definition
-          --> stdlib/ty_extensions.pyi:20:1
-           |
-        19 | # Types
-        20 | Unknown = object()
-           | ^^^^^^^
-        21 | AlwaysTruthy = object()
-        22 | AlwaysFalsy = object()
-           |
-        info: Source
-         --> main.py:2:6
-          |
-        2 | ab: "ab"
-          |      ^^
-          |
-        "#);
-    }
-
-    #[test]
-    fn goto_type_string_annotation_unknown() {
-        let test = cursor_test(
-            r#"
-        x: "foo<CURSOR>bar"
-        "#,
-        );
-
-        assert_snapshot!(test.goto_type_definition(), @r#"
-        info[goto-type-definition]: Type definition
-          --> stdlib/ty_extensions.pyi:20:1
-           |
-        19 | # Types
-        20 | Unknown = object()
-           | ^^^^^^^
-        21 | AlwaysTruthy = object()
-        22 | AlwaysFalsy = object()
-           |
-        info: Source
-         --> main.py:2:5
-          |
-        2 | x: "foobar"
-          |     ^^^^^^
-          |
-        "#);
-    }
-
     #[test]
     fn goto_type_match_name_stmt() {
         let test = cursor_test(
@@ -1111,7 +1057,7 @@ mod tests {
                 def __init__(self, pos, btn):
                     self.position: int = pos
                     self.button: str = btn
-
+            
             def my_func(event: Click):
                 match event:
                     case Click(x, button=a<CURSOR>b):
@@ -1131,7 +1077,7 @@ mod tests {
                 def __init__(self, pos, btn):
                     self.position: int = pos
                     self.button: str = btn
-
+            
             def my_func(event: Click):
                 match event:
                     case Click(x, button=ab):
@@ -1151,7 +1097,7 @@ mod tests {
                 def __init__(self, pos, btn):
                     self.position: int = pos
                     self.button: str = btn
-
+            
             def my_func(event: Click):
                 match event:
                     case Cl<CURSOR>ick(x, button=ab):
@@ -1189,7 +1135,7 @@ mod tests {
                 def __init__(self, pos, btn):
                     self.position: int = pos
                     self.button: str = btn
-
+            
             def my_func(event: Click):
                 match event:
                     case Click(x, but<CURSOR>ton=ab):
@@ -1398,12 +1344,12 @@ f(**kwargs<CURSOR>)
             r#"
 def outer():
     x = "outer_value"
-
+    
     def inner():
         nonlocal x
         x = "modified"
         return x<CURSOR>  # Should find the nonlocal x declaration in outer scope
-
+    
     return inner
 "#,
         );
@@ -1438,12 +1384,12 @@ def outer():
             r#"
 def outer():
     xy = "outer_value"
-
+    
     def inner():
         nonlocal x<CURSOR>y
         xy = "modified"
         return x  # Should find the nonlocal x declaration in outer scope
-
+    
     return inner
 "#,
         );
@@ -1672,283 +1618,6 @@ def function():
         "#);
     }
 
-    #[test]
-    fn goto_type_submodule_import_from_use() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg.submod import val
-
-                x = sub<CURSOR>pkg
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // The module is the correct type definition
-        assert_snapshot!(test.goto_type_definition(), @r"
-        info[goto-type-definition]: Type definition
-        --> mypackage/subpkg/__init__.py:1:1
-         |
-         |
-        info: Source
-         --> mypackage/__init__.py:4:5
-          |
-        2 | from .subpkg.submod import val
-        3 |
-        4 | x = subpkg
-          |     ^^^^^^
-          |
-        ");
-    }
-
-    #[test]
-    fn goto_type_submodule_import_from_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .sub<CURSOR>pkg.submod import val
-
-                x = subpkg
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // The module is the correct type definition
-        assert_snapshot!(test.goto_type_definition(), @r"
-        info[goto-type-definition]: Type definition
-        --> mypackage/subpkg/__init__.py:1:1
-         |
-         |
-        info: Source
-         --> mypackage/__init__.py:2:7
-          |
-        2 | from .subpkg.submod import val
-          |       ^^^^^^
-        3 |
-        4 | x = subpkg
-          |
-        ");
-    }
-
-    #[test]
-    fn goto_type_submodule_import_from_wrong_use() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg.submod import val
-
-                x = sub<CURSOR>mod
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // Unknown is correct, `submod` is not in scope
-        assert_snapshot!(test.goto_type_definition(), @r"
-        info[goto-type-definition]: Type definition
-          --> stdlib/ty_extensions.pyi:20:1
-           |
-        19 | # Types
-        20 | Unknown = object()
-           | ^^^^^^^
-        21 | AlwaysTruthy = object()
-        22 | AlwaysFalsy = object()
-           |
-        info: Source
-         --> mypackage/__init__.py:4:5
-          |
-        2 | from .subpkg.submod import val
-        3 |
-        4 | x = submod
-          |     ^^^^^^
-          |
-        ");
-    }
-
-    #[test]
-    fn goto_type_submodule_import_from_wrong_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg.sub<CURSOR>mod import val
-
-                x = submod
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // The module is correct
-        assert_snapshot!(test.goto_type_definition(), @r"
-        info[goto-type-definition]: Type definition
-         --> mypackage/subpkg/submod.py:1:1
-          |
-        1 | /
-        2 | | val: int = 0
-          | |_____________^
-          |
-        info: Source
-         --> mypackage/__init__.py:2:14
-          |
-        2 | from .subpkg.submod import val
-          |              ^^^^^^
-        3 |
-        4 | x = submod
-          |
-        ");
-    }
-
-    #[test]
-    fn goto_type_submodule_import_from_confusing_shadowed_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .sub<CURSOR>pkg import subpkg
-
-                x = subpkg
-                "#,
-            )
-            .source(
-                "mypackage/subpkg/__init__.py",
-                r#"
-                subpkg: int = 10
-                "#,
-            )
-            .build();
-
-        // The module is correct
-        assert_snapshot!(test.goto_type_definition(), @r"
-        info[goto-type-definition]: Type definition
-         --> mypackage/subpkg/__init__.py:1:1
-          |
-        1 | /
-        2 | | subpkg: int = 10
-          | |_________________^
-          |
-        info: Source
-         --> mypackage/__init__.py:2:7
-          |
-        2 | from .subpkg import subpkg
-          |       ^^^^^^
-        3 |
-        4 | x = subpkg
-          |
-        ");
-    }
-
-    #[test]
-    fn goto_type_submodule_import_from_confusing_real_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg import sub<CURSOR>pkg
-
-                x = subpkg
-                "#,
-            )
-            .source(
-                "mypackage/subpkg/__init__.py",
-                r#"
-                subpkg: int = 10
-                "#,
-            )
-            .build();
-
-        // `int` is correct
-        assert_snapshot!(test.goto_type_definition(), @r#"
-        info[goto-type-definition]: Type definition
-           --> stdlib/builtins.pyi:348:7
-            |
-        347 | @disjoint_base
-        348 | class int:
-            |       ^^^
-        349 |     """int([x]) -> integer
-        350 |     int(x, base=10) -> integer
-            |
-        info: Source
-         --> mypackage/__init__.py:2:21
-          |
-        2 | from .subpkg import subpkg
-          |                     ^^^^^^
-        3 |
-        4 | x = subpkg
-          |
-        "#);
-    }
-
-    #[test]
-    fn goto_type_submodule_import_from_confusing_use() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg import subpkg
-
-                x = sub<CURSOR>pkg
-                "#,
-            )
-            .source(
-                "mypackage/subpkg/__init__.py",
-                r#"
-                subpkg: int = 10
-                "#,
-            )
-            .build();
-
-        // `int` is correct
-        assert_snapshot!(test.goto_type_definition(), @r#"
-        info[goto-type-definition]: Type definition
-           --> stdlib/builtins.pyi:348:7
-            |
-        347 | @disjoint_base
-        348 | class int:
-            |       ^^^
-        349 |     """int([x]) -> integer
-        350 |     int(x, base=10) -> integer
-            |
-        info: Source
-         --> mypackage/__init__.py:4:5
-          |
-        2 | from .subpkg import subpkg
-        3 |
-        4 | x = subpkg
-          |     ^^^^^^
-          |
-        "#);
-    }
-
     impl CursorTest {
         fn goto_type_definition(&self) -> String {
             let Some(targets) =

crates/ty_ide/src/hover.rs

@@ -1089,60 +1089,6 @@ mod tests {
         assert_snapshot!(test.hover(), @"Hover provided no content");
     }
 
-    #[test]
-    fn hover_string_annotation_recursive() {
-        let test = cursor_test(
-            r#"
-        ab: "a<CURSOR>b"
-        "#,
-        );
-
-        assert_snapshot!(test.hover(), @r#"
-        Unknown
-        ---------------------------------------------
-        ```python
-        Unknown
-        ```
-        ---------------------------------------------
-        info[hover]: Hovered content is
-         --> main.py:2:6
-          |
-        2 | ab: "ab"
-          |      ^-
-          |      ||
-          |      |Cursor offset
-          |      source
-          |
-        "#);
-    }
-
-    #[test]
-    fn hover_string_annotation_unknown() {
-        let test = cursor_test(
-            r#"
-        x: "foo<CURSOR>bar"
-        "#,
-        );
-
-        assert_snapshot!(test.hover(), @r#"
-        Unknown
-        ---------------------------------------------
-        ```python
-        Unknown
-        ```
-        ---------------------------------------------
-        info[hover]: Hovered content is
-         --> main.py:2:5
-          |
-        2 | x: "foobar"
-          |     ^^^-^^
-          |     |  |
-          |     |  Cursor offset
-          |     source
-          |
-        "#);
-    }
-
     #[test]
     fn hover_overload_type_disambiguated1() {
         let test = CursorTest::builder()
@@ -1708,12 +1654,12 @@ def ab(a: int, *, c: int):
             r#"
 def outer():
     x = "outer_value"
-
+    
     def inner():
         nonlocal x
         x = "modified"
         return x<CURSOR>  # Should find the nonlocal x declaration in outer scope
-
+    
     return inner
 "#,
         );
@@ -1747,12 +1693,12 @@ def outer():
             r#"
 def outer():
     xy = "outer_value"
-
+    
     def inner():
         nonlocal x<CURSOR>y
         xy = "modified"
         return x  # Should find the nonlocal x declaration in outer scope
-
+    
     return inner
 "#,
         );
@@ -1960,7 +1906,7 @@ def function():
                 def __init__(self, pos, btn):
                     self.position: int = pos
                     self.button: str = btn
-
+            
             def my_func(event: Click):
                 match event:
                     case Click(x, button=a<CURSOR>b):
@@ -1980,7 +1926,7 @@ def function():
                 def __init__(self, pos, btn):
                     self.position: int = pos
                     self.button: str = btn
-
+            
             def my_func(event: Click):
                 match event:
                     case Click(x, button=ab):
@@ -2018,7 +1964,7 @@ def function():
                 def __init__(self, pos, btn):
                     self.position: int = pos
                     self.button: str = btn
-
+            
             def my_func(event: Click):
                 match event:
                     case Cl<CURSOR>ick(x, button=ab):
@@ -2057,7 +2003,7 @@ def function():
                 def __init__(self, pos, btn):
                     self.position: int = pos
                     self.button: str = btn
-
+            
             def my_func(event: Click):
                 match event:
                     case Click(x, but<CURSOR>ton=ab):
@@ -2143,13 +2089,15 @@ def function():
             "#,
         );
 
-        // TODO: This should just be `**AB@Alias2 (<variance>)`
-        // https://github.com/astral-sh/ty/issues/1581
         assert_snapshot!(test.hover(), @r"
-        (**AB@Alias2) -> tuple[AB@Alias2]
+        (
+            ...
+        ) -> tuple[typing.ParamSpec]
         ---------------------------------------------
         ```python
-        (**AB@Alias2) -> tuple[AB@Alias2]
+        (
+            ...
+        ) -> tuple[typing.ParamSpec]
         ```
         ---------------------------------------------
         info[hover]: Hovered content is
@@ -2290,12 +2238,12 @@ def function():
             "#,
         );
 
-        // TODO: Should this be constravariant instead?
+        // TODO: This should be `P@Alias (<variance>)`
         assert_snapshot!(test.hover(), @r"
-        P@Alias (bivariant)
+        typing.ParamSpec
         ---------------------------------------------
         ```python
-        P@Alias (bivariant)
+        typing.ParamSpec
         ```
         ---------------------------------------------
         info[hover]: Hovered content is
@@ -3319,297 +3267,6 @@ def function():
         ");
     }
 
-    #[test]
-    fn hover_submodule_import_from_use() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg.submod import val
-
-                x = sub<CURSOR>pkg
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // The module is correct
-        assert_snapshot!(test.hover(), @r"
-        <module 'mypackage.subpkg'>
-        ---------------------------------------------
-        ```python
-        <module 'mypackage.subpkg'>
-        ```
-        ---------------------------------------------
-        info[hover]: Hovered content is
-         --> mypackage/__init__.py:4:5
-          |
-        2 | from .subpkg.submod import val
-        3 |
-        4 | x = subpkg
-          |     ^^^-^^
-          |     |  |
-          |     |  Cursor offset
-          |     source
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_submodule_import_from_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .sub<CURSOR>pkg.submod import val
-
-                x = subpkg
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // The module is correct
-        assert_snapshot!(test.hover(), @r"
-        <module 'mypackage.subpkg'>
-        ---------------------------------------------
-        ```python
-        <module 'mypackage.subpkg'>
-        ```
-        ---------------------------------------------
-        info[hover]: Hovered content is
-         --> mypackage/__init__.py:2:7
-          |
-        2 | from .subpkg.submod import val
-          |       ^^^-^^
-          |       |  |
-          |       |  Cursor offset
-          |       source
-        3 |
-        4 | x = subpkg
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_submodule_import_from_wrong_use() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg.submod import val
-
-                x = sub<CURSOR>mod
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // Unknown is correct
-        assert_snapshot!(test.hover(), @r"
-        Unknown
-        ---------------------------------------------
-        ```python
-        Unknown
-        ```
-        ---------------------------------------------
-        info[hover]: Hovered content is
-         --> mypackage/__init__.py:4:5
-          |
-        2 | from .subpkg.submod import val
-        3 |
-        4 | x = submod
-          |     ^^^-^^
-          |     |  |
-          |     |  Cursor offset
-          |     source
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_submodule_import_from_wrong_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg.sub<CURSOR>mod import val
-
-                x = submod
-                "#,
-            )
-            .source("mypackage/subpkg/__init__.py", r#""#)
-            .source(
-                "mypackage/subpkg/submod.py",
-                r#"
-                val: int = 0
-                "#,
-            )
-            .build();
-
-        // The submodule is correct
-        assert_snapshot!(test.hover(), @r"
-        <module 'mypackage.subpkg.submod'>
-        ---------------------------------------------
-        ```python
-        <module 'mypackage.subpkg.submod'>
-        ```
-        ---------------------------------------------
-        info[hover]: Hovered content is
-         --> mypackage/__init__.py:2:14
-          |
-        2 | from .subpkg.submod import val
-          |              ^^^-^^
-          |              |  |
-          |              |  Cursor offset
-          |              source
-        3 |
-        4 | x = submod
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_submodule_import_from_confusing_shadowed_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .sub<CURSOR>pkg import subpkg
-
-                x = subpkg
-                "#,
-            )
-            .source(
-                "mypackage/subpkg/__init__.py",
-                r#"
-                subpkg: int = 10
-                "#,
-            )
-            .build();
-
-        // The module is correct
-        assert_snapshot!(test.hover(), @r"
-        <module 'mypackage.subpkg'>
-        ---------------------------------------------
-        ```python
-        <module 'mypackage.subpkg'>
-        ```
-        ---------------------------------------------
-        info[hover]: Hovered content is
-         --> mypackage/__init__.py:2:7
-          |
-        2 | from .subpkg import subpkg
-          |       ^^^-^^
-          |       |  |
-          |       |  Cursor offset
-          |       source
-        3 |
-        4 | x = subpkg
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_submodule_import_from_confusing_real_def() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg import sub<CURSOR>pkg
-
-                x = subpkg
-                "#,
-            )
-            .source(
-                "mypackage/subpkg/__init__.py",
-                r#"
-                subpkg: int = 10
-                "#,
-            )
-            .build();
-
-        // int is correct
-        assert_snapshot!(test.hover(), @r"
-        int
-        ---------------------------------------------
-        ```python
-        int
-        ```
-        ---------------------------------------------
-        info[hover]: Hovered content is
-         --> mypackage/__init__.py:2:21
-          |
-        2 | from .subpkg import subpkg
-          |                     ^^^-^^
-          |                     |  |
-          |                     |  Cursor offset
-          |                     source
-        3 |
-        4 | x = subpkg
-          |
-        ");
-    }
-
-    #[test]
-    fn hover_submodule_import_from_confusing_use() {
-        let test = CursorTest::builder()
-            .source(
-                "mypackage/__init__.py",
-                r#"
-                from .subpkg import subpkg
-
-                x = sub<CURSOR>pkg
-                "#,
-            )
-            .source(
-                "mypackage/subpkg/__init__.py",
-                r#"
-                subpkg: int = 10
-                "#,
-            )
-            .build();
-
-        // int is correct
-        assert_snapshot!(test.hover(), @r"
-        int
-        ---------------------------------------------
-        ```python
-        int
-        ```
-        ---------------------------------------------
-        info[hover]: Hovered content is
-         --> mypackage/__init__.py:4:5
-          |
-        2 | from .subpkg import subpkg
-        3 |
-        4 | x = subpkg
-          |     ^^^-^^
-          |     |  |
-          |     |  Cursor offset
-          |     source
-          |
-        ");
-    }
-
     impl CursorTest {
         fn hover(&self) -> String {
             use std::fmt::Write;

crates/ty_ide/src/importer.rs

@@ -145,7 +145,7 @@ impl<'a> Importer<'a> {
         members: &MembersInScope,
     ) -> ImportAction {
         let request = request.avoid_conflicts(self.db, self.file, members);
-        let mut symbol_text: Box<str> = request.member.unwrap_or(request.module).into();
+        let mut symbol_text: Box<str> = request.member.into();
         let Some(response) = self.find(&request, members.at) else {
             let insertion = if let Some(future) = self.find_last_future_import(members.at) {
                 Insertion::end_of_statement(future.stmt, self.source, self.stylist)
@@ -157,27 +157,14 @@ impl<'a> Importer<'a> {
                 Insertion::start_of_file(self.parsed.suite(), self.source, self.stylist, range)
             };
             let import = insertion.into_edit(&request.to_string());
-            if let Some(member) = request.member
-                && matches!(request.style, ImportStyle::Import)
-            {
-                symbol_text = format!("{}.{}", request.module, member).into();
+            if matches!(request.style, ImportStyle::Import) {
+                symbol_text = format!("{}.{}", request.module, request.member).into();
             }
             return ImportAction {
                 import: Some(import),
                 symbol_text,
             };
         };
-
-        // When we just have a request to import a module (and not
-        // any members from that module), then the only way we can be
-        // here is if we found a pre-existing import that definitively
-        // satisfies the request. So we're done.
-        let Some(member) = request.member else {
-            return ImportAction {
-                import: None,
-                symbol_text,
-            };
-        };
         match response.kind {
             ImportResponseKind::Unqualified { ast, alias } => {
                 let member = alias.asname.as_ref().unwrap_or(&alias.name).as_str();
@@ -202,10 +189,13 @@ impl<'a> Importer<'a> {
                 let import = if let Some(insertion) =
                     Insertion::existing_import(response.import.stmt, self.tokens)
                 {
-                    insertion.into_edit(member)
+                    insertion.into_edit(request.member)
                 } else {
                     Insertion::end_of_statement(response.import.stmt, self.source, self.stylist)
-                        .into_edit(&format!("from {} import {member}", request.module))
+                        .into_edit(&format!(
+                            "from {} import {}",
+                            request.module, request.member
+                        ))
                 };
                 ImportAction {
                     import: Some(import),
@@ -491,17 +481,6 @@ impl<'ast> AstImportKind<'ast> {
                 Some(ImportResponseKind::Qualified { ast, alias })
             }
             AstImportKind::ImportFrom(ast) => {
-                // If the request is for a module itself, then we
-                // assume that it can never be satisfies by a
-                // `from ... import ...` statement. For example, a
-                // `request for collections.abc` needs an
-                // `import collections.abc`. Now, there could be a
-                // `from collections import abc`, and we could
-                // plausibly consider that a match and return a
-                // symbol text of `abc`. But it's not clear if that's
-                // the right choice or not.
-                let member = request.member?;
-
                 if request.force_style && !matches!(request.style, ImportStyle::ImportFrom) {
                     return None;
                 }
@@ -513,7 +492,9 @@ impl<'ast> AstImportKind<'ast> {
                 let kind = ast
                     .names
                     .iter()
-                    .find(|alias| alias.name.as_str() == "*" || alias.name.as_str() == member)
+                    .find(|alias| {
+                        alias.name.as_str() == "*" || alias.name.as_str() == request.member
+                    })
                     .map(|alias| ImportResponseKind::Unqualified { ast, alias })
                     .unwrap_or_else(|| ImportResponseKind::Partial(ast));
                 Some(kind)
@@ -529,10 +510,7 @@ pub(crate) struct ImportRequest<'a> {
     /// `foo`, in `from foo import bar`).
     module: &'a str,
     /// The member to import (e.g., `bar`, in `from foo import bar`).
-    ///
-    /// When `member` is absent, then this request reflects an import
-    /// of the module itself. i.e., `import module`.
-    member: Option<&'a str>,
+    member: &'a str,
     /// The preferred style to use when importing the symbol (e.g.,
     /// `import foo` or `from foo import bar`).
     ///
@@ -554,7 +532,7 @@ impl<'a> ImportRequest<'a> {
     pub(crate) fn import(module: &'a str, member: &'a str) -> Self {
         Self {
             module,
-            member: Some(member),
+            member,
             style: ImportStyle::Import,
             force_style: false,
         }
@@ -567,26 +545,12 @@ impl<'a> ImportRequest<'a> {
     pub(crate) fn import_from(module: &'a str, member: &'a str) -> Self {
         Self {
             module,
-            member: Some(member),
+            member,
             style: ImportStyle::ImportFrom,
             force_style: false,
         }
     }
 
-    /// Create a new [`ImportRequest`] for bringing the given module
-    /// into scope.
-    ///
-    /// This is for just importing the module itself, always via an
-    /// `import` statement.
-    pub(crate) fn module(module: &'a str) -> Self {
-        Self {
-            module,
-            member: None,
-            style: ImportStyle::Import,
-            force_style: false,
-        }
-    }
-
     /// Causes this request to become a command. This will force the
     /// requested import style, even if another style would be more
     /// appropriate generally.
@@ -601,13 +565,7 @@ impl<'a> ImportRequest<'a> {
     /// of an import conflict are minimized (although not always reduced
     /// to zero).
     fn avoid_conflicts(self, db: &dyn Db, importing_file: File, members: &MembersInScope) -> Self {
-        let Some(member) = self.member else {
-            return Self {
-                style: ImportStyle::Import,
-                ..self
-            };
-        };
-        match (members.map.get(self.module), members.map.get(member)) {
+        match (members.map.get(self.module), members.map.get(self.member)) {
             // Neither symbol exists, so we can just proceed as
             // normal.
             (None, None) => self,
@@ -672,10 +630,7 @@ impl std::fmt::Display for ImportRequest<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self.style {
             ImportStyle::Import => write!(f, "import {}", self.module),
-            ImportStyle::ImportFrom => match self.member {
-                None => write!(f, "import {}", self.module),
-                Some(member) => write!(f, "from {} import {member}", self.module),
-            },
+            ImportStyle::ImportFrom => write!(f, "from {} import {}", self.module, self.member),
         }
     }
 }
@@ -888,10 +843,6 @@ mod tests {
             self.add(ImportRequest::import_from(module, member))
         }
 
-        fn module(&self, module: &str) -> String {
-            self.add(ImportRequest::module(module))
-        }
-
         fn add(&self, request: ImportRequest<'_>) -> String {
             let node = covering_node(
                 self.cursor.parsed.syntax().into(),
@@ -2205,73 +2156,4 @@ except ImportError:
         (bar.MAGIC)
         ");
     }
-
-    #[test]
-    fn import_module_blank() {
-        let test = cursor_test(
-            "\
-<CURSOR>
-        ",
-        );
-        assert_snapshot!(
-            test.module("collections"), @r"
-        import collections
-        collections
-        ");
-    }
-
-    #[test]
-    fn import_module_exists() {
-        let test = cursor_test(
-            "\
-import collections
-<CURSOR>
-        ",
-        );
-        assert_snapshot!(
-            test.module("collections"), @r"
-        import collections
-        collections
-        ");
-    }
-
-    #[test]
-    fn import_module_from_exists() {
-        let test = cursor_test(
-            "\
-from collections import defaultdict
-<CURSOR>
-        ",
-        );
-        assert_snapshot!(
-            test.module("collections"), @r"
-        import collections
-        from collections import defaultdict
-        collections
-        ");
-    }
-
-    // This test is working as intended. That is,
-    // `abc` is already in scope, so requesting an
-    // import for `collections.abc` could feasibly
-    // reuse the import and rewrite the symbol text
-    // to just `abc`. But for now it seems better
-    // to respect what has been written and add the
-    // `import collections.abc`. This behavior could
-    // plausibly be changed.
-    #[test]
-    fn import_module_from_via_member_exists() {
-        let test = cursor_test(
-            "\
-from collections import abc
-<CURSOR>
-        ",
-        );
-        assert_snapshot!(
-            test.module("collections.abc"), @r"
-        import collections.abc
-        from collections import abc
-        collections.abc
-        ");
-    }
 }

crates/ty_ide/src/inlay_hints.rs

@@ -19,22 +19,11 @@ pub struct InlayHint {
 }
 
 impl InlayHint {
-    fn variable_type(
-        expr: &Expr,
-        rhs: &Expr,
-        ty: Type,
-        db: &dyn Db,
-        allow_edits: bool,
-    ) -> Option<Self> {
+    fn variable_type(expr: &Expr, ty: Type, db: &dyn Db, allow_edits: bool) -> Self {
         let position = expr.range().end();
         // Render the type to a string, and get subspans for all the types that make it up
         let details = ty.display(db).to_string_parts();
 
-        // Filter out a reptitive hints like `x: T = T()`
-        if call_matches_name(rhs, &details.label) {
-            return None;
-        }
-
         // Ok so the idea here is that we potentially have a random soup of spans here,
         // and each byte of the string can have at most one target associate with it.
         // Thankfully, they were generally pushed in print order, with the inner smaller types
@@ -84,12 +73,12 @@ impl InlayHint {
             vec![]
         };
 
-        Some(Self {
+        Self {
             position,
             kind: InlayHintKind::Type,
             label: InlayHintLabel { parts: label_parts },
             text_edits,
-        })
+        }
     }
 
     fn call_argument_name(
@@ -261,7 +250,7 @@ struct InlayHintVisitor<'a, 'db> {
     db: &'db dyn Db,
     model: SemanticModel<'db>,
     hints: Vec<InlayHint>,
-    assignment_rhs: Option<&'a Expr>,
+    in_assignment: bool,
     range: TextRange,
     settings: &'a InlayHintSettings,
     in_no_edits_allowed: bool,
@@ -273,21 +262,21 @@ impl<'a, 'db> InlayHintVisitor<'a, 'db> {
             db,
             model: SemanticModel::new(db, file),
             hints: Vec::new(),
-            assignment_rhs: None,
+            in_assignment: false,
             range,
             settings,
             in_no_edits_allowed: false,
         }
     }
 
-    fn add_type_hint(&mut self, expr: &Expr, rhs: &Expr, ty: Type<'db>, allow_edits: bool) {
+    fn add_type_hint(&mut self, expr: &Expr, ty: Type<'db>, allow_edits: bool) {
         if !self.settings.variable_types {
             return;
         }
 
-        if let Some(inlay_hint) = InlayHint::variable_type(expr, rhs, ty, self.db, allow_edits) {
-            self.hints.push(inlay_hint);
-        }
+        let inlay_hint = InlayHint::variable_type(expr, ty, self.db, allow_edits);
+
+        self.hints.push(inlay_hint);
     }
 
     fn add_call_argument_name(
@@ -310,8 +299,8 @@ impl<'a, 'db> InlayHintVisitor<'a, 'db> {
     }
 }
 
-impl<'a> SourceOrderVisitor<'a> for InlayHintVisitor<'a, '_> {
-    fn enter_node(&mut self, node: AnyNodeRef<'a>) -> TraversalSignal {
+impl SourceOrderVisitor<'_> for InlayHintVisitor<'_, '_> {
+    fn enter_node(&mut self, node: AnyNodeRef<'_>) -> TraversalSignal {
         if self.range.intersect(node.range()).is_some() {
             TraversalSignal::Traverse
         } else {
@@ -319,7 +308,7 @@ impl<'a> SourceOrderVisitor<'a> for InlayHintVisitor<'a, '_> {
         }
     }
 
-    fn visit_stmt(&mut self, stmt: &'a Stmt) {
+    fn visit_stmt(&mut self, stmt: &Stmt) {
         let node = AnyNodeRef::from(stmt);
 
         if !self.enter_node(node).is_traverse() {
@@ -328,9 +317,7 @@ impl<'a> SourceOrderVisitor<'a> for InlayHintVisitor<'a, '_> {
 
         match stmt {
             Stmt::Assign(assign) => {
-                if !type_hint_is_excessive_for_expr(&assign.value) {
-                    self.assignment_rhs = Some(&*assign.value);
-                }
+                self.in_assignment = !type_hint_is_excessive_for_expr(&assign.value);
                 if !annotations_are_valid_syntax(assign) {
                     self.in_no_edits_allowed = true;
                 }
@@ -338,7 +325,7 @@ impl<'a> SourceOrderVisitor<'a> for InlayHintVisitor<'a, '_> {
                     self.visit_expr(target);
                 }
                 self.in_no_edits_allowed = false;
-                self.assignment_rhs = None;
+                self.in_assignment = false;
 
                 self.visit_expr(&assign.value);
 
@@ -357,22 +344,22 @@ impl<'a> SourceOrderVisitor<'a> for InlayHintVisitor<'a, '_> {
         source_order::walk_stmt(self, stmt);
     }
 
-    fn visit_expr(&mut self, expr: &'a Expr) {
+    fn visit_expr(&mut self, expr: &'_ Expr) {
         match expr {
             Expr::Name(name) => {
-                if let Some(rhs) = self.assignment_rhs {
+                if self.in_assignment {
                     if name.ctx.is_store() {
                         let ty = expr.inferred_type(&self.model);
-                        self.add_type_hint(expr, rhs, ty, !self.in_no_edits_allowed);
+                        self.add_type_hint(expr, ty, !self.in_no_edits_allowed);
                     }
                 }
                 source_order::walk_expr(self, expr);
             }
             Expr::Attribute(attribute) => {
-                if let Some(rhs) = self.assignment_rhs {
+                if self.in_assignment {
                     if attribute.ctx.is_store() {
                         let ty = expr.inferred_type(&self.model);
-                        self.add_type_hint(expr, rhs, ty, !self.in_no_edits_allowed);
+                        self.add_type_hint(expr, ty, !self.in_no_edits_allowed);
                     }
                 }
                 source_order::walk_expr(self, expr);
@@ -429,26 +416,6 @@ fn arg_matches_name(arg_or_keyword: &ArgOrKeyword, name: &str) -> bool {
     }
 }
 
-/// Given a function call, check if the expression is the "same name"
-/// as the function being called.
-///
-/// This allows us to filter out reptitive inlay hints like `x: T = T(...)`.
-/// While still allowing non-trivial ones like `x: T[U] = T()`.
-fn call_matches_name(expr: &Expr, name: &str) -> bool {
-    // Only care about function calls
-    let Expr::Call(call) = expr else {
-        return false;
-    };
-
-    match &*call.func {
-        // `x: T = T()` is a match
-        Expr::Name(expr_name) => expr_name.id.as_str() == name,
-        // `x: T = a.T()` is a match
-        Expr::Attribute(expr_attribute) => expr_attribute.attr.as_str() == name,
-        _ => false,
-    }
-}
-
 /// Given an expression that's the RHS of an assignment, would it be excessive to
 /// emit an inlay type hint for the variable assigned to it?
 ///
@@ -1862,16 +1829,35 @@ mod tests {
             ",
         );
 
-        assert_snapshot!(test.inlay_hints(), @r"
+        assert_snapshot!(test.inlay_hints(), @r#"
         class A:
             def __init__(self, y):
-                self.x = int(1)
+                self.x[: int] = int(1)
                 self.y[: Unknown] = y
 
-        a = A([y=]2)
-        a.y = int(3)
+        a[: A] = A([y=]2)
+        a.y[: int] = int(3)
 
         ---------------------------------------------
+        info[inlay-hint-location]: Inlay Hint Target
+           --> stdlib/builtins.pyi:348:7
+            |
+        347 | @disjoint_base
+        348 | class int:
+            |       ^^^
+        349 |     """int([x]) -> integer
+        350 |     int(x, base=10) -> integer
+            |
+        info: Source
+         --> main2.py:4:18
+          |
+        2 | class A:
+        3 |     def __init__(self, y):
+        4 |         self.x[: int] = int(1)
+          |                  ^^^
+        5 |         self.y[: Unknown] = y
+          |
+
         info[inlay-hint-location]: Inlay Hint Target
           --> stdlib/ty_extensions.pyi:20:1
            |
@@ -1885,11 +1871,29 @@ mod tests {
          --> main2.py:5:18
           |
         3 |     def __init__(self, y):
-        4 |         self.x = int(1)
+        4 |         self.x[: int] = int(1)
         5 |         self.y[: Unknown] = y
           |                  ^^^^^^^
         6 |
-        7 | a = A([y=]2)
+        7 | a[: A] = A([y=]2)
+          |
+
+        info[inlay-hint-location]: Inlay Hint Target
+         --> main.py:2:7
+          |
+        2 | class A:
+          |       ^
+        3 |     def __init__(self, y):
+        4 |         self.x = int(1)
+          |
+        info: Source
+         --> main2.py:7:5
+          |
+        5 |         self.y[: Unknown] = y
+        6 |
+        7 | a[: A] = A([y=]2)
+          |     ^
+        8 | a.y[: int] = int(3)
           |
 
         info[inlay-hint-location]: Inlay Hint Target
@@ -1902,13 +1906,30 @@ mod tests {
         5 |         self.y = y
           |
         info: Source
-         --> main2.py:7:8
+         --> main2.py:7:13
           |
         5 |         self.y[: Unknown] = y
         6 |
-        7 | a = A([y=]2)
-          |        ^
-        8 | a.y = int(3)
+        7 | a[: A] = A([y=]2)
+          |             ^
+        8 | a.y[: int] = int(3)
+          |
+
+        info[inlay-hint-location]: Inlay Hint Target
+           --> stdlib/builtins.pyi:348:7
+            |
+        347 | @disjoint_base
+        348 | class int:
+            |       ^^^
+        349 |     """int([x]) -> integer
+        350 |     int(x, base=10) -> integer
+            |
+        info: Source
+         --> main2.py:8:7
+          |
+        7 | a[: A] = A([y=]2)
+        8 | a.y[: int] = int(3)
+          |       ^^^
           |
 
         ---------------------------------------------
@@ -1917,12 +1938,12 @@ mod tests {
 
         class A:
             def __init__(self, y):
-                self.x = int(1)
+                self.x: int = int(1)
                 self.y: Unknown = y
 
-        a = A(2)
-        a.y = int(3)
-        ");
+        a: A = A(2)
+        a.y: int = int(3)
+        "#);
     }
 
     #[test]
@@ -1991,7 +2012,7 @@ mod tests {
                 def __init__(self, pos, btn):
                     self.position: int = pos
                     self.button: str = btn
-
+            
             def my_func(event: Click):
                 match event:
                     case Click(x, button=ab):
@@ -2916,12 +2937,31 @@ mod tests {
             def __init__(self):
                 self.x: int = 1
 
-        x = MyClass()
+        x[: MyClass] = MyClass()
         y[: tuple[MyClass, MyClass]] = (MyClass(), MyClass())
         a[: MyClass], b[: MyClass] = MyClass(), MyClass()
         c[: MyClass], d[: MyClass] = (MyClass(), MyClass())
 
         ---------------------------------------------
+        info[inlay-hint-location]: Inlay Hint Target
+         --> main.py:2:7
+          |
+        2 | class MyClass:
+          |       ^^^^^^^
+        3 |     def __init__(self):
+        4 |         self.x: int = 1
+          |
+        info: Source
+         --> main2.py:6:5
+          |
+        4 |         self.x: int = 1
+        5 |
+        6 | x[: MyClass] = MyClass()
+          |     ^^^^^^^
+        7 | y[: tuple[MyClass, MyClass]] = (MyClass(), MyClass())
+        8 | a[: MyClass], b[: MyClass] = MyClass(), MyClass()
+          |
+
         info[inlay-hint-location]: Inlay Hint Target
             --> stdlib/builtins.pyi:2695:7
              |
@@ -2933,7 +2973,7 @@ mod tests {
         info: Source
          --> main2.py:7:5
           |
-        6 | x = MyClass()
+        6 | x[: MyClass] = MyClass()
         7 | y[: tuple[MyClass, MyClass]] = (MyClass(), MyClass())
           |     ^^^^^
         8 | a[: MyClass], b[: MyClass] = MyClass(), MyClass()
@@ -2951,7 +2991,7 @@ mod tests {
         info: Source
          --> main2.py:7:11
           |
-        6 | x = MyClass()
+        6 | x[: MyClass] = MyClass()
         7 | y[: tuple[MyClass, MyClass]] = (MyClass(), MyClass())
           |           ^^^^^^^
         8 | a[: MyClass], b[: MyClass] = MyClass(), MyClass()
@@ -2969,7 +3009,7 @@ mod tests {
         info: Source
          --> main2.py:7:20
           |
-        6 | x = MyClass()
+        6 | x[: MyClass] = MyClass()
         7 | y[: tuple[MyClass, MyClass]] = (MyClass(), MyClass())
           |                    ^^^^^^^
         8 | a[: MyClass], b[: MyClass] = MyClass(), MyClass()
@@ -2987,7 +3027,7 @@ mod tests {
         info: Source
          --> main2.py:8:5
           |
-        6 | x = MyClass()
+        6 | x[: MyClass] = MyClass()
         7 | y[: tuple[MyClass, MyClass]] = (MyClass(), MyClass())
         8 | a[: MyClass], b[: MyClass] = MyClass(), MyClass()
           |     ^^^^^^^
@@ -3005,7 +3045,7 @@ mod tests {
         info: Source
          --> main2.py:8:19
           |
-        6 | x = MyClass()
+        6 | x[: MyClass] = MyClass()
         7 | y[: tuple[MyClass, MyClass]] = (MyClass(), MyClass())
         8 | a[: MyClass], b[: MyClass] = MyClass(), MyClass()
           |                   ^^^^^^^
@@ -3054,7 +3094,7 @@ mod tests {
             def __init__(self):
                 self.x: int = 1
 
-        x = MyClass()
+        x: MyClass = MyClass()
         y: tuple[MyClass, MyClass] = (MyClass(), MyClass())
         a, b = MyClass(), MyClass()
         c, d = (MyClass(), MyClass())
@@ -4057,11 +4097,31 @@ mod tests {
             def __init__(self):
                 self.x: int = 1
                 self.y: int = 2
-        val = MyClass()
+        val[: MyClass] = MyClass()
 
         foo(val.x)
         foo([x=]val.y)
         ---------------------------------------------
+        info[inlay-hint-location]: Inlay Hint Target
+         --> main.py:3:7
+          |
+        2 | def foo(x: int): pass
+        3 | class MyClass:
+          |       ^^^^^^^
+        4 |     def __init__(self):
+        5 |         self.x: int = 1
+          |
+        info: Source
+         --> main2.py:7:7
+          |
+        5 |         self.x: int = 1
+        6 |         self.y: int = 2
+        7 | val[: MyClass] = MyClass()
+          |       ^^^^^^^
+        8 |
+        9 | foo(val.x)
+          |
+
         info[inlay-hint-location]: Inlay Hint Target
          --> main.py:2:9
           |
@@ -4077,6 +4137,20 @@ mod tests {
         10 | foo([x=]val.y)
            |      ^
            |
+
+        ---------------------------------------------
+        info[inlay-hint-edit]: File after edits
+        info: Source
+
+        def foo(x: int): pass
+        class MyClass:
+            def __init__(self):
+                self.x: int = 1
+                self.y: int = 2
+        val: MyClass = MyClass()
+
+        foo(val.x)
+        foo(val.y)
         ");
     }
 
@@ -4102,11 +4176,31 @@ mod tests {
             def __init__(self):
                 self.x: int = 1
                 self.y: int = 2
-        x = MyClass()
+        x[: MyClass] = MyClass()
 
         foo(x.x)
         foo([x=]x.y)
         ---------------------------------------------
+        info[inlay-hint-location]: Inlay Hint Target
+         --> main.py:3:7
+          |
+        2 | def foo(x: int): pass
+        3 | class MyClass:
+          |       ^^^^^^^
+        4 |     def __init__(self):
+        5 |         self.x: int = 1
+          |
+        info: Source
+         --> main2.py:7:5
+          |
+        5 |         self.x: int = 1
+        6 |         self.y: int = 2
+        7 | x[: MyClass] = MyClass()
+          |     ^^^^^^^
+        8 |
+        9 | foo(x.x)
+          |
+
         info[inlay-hint-location]: Inlay Hint Target
          --> main.py:2:9
           |
@@ -4122,6 +4216,20 @@ mod tests {
         10 | foo([x=]x.y)
            |      ^
            |
+
+        ---------------------------------------------
+        info[inlay-hint-edit]: File after edits
+        info: Source
+
+        def foo(x: int): pass
+        class MyClass:
+            def __init__(self):
+                self.x: int = 1
+                self.y: int = 2
+        x: MyClass = MyClass()
+
+        foo(x.x)
+        foo(x.y)
         ");
     }
 
@@ -4150,11 +4258,31 @@ mod tests {
                 return 1
             def y() -> int:
                 return 2
-        val = MyClass()
+        val[: MyClass] = MyClass()
 
         foo(val.x())
         foo([x=]val.y())
         ---------------------------------------------
+        info[inlay-hint-location]: Inlay Hint Target
+         --> main.py:3:7
+          |
+        2 | def foo(x: int): pass
+        3 | class MyClass:
+          |       ^^^^^^^
+        4 |     def __init__(self):
+        5 |     def x() -> int:
+          |
+        info: Source
+          --> main2.py:9:7
+           |
+         7 |     def y() -> int:
+         8 |         return 2
+         9 | val[: MyClass] = MyClass()
+           |       ^^^^^^^
+        10 |
+        11 | foo(val.x())
+           |
+
         info[inlay-hint-location]: Inlay Hint Target
          --> main.py:2:9
           |
@@ -4170,6 +4298,22 @@ mod tests {
         12 | foo([x=]val.y())
            |      ^
            |
+
+        ---------------------------------------------
+        info[inlay-hint-edit]: File after edits
+        info: Source
+
+        def foo(x: int): pass
+        class MyClass:
+            def __init__(self):
+            def x() -> int:
+                return 1
+            def y() -> int:
+                return 2
+        val: MyClass = MyClass()
+
+        foo(val.x())
+        foo(val.y())
         ");
     }
 
@@ -4202,11 +4346,31 @@ mod tests {
                 return 1
             def y() -> List[int]:
                 return 2
-        val = MyClass()
+        val[: MyClass] = MyClass()
 
         foo(val.x()[0])
         foo([x=]val.y()[1])
         ---------------------------------------------
+        info[inlay-hint-location]: Inlay Hint Target
+         --> main.py:5:7
+          |
+        4 | def foo(x: int): pass
+        5 | class MyClass:
+          |       ^^^^^^^
+        6 |     def __init__(self):
+        7 |     def x() -> List[int]:
+          |
+        info: Source
+          --> main2.py:11:7
+           |
+         9 |     def y() -> List[int]:
+        10 |         return 2
+        11 | val[: MyClass] = MyClass()
+           |       ^^^^^^^
+        12 |
+        13 | foo(val.x()[0])
+           |
+
         info[inlay-hint-location]: Inlay Hint Target
          --> main.py:4:9
           |
@@ -4224,6 +4388,24 @@ mod tests {
         14 | foo([x=]val.y()[1])
            |      ^
            |
+
+        ---------------------------------------------
+        info[inlay-hint-edit]: File after edits
+        info: Source
+
+        from typing import List
+
+        def foo(x: int): pass
+        class MyClass:
+            def __init__(self):
+            def x() -> List[int]:
+                return 1
+            def y() -> List[int]:
+                return 2
+        val: MyClass = MyClass()
+
+        foo(val.x()[0])
+        foo(val.y()[1])
         ");
     }
 
@@ -4515,7 +4697,7 @@ mod tests {
         class Foo:
             def __init__(self, x: int): pass
         Foo([x=]1)
-        f = Foo([x=]1)
+        f[: Foo] = Foo([x=]1)
         ---------------------------------------------
         info[inlay-hint-location]: Inlay Hint Target
          --> main.py:3:24
@@ -4533,7 +4715,24 @@ mod tests {
         3 |     def __init__(self, x: int): pass
         4 | Foo([x=]1)
           |      ^
-        5 | f = Foo([x=]1)
+        5 | f[: Foo] = Foo([x=]1)
+          |
+
+        info[inlay-hint-location]: Inlay Hint Target
+         --> main.py:2:7
+          |
+        2 | class Foo:
+          |       ^^^
+        3 |     def __init__(self, x: int): pass
+        4 | Foo(1)
+          |
+        info: Source
+         --> main2.py:5:5
+          |
+        3 |     def __init__(self, x: int): pass
+        4 | Foo([x=]1)
+        5 | f[: Foo] = Foo([x=]1)
+          |     ^^^
           |
 
         info[inlay-hint-location]: Inlay Hint Target
@@ -4546,13 +4745,22 @@ mod tests {
         5 | f = Foo(1)
           |
         info: Source
-         --> main2.py:5:10
+         --> main2.py:5:17
           |
         3 |     def __init__(self, x: int): pass
         4 | Foo([x=]1)
-        5 | f = Foo([x=]1)
-          |          ^
+        5 | f[: Foo] = Foo([x=]1)
+          |                 ^
           |
+
+        ---------------------------------------------
+        info[inlay-hint-edit]: File after edits
+        info: Source
+
+        class Foo:
+            def __init__(self, x: int): pass
+        Foo(1)
+        f: Foo = Foo(1)
         ");
     }
 
@@ -4570,7 +4778,7 @@ mod tests {
         class Foo:
             def __new__(cls, x: int): pass
         Foo([x=]1)
-        f = Foo([x=]1)
+        f[: Foo] = Foo([x=]1)
         ---------------------------------------------
         info[inlay-hint-location]: Inlay Hint Target
          --> main.py:3:22
@@ -4588,7 +4796,24 @@ mod tests {
         3 |     def __new__(cls, x: int): pass
         4 | Foo([x=]1)
           |      ^
-        5 | f = Foo([x=]1)
+        5 | f[: Foo] = Foo([x=]1)
+          |
+
+        info[inlay-hint-location]: Inlay Hint Target
+         --> main.py:2:7
+          |
+        2 | class Foo:
+          |       ^^^
+        3 |     def __new__(cls, x: int): pass
+        4 | Foo(1)
+          |
+        info: Source
+         --> main2.py:5:5
+          |
+        3 |     def __new__(cls, x: int): pass
+        4 | Foo([x=]1)
+        5 | f[: Foo] = Foo([x=]1)
+          |     ^^^
           |
 
         info[inlay-hint-location]: Inlay Hint Target
@@ -4601,13 +4826,22 @@ mod tests {
         5 | f = Foo(1)
           |
         info: Source
-         --> main2.py:5:10
+         --> main2.py:5:17
           |
         3 |     def __new__(cls, x: int): pass
         4 | Foo([x=]1)
-        5 | f = Foo([x=]1)
-          |          ^
+        5 | f[: Foo] = Foo([x=]1)
+          |                 ^
           |
+
+        ---------------------------------------------
+        info[inlay-hint-edit]: File after edits
+        info: Source
+
+        class Foo:
+            def __new__(cls, x: int): pass
+        Foo(1)
+        f: Foo = Foo(1)
         ");
     }
 
@@ -6194,11 +6428,11 @@ mod tests {
                         a = Literal['a', 'b', 'c']",
         );
 
-        assert_snapshot!(test.inlay_hints(), @r#"
+        assert_snapshot!(test.inlay_hints(), @r"
         from typing import Literal
 
-        a[: <special form 'Literal["a", "b", "c"]'>] = Literal['a', 'b', 'c']
-        "#);
+        a[: <typing.Literal special form>] = Literal['a', 'b', 'c']
+        ");
     }
 
     struct InlayHintLocationDiagnostic {

crates/ty_ide/src/references.rs

@@ -37,38 +37,6 @@ pub enum ReferencesMode {
     DocumentHighlights,
 }
 
-impl ReferencesMode {
-    pub(super) fn to_import_alias_resolution(self) -> ImportAliasResolution {
-        match self {
-            // Resolve import aliases for find references:
-            // ```py
-            // from warnings import deprecated as my_deprecated
-            //
-            // @my_deprecated
-            // def foo
-            // ```
-            //
-            // When finding references on `my_deprecated`, we want to find all usages of `deprecated` across the entire
-            // project.
-            Self::References | Self::ReferencesSkipDeclaration => {
-                ImportAliasResolution::ResolveAliases
-            }
-            // For rename, don't resolve import aliases.
-            //
-            // ```py
-            // from warnings import deprecated as my_deprecated
-            //
-            // @my_deprecated
-            // def foo
-            // ```
-            // When renaming `my_deprecated`, only rename the alias, but not the original definition in `warnings`.
-            Self::Rename | Self::RenameMultiFile | Self::DocumentHighlights => {
-                ImportAliasResolution::PreserveAliases
-            }
-        }
-    }
-}
-
 /// Find all references to a symbol at the given position.
 /// Search for references across all files in the project.
 pub(crate) fn references(
@@ -77,9 +45,12 @@ pub(crate) fn references(
     goto_target: &GotoTarget,
     mode: ReferencesMode,
 ) -> Option<Vec<ReferenceTarget>> {
+    // Get the definitions for the symbol at the cursor position
+
+    // When finding references, do not resolve any local aliases.
     let model = SemanticModel::new(db, file);
     let target_definitions = goto_target
-        .get_definition_targets(&model, mode.to_import_alias_resolution())?
+        .get_definition_targets(&model, ImportAliasResolution::PreserveAliases)?
         .declaration_targets(db)?;
 
     // Extract the target text from the goto target for fast comparison
@@ -347,7 +318,7 @@ impl LocalReferencesFinder<'_> {
         {
             // Get the definitions for this goto target
             if let Some(current_definitions) = goto_target
-                .get_definition_targets(self.model, self.mode.to_import_alias_resolution())
+                .get_definition_targets(self.model, ImportAliasResolution::PreserveAliases)
                 .and_then(|definitions| definitions.declaration_targets(self.model.db()))
             {
                 // Check if any of the current definitions match our target definitions

crates/ty_ide/src/semantic_tokens.rs

@@ -259,11 +259,7 @@ impl<'db> SemanticTokenVisitor<'db> {
 
     fn classify_name(&self, name: &ast::ExprName) -> (SemanticTokenType, SemanticTokenModifier) {
         // First try to classify the token based on its definition kind.
-        let definition = definition_for_name(
-            self.model,
-            name,
-            ty_python_semantic::ImportAliasResolution::ResolveAliases,
-        );
+        let definition = definition_for_name(self.model, name);
 
         if let Some(definition) = definition {
             let name_str = name.id.as_str();

crates/ty_ide/src/signature_help.rs

@@ -20,7 +20,6 @@ use ty_python_semantic::semantic_index::definition::Definition;
 use ty_python_semantic::types::ide_support::{
     CallSignatureDetails, call_signature_details, find_active_signature_from_details,
 };
-use ty_python_semantic::types::{ParameterKind, Type};
 
 // TODO: We may want to add special-case handling for calls to constructors
 // so the class docstring is used in place of (or inaddition to) any docstring
@@ -28,29 +27,25 @@ use ty_python_semantic::types::{ParameterKind, Type};
 
 /// Information about a function parameter
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ParameterDetails<'db> {
+pub struct ParameterDetails {
     /// The parameter name (e.g., "param1")
     pub name: String,
     /// The parameter label in the signature (e.g., "param1: str")
     pub label: String,
-    /// The annotated type of the parameter, if any
-    pub ty: Option<Type<'db>>,
     /// Documentation specific to the parameter, typically extracted from the
     /// function's docstring
     pub documentation: Option<String>,
-    /// True if the parameter is positional-only.
-    pub is_positional_only: bool,
 }
 
 /// Information about a function signature
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SignatureDetails<'db> {
+pub struct SignatureDetails {
     /// Text representation of the full signature (including input parameters and return type).
     pub label: String,
     /// Documentation for the signature, typically from the function's docstring.
     pub documentation: Option<Docstring>,
     /// Information about each of the parameters in left-to-right order.
-    pub parameters: Vec<ParameterDetails<'db>>,
+    pub parameters: Vec<ParameterDetails>,
     /// Index of the parameter that corresponds to the argument where the
     /// user's cursor is currently positioned.
     pub active_parameter: Option<usize>,
@@ -58,18 +53,18 @@ pub struct SignatureDetails<'db> {
 
 /// Signature help information for function calls
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SignatureHelpInfo<'db> {
+pub struct SignatureHelpInfo {
     /// Information about each of the signatures for the function call. We
     /// need to handle multiple because of unions, overloads, and composite
     /// calls like constructors (which invoke both __new__ and __init__).
-    pub signatures: Vec<SignatureDetails<'db>>,
+    pub signatures: Vec<SignatureDetails>,
     /// Index of the "active signature" which is the first signature where
     /// all arguments that are currently present in the code map to parameters.
     pub active_signature: Option<usize>,
 }
 
 /// Signature help information for function calls at the given position
-pub fn signature_help(db: &dyn Db, file: File, offset: TextSize) -> Option<SignatureHelpInfo<'_>> {
+pub fn signature_help(db: &dyn Db, file: File, offset: TextSize) -> Option<SignatureHelpInfo> {
     let parsed = parsed_module(db, file).load(db);
 
     // Get the call expression at the given position.
@@ -171,11 +166,11 @@ fn get_argument_index(call_expr: &ast::ExprCall, offset: TextSize) -> usize {
 }
 
 /// Create signature details from `CallSignatureDetails`.
-fn create_signature_details_from_call_signature_details<'db>(
+fn create_signature_details_from_call_signature_details(
     db: &dyn crate::Db,
-    details: &CallSignatureDetails<'db>,
+    details: &CallSignatureDetails,
     current_arg_index: usize,
-) -> SignatureDetails<'db> {
+) -> SignatureDetails {
     let signature_label = details.label.clone();
 
     let documentation = get_callable_documentation(db, details.definition);
@@ -205,8 +200,6 @@ fn create_signature_details_from_call_signature_details<'db>(
         &signature_label,
         documentation.as_ref(),
         &details.parameter_names,
-        &details.parameter_kinds,
-        &details.parameter_types,
     );
     SignatureDetails {
         label: signature_label,
@@ -225,14 +218,12 @@ fn get_callable_documentation(
 }
 
 /// Create `ParameterDetails` objects from parameter label offsets.
-fn create_parameters_from_offsets<'db>(
+fn create_parameters_from_offsets(
     parameter_offsets: &[TextRange],
     signature_label: &str,
     docstring: Option<&Docstring>,
     parameter_names: &[String],
-    parameter_kinds: &[ParameterKind],
-    parameter_types: &[Option<Type<'db>>],
-) -> Vec<ParameterDetails<'db>> {
+) -> Vec<ParameterDetails> {
     // Extract parameter documentation from the function's docstring if available.
     let param_docs = if let Some(docstring) = docstring {
         docstring.parameter_documentation()
@@ -254,18 +245,11 @@ fn create_parameters_from_offsets<'db>(
 
             // Get the parameter name for documentation lookup.
             let param_name = parameter_names.get(i).map(String::as_str).unwrap_or("");
-            let is_positional_only = matches!(
-                parameter_kinds.get(i),
-                Some(ParameterKind::PositionalOnly { .. })
-            );
-            let ty = parameter_types.get(i).copied().flatten();
 
             ParameterDetails {
                 name: param_name.to_string(),
                 label,
-                ty,
                 documentation: param_docs.get(param_name).cloned(),
-                is_positional_only,
             }
         })
         .collect()
@@ -1189,7 +1173,7 @@ def ab(a: int, *, c: int):
     }
 
     impl CursorTest {
-        fn signature_help(&self) -> Option<SignatureHelpInfo<'_>> {
+        fn signature_help(&self) -> Option<SignatureHelpInfo> {
             crate::signature_help::signature_help(&self.db, self.cursor.file, self.cursor.offset)
         }
 

crates/ty_python_semantic/mdtest.py

@@ -37,16 +37,14 @@ class MDTestRunner:
     mdtest_executable: Path | None
     console: Console
     filters: list[str]
-    enable_external: bool
 
-    def __init__(self, filters: list[str] | None, enable_external: bool) -> None:
+    def __init__(self, filters: list[str] | None = None) -> None:
         self.mdtest_executable = None
         self.console = Console()
         self.filters = [
             f.removesuffix(".md").replace("/", "_").replace("-", "_")
             for f in (filters or [])
         ]
-        self.enable_external = enable_external
 
     def _run_cargo_test(self, *, message_format: Literal["human", "json"]) -> str:
         return subprocess.check_output(
@@ -122,7 +120,6 @@ class MDTestRunner:
                 CLICOLOR_FORCE="1",
                 INSTA_FORCE_PASS="1",
                 INSTA_OUTPUT="none",
-                MDTEST_EXTERNAL="1" if self.enable_external else "0",
             ),
             capture_output=capture_output,
             text=True,
@@ -269,19 +266,11 @@ def main() -> None:
         nargs="*",
         help="Partial paths or mangled names, e.g., 'loops/for.md' or 'loops_for'",
     )
-    parser.add_argument(
-        "--enable-external",
-        "-e",
-        action="store_true",
-        help="Enable tests with external dependencies",
-    )
 
     args = parser.parse_args()
 
     try:
-        runner = MDTestRunner(
-            filters=args.filters, enable_external=args.enable_external
-        )
+        runner = MDTestRunner(filters=args.filters)
         runner.watch()
     except KeyboardInterrupt:
         print()

crates/ty_python_semantic/resources/corpus/cyclic_pep695_variance.py

@@ -1,14 +0,0 @@
-from typing import Protocol
-
-class A(Protocol):
-    @property
-    def f(self): ...
-
-type Recursive = int | tuple[Recursive, ...]
-
-class B[T: A]: ...
-
-class C[T: A](A):
-    x: tuple[Recursive, ...]
-
-class D(B[C]): ...

crates/ty_python_semantic/resources/corpus/future_annotations_recursive_annotation.py

@@ -1,4 +0,0 @@
-from __future__ import annotations
-
-class MyClass:
-    type: type = str

crates/ty_python_semantic/resources/corpus/inner_expression_inference_state.py

@@ -1,6 +0,0 @@
-# This is a regression test for `store_expression_type`.
-# ref: https://github.com/astral-sh/ty/issues/1688
-
-x: int
-
-type x[T] = x[T, U]

crates/ty_python_semantic/resources/corpus/invalid_typevar_constraints.py

@@ -1,6 +0,0 @@
-class C[T: (A, B)]:
-    def f(foo: T):
-        try:
-            pass
-        except foo:
-            pass

crates/ty_python_semantic/resources/mdtest/annotations/any.md

@@ -169,13 +169,13 @@ def f(x: Any[int]):
 `Any` cannot be called (this leads to a `TypeError` at runtime):
 
 ```py
-Any()  # error: [call-non-callable] "Object of type `<special form 'typing.Any'>` is not callable"
+Any()  # error: [call-non-callable] "Object of type `typing.Any` is not callable"
 ```
 
 `Any` also cannot be used as a metaclass (under the hood, this leads to an implicit call to `Any`):
 
 ```py
-class F(metaclass=Any): ...  # error: [invalid-metaclass] "Metaclass type `<special form 'typing.Any'>` is not callable"
+class F(metaclass=Any): ...  # error: [invalid-metaclass] "Metaclass type `typing.Any` is not callable"
 ```
 
 And `Any` cannot be used in `isinstance()` checks:

crates/ty_python_semantic/resources/mdtest/annotations/callable.md

@@ -307,10 +307,12 @@ Using a `ParamSpec` in a `Callable` annotation:
 from typing_extensions import Callable
 
 def _[**P1](c: Callable[P1, int]):
-    reveal_type(P1.args)  # revealed: P1@_.args
-    reveal_type(P1.kwargs)  # revealed: P1@_.kwargs
+    # TODO: Should reveal `ParamSpecArgs` and `ParamSpecKwargs`
+    reveal_type(P1.args)  # revealed: @Todo(ParamSpecArgs / ParamSpecKwargs)
+    reveal_type(P1.kwargs)  # revealed: @Todo(ParamSpecArgs / ParamSpecKwargs)
 
-    reveal_type(c)  # revealed: (**P1@_) -> int
+    # TODO: Signature should be (**P1) -> int
+    reveal_type(c)  # revealed: (...) -> int
 ```
 
 And, using the legacy syntax:
@@ -320,8 +322,9 @@ from typing_extensions import ParamSpec
 
 P2 = ParamSpec("P2")
 
+# TODO: argument list should not be `...` (requires `ParamSpec` support)
 def _(c: Callable[P2, int]):
-    reveal_type(c)  # revealed: (**P2@_) -> int
+    reveal_type(c)  # revealed: (...) -> int
 ```
 
 ## Using `typing.Unpack`

crates/ty_python_semantic/resources/mdtest/annotations/never.md

@@ -59,7 +59,7 @@ python-version = "3.11"
 ```py
 from typing import Never
 
-reveal_type(Never)  # revealed: <special form 'typing.Never'>
+reveal_type(Never)  # revealed: typing.Never
 ```
 
 ### Python 3.10

crates/ty_python_semantic/resources/mdtest/annotations/unsupported_special_forms.md

@@ -18,8 +18,9 @@ def f(*args: Unpack[Ts]) -> tuple[Unpack[Ts]]:
 
 def g() -> TypeGuard[int]: ...
 def i(callback: Callable[Concatenate[int, P], R_co], *args: P.args, **kwargs: P.kwargs) -> R_co:
-    reveal_type(args)  # revealed: P@i.args
-    reveal_type(kwargs)  # revealed: P@i.kwargs
+    # TODO: Should reveal a type representing `P.args` and `P.kwargs`
+    reveal_type(args)  # revealed: tuple[@Todo(ParamSpecArgs / ParamSpecKwargs), ...]
+    reveal_type(kwargs)  # revealed: dict[str, @Todo(ParamSpecArgs / ParamSpecKwargs)]
     return callback(42, *args, **kwargs)
 
 class Foo:
@@ -64,9 +65,8 @@ def _(
     reveal_type(c)  # revealed: Unknown
     reveal_type(d)  # revealed: Unknown
 
-    # error: [invalid-type-form] "Variable of type `ParamSpec` is not allowed in a type expression"
     def foo(a_: e) -> None:
-        reveal_type(a_)  # revealed: Unknown
+        reveal_type(a_)  # revealed: @Todo(Support for `typing.ParamSpec`)
 ```
 
 ## Inheritance

crates/ty_python_semantic/resources/mdtest/async.md

@@ -43,9 +43,7 @@ async def main():
     loop = asyncio.get_event_loop()
     with concurrent.futures.ThreadPoolExecutor() as pool:
         result = await loop.run_in_executor(pool, blocking_function)
-
-        # TODO: should be `int`
-        reveal_type(result)  # revealed: Unknown
+        reveal_type(result)  # revealed: int
 ```
 
 ### `asyncio.Task`

crates/ty_python_semantic/resources/mdtest/binary/classes.md

@@ -13,7 +13,7 @@ python-version = "3.10"
 class A: ...
 class B: ...
 
-reveal_type(A | B)  # revealed: <types.UnionType special form 'A | B'>
+reveal_type(A | B)  # revealed: types.UnionType
 ```
 
 ## Union of two classes (prior to 3.10)
@@ -43,14 +43,14 @@ class A: ...
 class B: ...
 
 def _(sub_a: type[A], sub_b: type[B]):
-    reveal_type(A | sub_b)  # revealed: <types.UnionType special form>
-    reveal_type(sub_a | B)  # revealed: <types.UnionType special form>
-    reveal_type(sub_a | sub_b)  # revealed: <types.UnionType special form>
+    reveal_type(A | sub_b)  # revealed: types.UnionType
+    reveal_type(sub_a | B)  # revealed: types.UnionType
+    reveal_type(sub_a | sub_b)  # revealed: types.UnionType
 
 class C[T]: ...
 class D[T]: ...
 
-reveal_type(C | D)  # revealed: <types.UnionType special form 'C[Unknown] | D[Unknown]'>
+reveal_type(C | D)  # revealed: types.UnionType
 
-reveal_type(C[int] | D[str])  # revealed: <types.UnionType special form 'C[int] | D[str]'>
+reveal_type(C[int] | D[str])  # revealed: types.UnionType
 ```

crates/ty_python_semantic/resources/mdtest/call/union.md

@@ -227,56 +227,17 @@ def _(literals_2: Literal[0, 1], b: bool, flag: bool):
     literals_16 = 4 * literals_4 + literals_4  # Literal[0, 1, .., 15]
     literals_64 = 4 * literals_16 + literals_4  # Literal[0, 1, .., 63]
     literals_128 = 2 * literals_64 + literals_2  # Literal[0, 1, .., 127]
-    literals_256 = 2 * literals_128 + literals_2  # Literal[0, 1, .., 255]
 
-    # Going beyond the MAX_NON_RECURSIVE_UNION_LITERALS limit (currently 256):
-    reveal_type(literals_256 if flag else 256)  # revealed: int
+    # Going beyond the MAX_UNION_LITERALS limit (currently 200):
+    literals_256 = 16 * literals_16 + literals_16
+    reveal_type(literals_256)  # revealed: int
 
     # Going beyond the limit when another type is already part of the union
     bool_and_literals_128 = b if flag else literals_128  # bool | Literal[0, 1, ..., 127]
     literals_128_shifted = literals_128 + 128  # Literal[128, 129, ..., 255]
-    literals_256_shifted = literals_256 + 256  # Literal[256, 257, ..., 511]
 
     # Now union the two:
-    two = bool_and_literals_128 if flag else literals_128_shifted
-    # revealed: bool | Literal[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255]
-    reveal_type(two)
-    reveal_type(two if flag else literals_256_shifted)  # revealed: int
-```
-
-Recursively defined literal union types are widened earlier than non-recursively defined types for
-faster convergence.
-
-```py
-class RecursiveAttr:
-    def __init__(self):
-        self.i = 0
-
-    def update(self):
-        self.i = self.i + 1
-
-reveal_type(RecursiveAttr().i)  # revealed: Unknown | int
-
-# Here are some recursive but saturating examples. Because it's difficult to statically determine whether literal unions saturate or diverge,
-# we widen them early, even though they may actually be convergent.
-class RecursiveAttr2:
-    def __init__(self):
-        self.i = 0
-
-    def update(self):
-        self.i = (self.i + 1) % 9
-
-reveal_type(RecursiveAttr2().i)  # revealed: Unknown | Literal[0, 1, 2, 3, 4, 5, 6, 7, 8]
-
-class RecursiveAttr3:
-    def __init__(self):
-        self.i = 0
-
-    def update(self):
-        self.i = (self.i + 1) % 10
-
-# Going beyond the MAX_RECURSIVE_UNION_LITERALS limit:
-reveal_type(RecursiveAttr3().i)  # revealed: Unknown | int
+    reveal_type(bool_and_literals_128 if flag else literals_128_shifted)  # revealed: int
 ```
 
 ## Simplifying gradually-equivalent types

crates/ty_python_semantic/resources/mdtest/class/super.md

@@ -603,14 +603,12 @@ super(object, object()).__class__
 # Not all objects valid in a class's bases list are valid as the first argument to `super()`.
 # For example, it's valid to inherit from `typing.ChainMap`, but it's not valid as the first argument to `super()`.
 #
-# error: [invalid-super-argument] "`<special form 'typing.ChainMap'>` is not a valid class"
+# error: [invalid-super-argument] "`typing.ChainMap` is not a valid class"
 reveal_type(super(typing.ChainMap, collections.ChainMap()))  # revealed: Unknown
 
 # Meanwhile, it's not valid to inherit from unsubscripted `typing.Generic`,
 # but it *is* valid as the first argument to `super()`.
-#
-# revealed: <super: <special form 'typing.Generic'>, <class 'SupportsInt'>>
-reveal_type(super(typing.Generic, typing.SupportsInt))
+reveal_type(super(typing.Generic, typing.SupportsInt))  # revealed: <super: typing.Generic, <class 'SupportsInt'>>
 
 def _(x: type[typing.Any], y: typing.Any):
     reveal_type(super(x, y))  # revealed: <super: Any, Any>

crates/ty_python_semantic/resources/mdtest/dataclasses/fields.md

@@ -82,8 +82,7 @@ def get_default() -> str:
 
 reveal_type(field(default=1))  # revealed: dataclasses.Field[Literal[1]]
 reveal_type(field(default=None))  # revealed: dataclasses.Field[None]
-# TODO: this could ideally be `dataclasses.Field[str]` with a better generics solver
-reveal_type(field(default_factory=get_default))  # revealed: dataclasses.Field[Unknown]
+reveal_type(field(default_factory=get_default))  # revealed: dataclasses.Field[str]
 ```
 
 ## dataclass_transform field_specifiers

crates/ty_python_semantic/resources/mdtest/decorators.md

@@ -144,11 +144,12 @@ from functools import cache
 def f(x: int) -> int:
     return x**2
 
-# TODO: Should be `_lru_cache_wrapper[int]`
-reveal_type(f)  # revealed: _lru_cache_wrapper[Unknown]
-
-# TODO: Should be `int`
-reveal_type(f(1))  # revealed: Unknown
+# TODO: revealed: _lru_cache_wrapper[int]
+# revealed: _lru_cache_wrapper[int] | _lru_cache_wrapper[Unknown]
+reveal_type(f)
+# TODO: revealed: int
+# revealed: int | Unknown
+reveal_type(f(1))
 ```
 
 ## Lambdas as decorators

crates/ty_python_semantic/resources/mdtest/deprecated.md

@@ -11,9 +11,9 @@ classes. Uses of these items should subsequently produce a warning.
 from typing_extensions import deprecated
 
 @deprecated("use OtherClass")
-def myfunc(): ...
+def myfunc(x: int): ...
 
-myfunc()  # error: [deprecated] "use OtherClass"
+myfunc(1)  # error: [deprecated] "use OtherClass"
 ```
 
 ```py

crates/ty_python_semantic/resources/mdtest/diagnostics/special_form_attributes.md

@@ -1,26 +0,0 @@
-# Diagnostics for invalid attribute access on special forms
-
-<!-- snapshot-diagnostics -->
-
-```py
-from typing_extensions import Any, Final, LiteralString, Self
-
-X = Any
-
-class Foo:
-    X: Final = LiteralString
-    a: int
-    b: Self
-
-    class Bar:
-        def __init__(self):
-            self.y: Final = LiteralString
-
-X.foo  # error: [unresolved-attribute]
-X.aaaaooooooo  # error: [unresolved-attribute]
-Foo.X.startswith  # error: [unresolved-attribute]
-Foo.Bar().y.startswith  # error: [unresolved-attribute]
-
-# TODO: false positive (just testing the diagnostic in the meantime)
-Foo().b.a  # error: [unresolved-attribute]
-```

crates/ty_python_semantic/resources/mdtest/directives/assert_type.md

@@ -7,11 +7,10 @@
 ```py
 from typing_extensions import assert_type
 
-def _(x: int, y: bool):
+def _(x: int):
     assert_type(x, int)  # fine
     assert_type(x, str)  # error: [type-assertion-failure]
     assert_type(assert_type(x, int), int)
-    assert_type(y, int)  # error: [type-assertion-failure]
 ```
 
 ## Narrowing

crates/ty_python_semantic/resources/mdtest/external/README.md

@@ -1,4 +0,0 @@
-# mdtests with external dependencies
-
-This directory contains mdtests that make use of external packages. See the mdtest `README.md` for
-more information.

crates/ty_python_semantic/resources/mdtest/external/attrs.md

@@ -1,78 +0,0 @@
-# attrs
-
-```toml
-[environment]
-python-version = "3.13"
-python-platform = "linux"
-
-[project]
-dependencies = ["attrs==25.4.0"]
-```
-
-## Basic class (`attr`)
-
-```py
-import attr
-
-@attr.s
-class User:
-    id: int = attr.ib()
-    name: str = attr.ib()
-
-user = User(id=1, name="John Doe")
-
-reveal_type(user.id)  # revealed: int
-reveal_type(user.name)  # revealed: str
-```
-
-## Basic class (`define`)
-
-```py
-from attrs import define, field
-
-@define
-class User:
-    id: int = field()
-    internal_name: str = field(alias="name")
-
-user = User(id=1, name="John Doe")
-reveal_type(user.id)  # revealed: int
-reveal_type(user.internal_name)  # revealed: str
-```
-
-## Usage of `field` parameters
-
-```py
-from attrs import define, field
-
-@define
-class Product:
-    id: int = field(init=False)
-    name: str = field()
-    price_cent: int = field(kw_only=True)
-
-reveal_type(Product.__init__)  # revealed: (self: Product, name: str, *, price_cent: int) -> None
-```
-
-## Dedicated support for the `default` decorator?
-
-We currently do not support this:
-
-```py
-from attrs import define, field
-
-@define
-class Person:
-    id: int = field()
-    name: str = field()
-
-    # error: [call-non-callable] "Object of type `_MISSING_TYPE` is not callable"
-    @id.default
-    def _default_id(self) -> int:
-        raise NotImplementedError
-
-# error: [missing-argument] "No argument provided for required parameter `id`"
-person = Person(name="Alice")
-reveal_type(person.id)  # revealed: int
-reveal_type(person.name)  # revealed: str
-```

crates/ty_python_semantic/resources/mdtest/external/numpy.md

@@ -1,23 +0,0 @@
-# numpy
-
-```toml
-[environment]
-python-version = "3.13"
-python-platform = "linux"
-
-[project]
-dependencies = ["numpy==2.3.0"]
-```
-
-## Basic usage
-
-```py
-import numpy as np
-
-xs = np.array([1, 2, 3])
-reveal_type(xs)  # revealed: ndarray[tuple[Any, ...], dtype[Any]]
-
-xs = np.array([1.0, 2.0, 3.0], dtype=np.float64)
-# TODO: should be `ndarray[tuple[Any, ...], dtype[float64]]`
-reveal_type(xs)  # revealed: ndarray[tuple[Any, ...], dtype[Unknown]]
-```

crates/ty_python_semantic/resources/mdtest/external/pydantic.md

@@ -1,48 +0,0 @@
-# Pydantic
-
-```toml
-[environment]
-python-version = "3.12"
-python-platform = "linux"
-
-[project]
-dependencies = ["pydantic==2.12.2"]
-```
-
-## Basic model
-
-```py
-from pydantic import BaseModel
-
-class User(BaseModel):
-    id: int
-    name: str
-
-reveal_type(User.__init__)  # revealed: (self: User, *, id: int, name: str) -> None
-
-user = User(id=1, name="John Doe")
-reveal_type(user.id)  # revealed: int
-reveal_type(user.name)  # revealed: str
-
-# error: [missing-argument] "No argument provided for required parameter `name`"
-invalid_user = User(id=2)
-```
-
-## Usage of `Field`
-
-```py
-from pydantic import BaseModel, Field
-
-class Product(BaseModel):
-    id: int = Field(init=False)
-    name: str = Field(..., kw_only=False, min_length=1)
-    internal_price_cent: int = Field(..., gt=0, alias="price_cent")
-
-reveal_type(Product.__init__)  # revealed: (self: Product, name: str = Any, *, price_cent: int = Any) -> None
-
-product = Product("Laptop", price_cent=999_00)
-
-reveal_type(product.id)  # revealed: int
-reveal_type(product.name)  # revealed: str
-reveal_type(product.internal_price_cent)  # revealed: int
-```

crates/ty_python_semantic/resources/mdtest/external/pytest.md

@@ -1,27 +0,0 @@
-# pytest
-
-```toml
-[environment]
-python-version = "3.13"
-python-platform = "linux"
-
-[project]
-dependencies = ["pytest==9.0.1"]
-```
-
-## `pytest.fail`
-
-Make sure that we recognize `pytest.fail` calls as terminal:
-
-```py
-import pytest
-
-def some_runtime_condition() -> bool:
-    return True
-
-def test_something():
-    if not some_runtime_condition():
-        pytest.fail("Runtime condition failed")
-
-        no_error_here_this_is_unreachable
-```