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_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/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/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/linter.rs

@@ -1043,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/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__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/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_python_ast/src/script.rs

@@ -12,11 +12,11 @@ static FINDER: LazyLock<Finder> = LazyLock::new(|| Finder::new(b"# /// script"))
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct ScriptTag {
     /// The content of the script before the metadata block.
-    pub prelude: String,
+    prelude: String,
     /// The metadata block.
-    pub metadata: String,
+    metadata: String,
     /// The content of the script after the metadata block.
-    pub postlude: String,
+    postlude: String,
 }
 
 impl ScriptTag {

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_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/ty/src/lib.rs

@@ -90,22 +90,6 @@ fn run_check(args: CheckCommand) -> anyhow::Result<ExitStatus> {
             })?
     };
 
-    let system = OsSystem::new(&cwd);
-
-    // If we see a single path, check if it's a PEP-723 script
-    let mut script_project = None;
-    if let [path] = &*args.paths {
-        match ProjectMetadata::discover_script(path, &system) {
-            Ok(project) => {
-                script_project = Some(project);
-            }
-            Err(ty_project::ProjectMetadataError::NotAScript(_)) => {
-                // This is fine
-            }
-            Err(e) => tracing::info!("Issue reading script at `{path}`: {e}"),
-        }
-    }
-
     let project_path = args
         .project
         .as_ref()
@@ -127,6 +111,7 @@ fn run_check(args: CheckCommand) -> anyhow::Result<ExitStatus> {
         .map(|path| SystemPath::absolute(path, &cwd))
         .collect();
 
+    let system = OsSystem::new(&cwd);
     let watch = args.watch;
     let exit_zero = args.exit_zero;
     let config_file = args
@@ -136,13 +121,7 @@ fn run_check(args: CheckCommand) -> anyhow::Result<ExitStatus> {
 
     let mut project_metadata = match &config_file {
         Some(config_file) => ProjectMetadata::from_config_file(config_file.clone(), &system)?,
-        None => {
-            if let Some(project) = script_project {
-                project
-            } else {
-                ProjectMetadata::discover(&project_path, &system)?
-            }
-        }
+        None => ProjectMetadata::discover(&project_path, &system)?,
     };
 
     project_metadata.apply_configuration_files(&system)?;

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/completion.rs

@@ -74,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?,
                 })
             })
@@ -160,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.
     ///
@@ -229,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,
@@ -311,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),
@@ -327,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),
@@ -544,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
@@ -568,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
@@ -4368,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
         ");
     }
@@ -5552,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
         ");
     }
@@ -5822,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]
@@ -5830,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]
@@ -5841,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
         ");
     }
 
@@ -5855,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
         ");
@@ -5867,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
         ");
     }
 
@@ -5880,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.
     ///
@@ -6332,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_project/Cargo.toml

@@ -41,7 +41,7 @@ rustc-hash = { workspace = true }
 salsa = { workspace = true }
 schemars = { workspace = true, optional = true }
 serde = { workspace = true }
-serde_json = { workspace = true }
+serde_json = { workspace = true, optional = true }
 thiserror = { workspace = true }
 toml = { workspace = true }
 tracing = { workspace = true }
@@ -55,6 +55,7 @@ default = ["zstd"]
 deflate = ["ty_vendored/deflate"]
 schemars = [
     "dep:schemars",
+    "dep:serde_json",
     "ruff_db/schemars",
     "ruff_python_ast/schemars",
     "ty_python_semantic/schemars",

crates/ty_project/src/metadata.rs

@@ -9,15 +9,13 @@ use ty_python_semantic::ProgramSettings;
 
 use crate::metadata::options::ProjectOptionsOverrides;
 use crate::metadata::pyproject::{Project, PyProject, PyProjectError, ResolveRequiresPythonError};
-use crate::metadata::script::{Pep723Error, Pep723Metadata};
-use crate::metadata::value::{RelativePathBuf, ValueSource};
+use crate::metadata::value::ValueSource;
 pub use options::Options;
 use options::TyTomlError;
 
 mod configuration_file;
 pub mod options;
 pub mod pyproject;
-pub mod script;
 pub mod settings;
 pub mod value;
 
@@ -87,32 +85,6 @@ impl ProjectMetadata {
         )
     }
 
-    /// Loads a project from a `pyproject.toml` file.
-    pub(crate) fn from_script(
-        script: Pep723Metadata,
-        script_path: &SystemPath,
-    ) -> Result<Self, ResolveRequiresPythonError> {
-        let project = Some(&script.to_project());
-        let parent_dir = script_path
-            .parent()
-            .map(ToOwned::to_owned)
-            .unwrap_or_default();
-        let mut metadata = Self::from_options(
-            script.tool.and_then(|tool| tool.ty).unwrap_or_default(),
-            parent_dir,
-            project,
-        )?;
-
-        // Try to get `uv sync --script` to setup the venv for us
-        if let Some(python) = script::uv_sync_script(script_path) {
-            let mut environment = metadata.options.environment.unwrap_or_default();
-            environment.python = Some(RelativePathBuf::new(python, ValueSource::Cli));
-            metadata.options.environment = Some(environment);
-        }
-
-        Ok(metadata)
-    }
-
     /// Loads a project from a set of options with an optional pyproject-project table.
     pub fn from_options(
         mut options: Options,
@@ -148,46 +120,6 @@ impl ProjectMetadata {
         })
     }
 
-    pub fn discover_script(
-        path: &SystemPath,
-        system: &dyn System,
-    ) -> Result<ProjectMetadata, ProjectMetadataError> {
-        tracing::debug!("Searching for a PEP-723 Script in '{path}'");
-        if !system.is_file(path) {
-            return Err(ProjectMetadataError::NotAScript(path.to_path_buf()));
-        }
-
-        let script_metadata = if let Ok(script_str) = system.read_to_string(path) {
-            match Pep723Metadata::from_script_str(
-                script_str.as_bytes(),
-                ValueSource::File(Arc::new(path.to_owned())),
-            ) {
-                Ok(Some(pyproject)) => Some(pyproject),
-                Ok(None) => None,
-                Err(error) => {
-                    return Err(ProjectMetadataError::InvalidScript {
-                        path: path.to_owned(),
-                        source: Box::new(error),
-                    });
-                }
-            }
-        } else {
-            None
-        };
-
-        let Some(script_metadata) = script_metadata else {
-            return Err(ProjectMetadataError::NotAScript(path.to_path_buf()));
-        };
-
-        let metadata = ProjectMetadata::from_script(script_metadata, path).map_err(|err| {
-            ProjectMetadataError::InvalidRequiresPythonConstraint {
-                source: err,
-                path: path.to_owned(),
-            }
-        })?;
-
-        Ok(metadata)
-    }
     /// Discovers the closest project at `path` and returns its metadata.
     ///
     /// The algorithm traverses upwards in the `path`'s ancestor chain and uses the following precedence
@@ -387,21 +319,12 @@ pub enum ProjectMetadataError {
     #[error("project path '{0}' is not a directory")]
     NotADirectory(SystemPathBuf),
 
-    #[error("project path '{0}' is not a PEP-723 script")]
-    NotAScript(SystemPathBuf),
-
     #[error("{path} is not a valid `pyproject.toml`: {source}")]
     InvalidPyProject {
         source: Box<PyProjectError>,
         path: SystemPathBuf,
     },
 
-    #[error("{path} is not a valid PEP-723 script: {source}")]
-    InvalidScript {
-        source: Box<Pep723Error>,
-        path: SystemPathBuf,
-    },
-
     #[error("{path} is not a valid `ty.toml`: {source}")]
     InvalidTyToml {
         source: Box<TyTomlError>,

crates/ty_project/src/metadata/script.rs

@@ -1,157 +0,0 @@
-use std::{io, process::Command, str::FromStr};
-
-use camino::Utf8PathBuf;
-use pep440_rs::VersionSpecifiers;
-use ruff_db::system::{SystemPath, SystemPathBuf};
-use ruff_python_ast::script::ScriptTag;
-use serde::Deserialize;
-use thiserror::Error;
-
-use crate::metadata::{
-    pyproject::{Project, Tool},
-    value::{RangedValue, ValueSource, ValueSourceGuard},
-};
-
-/// PEP 723 metadata as parsed from a `script` comment block.
-///
-/// See: <https://peps.python.org/pep-0723/>
-#[derive(Debug, Deserialize, Clone)]
-#[serde(rename_all = "kebab-case")]
-pub struct Pep723Metadata {
-    pub dependencies: Option<RangedValue<Vec<toml::Value>>>,
-    pub requires_python: Option<RangedValue<VersionSpecifiers>>,
-    pub tool: Option<Tool>,
-
-    /// The raw unserialized document.
-    #[serde(skip)]
-    pub raw: String,
-}
-
-#[derive(Debug, Error)]
-pub enum Pep723Error {
-    #[error(
-        "An opening tag (`# /// script`) was found without a closing tag (`# ///`). Ensure that every line between the opening and closing tags (including empty lines) starts with a leading `#`."
-    )]
-    UnclosedBlock,
-    #[error("The PEP 723 metadata block is missing from the script.")]
-    MissingTag,
-    #[error(transparent)]
-    Io(#[from] io::Error),
-    #[error(transparent)]
-    Utf8(#[from] std::str::Utf8Error),
-    #[error(transparent)]
-    Toml(#[from] toml::de::Error),
-    #[error("Invalid filename `{0}` supplied")]
-    InvalidFilename(String),
-}
-
-impl Pep723Metadata {
-    /// Parse the PEP 723 metadata from `stdin`.
-    pub fn from_script_str(
-        contents: &[u8],
-        source: ValueSource,
-    ) -> Result<Option<Self>, Pep723Error> {
-        let _guard = ValueSourceGuard::new(source, true);
-
-        // Extract the `script` tag.
-        let Some(ScriptTag { metadata, .. }) = ScriptTag::parse(contents) else {
-            return Ok(None);
-        };
-
-        // Parse the metadata.
-        Ok(Some(Self::from_str(&metadata)?))
-    }
-
-    pub fn to_project(&self) -> Project {
-        Project {
-            name: None,
-            version: None,
-            requires_python: self.requires_python.clone(),
-        }
-    }
-}
-
-/*
-{
-  "schema": {
-    "version": "preview"
-  },
-  "target": "script",
-  "script": {
-    "path": "/Users/myuser/code/myproj/scripts/load-test.py"
-  },
-  "sync": {
-    "environment": {
-      "path": "/Users/myuser/.cache/uv/environments-v2/load-test-d6edaf5bfab110a8",
-      "python": {
-        "path": "/Users/myuser/.cache/uv/environments-v2/load-test-d6edaf5bfab110a8/bin/python3",
-        "version": "3.14.0",
-        "implementation": "cpython"
-      }
-    },
-    "action": "check"
-  },
-  "lock": null,
-  "dry_run": false
-}
-*/
-
-/// The output of `uv sync --output-format=json --script ...`
-#[derive(Debug, Clone, Deserialize)]
-struct UvMetadata {
-    sync: Option<UvSync>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct UvSync {
-    environment: Option<UvEnvironment>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-struct UvEnvironment {
-    path: Option<String>,
-}
-
-/// Ask `uv` to sync the script's venv to some temp dir so we can analyze dependencies properly
-///
-/// Returns the path to the venv on success
-pub fn uv_sync_script(script_path: &SystemPath) -> Option<SystemPathBuf> {
-    tracing::info!("Asking uv to sync the script's venv");
-    let mut command = Command::new("uv");
-    command
-        .arg("sync")
-        .arg("--output-format=json")
-        .arg("--script")
-        .arg(script_path.as_str());
-    let output = command
-        .output()
-        .inspect_err(|e| {
-            tracing::info!(
-                "failed to run `uv sync --output-format=json --script {script_path}`: {e}"
-            );
-        })
-        .ok()?;
-    let metadata: UvMetadata = serde_json::from_slice(&output.stdout)
-        .inspect_err(|e| {
-            tracing::info!(
-                "failed to parse `uv sync --output-format=json --script {script_path}`: {e}"
-            );
-        })
-        .ok()?;
-    let env_path = metadata.sync?.environment?.path?;
-    let utf8_path = Utf8PathBuf::from(env_path);
-    Some(SystemPathBuf::from_utf8_path_buf(utf8_path))
-}
-
-impl FromStr for Pep723Metadata {
-    type Err = toml::de::Error;
-
-    /// Parse `Pep723Metadata` from a raw TOML string.
-    fn from_str(raw: &str) -> Result<Self, Self::Err> {
-        let metadata = toml::from_str(raw)?;
-        Ok(Self {
-            raw: raw.to_string(),
-            ..metadata
-        })
-    }
-}

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
-```

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

@@ -1,210 +0,0 @@
-# SQLAlchemy
-
-```toml
-[environment]
-python-version = "3.13"
-python-platform = "linux"
-
-[project]
-dependencies = ["SQLAlchemy==2.0.44"]
-```
-
-## ORM Model
-
-This test makes sure that ty understands SQLAlchemy's `dataclass_transform` setup:
-
-```py
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
-
-class Base(DeclarativeBase):
-    pass
-
-class User(Base):
-    __tablename__ = "user"
-
-    id: Mapped[int] = mapped_column(primary_key=True, init=False)
-    internal_name: Mapped[str] = mapped_column(alias="name")
-
-user = User(name="John Doe")
-reveal_type(user.id)  # revealed: int
-reveal_type(user.internal_name)  # revealed: str
-```
-
-Unfortunately, SQLAlchemy overrides `__init__` and explicitly accepts all combinations of keyword
-arguments. This is why we currently cannot flag invalid constructor calls:
-
-```py
-reveal_type(User.__init__)  # revealed: def __init__(self, **kw: Any) -> Unknown
-
-# TODO: this should ideally be an error
-invalid_user = User(invalid_arg=42)
-```
-
-## Basic query example
-
-First, set up a `Session`:
-
-```py
-from sqlalchemy import select, Integer, Text, Boolean
-from sqlalchemy.orm import Session
-from sqlalchemy.orm import DeclarativeBase
-from sqlalchemy.orm import Mapped, mapped_column
-from sqlalchemy import create_engine
-
-engine = create_engine("sqlite://example.db")
-session = Session(engine)
-```
-
-And define a simple model:
-
-```py
-class Base(DeclarativeBase):
-    pass
-
-class User(Base):
-    __tablename__ = "users"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    name: Mapped[str] = mapped_column(Text)
-    is_admin: Mapped[bool] = mapped_column(Boolean, default=False)
-```
-
-Finally, we can execute queries:
-
-```py
-stmt = select(User)
-reveal_type(stmt)  # revealed: Select[tuple[User]]
-
-users = session.scalars(stmt).all()
-reveal_type(users)  # revealed: Sequence[User]
-
-for row in session.execute(stmt):
-    reveal_type(row)  # revealed: Row[tuple[User]]
-
-stmt = select(User).where(User.name == "Alice")
-alice1 = session.scalars(stmt).first()
-reveal_type(alice1)  # revealed: User | None
-
-alice2 = session.scalar(stmt)
-reveal_type(alice2)  # revealed: User | None
-
-result = session.execute(stmt)
-row = result.one_or_none()
-assert row is not None
-(alice3,) = row._tuple()
-reveal_type(alice3)  # revealed: User
-```
-
-This also works with more complex queries:
-
-```py
-stmt = select(User).where(User.is_admin == True).order_by(User.name).limit(10)
-admin_users = session.scalars(stmt).all()
-reveal_type(admin_users)  # revealed: Sequence[User]
-```
-
-We can also specify particular columns to select:
-
-```py
-stmt = select(User.id, User.name)
-# TODO: should be `Select[tuple[int, str]]`
-reveal_type(stmt)  # revealed: Select[tuple[Unknown, Unknown]]
-
-ids_and_names = session.execute(stmt).all()
-# TODO: should be `Sequence[Row[tuple[int, str]]]`
-reveal_type(ids_and_names)  # revealed: Sequence[Row[tuple[Unknown, Unknown]]]
-
-for row in session.execute(stmt):
-    # TODO: should be `Row[tuple[int, str]]`
-    reveal_type(row)  # revealed: Row[tuple[Unknown, Unknown]]
-
-for user_id, name in session.execute(stmt).tuples():
-    # TODO: should be `int`
-    reveal_type(user_id)  # revealed: Unknown
-    # TODO: should be `str`
-    reveal_type(name)  # revealed: Unknown
-
-result = session.execute(stmt)
-row = result.one_or_none()
-assert row is not None
-(user_id, name) = row._tuple()
-# TODO: should be `int`
-reveal_type(user_id)  # revealed: Unknown
-# TODO: should be `str`
-reveal_type(name)  # revealed: Unknown
-
-stmt = select(User.id).where(User.name == "Alice")
-
-# TODO: should be `Select[tuple[int]]`
-reveal_type(stmt)  # revealed: Select[tuple[Unknown]]
-
-alice_id = session.scalars(stmt).first()
-# TODO: should be `int | None`
-reveal_type(alice_id)  # revealed: Unknown | None
-
-alice_id = session.scalar(stmt)
-# TODO: should be `int | None`
-reveal_type(alice_id)  # revealed: Unknown | None
-```
-
-Using the legacy `query` API also works:
-
-```py
-users_legacy = session.query(User).all()
-reveal_type(users_legacy)  # revealed: list[User]
-
-query = session.query(User)
-reveal_type(query)  # revealed: Query[User]
-
-reveal_type(query.all())  # revealed: list[User]
-
-for row in query:
-    reveal_type(row)  # revealed: User
-```
-
-And similarly when specifying particular columns:
-
-```py
-query = session.query(User.id, User.name)
-# TODO: should be `RowReturningQuery[tuple[int, str]]`
-reveal_type(query)  # revealed: RowReturningQuery[tuple[Unknown, Unknown]]
-
-# TODO: should be `list[Row[tuple[int, str]]]`
-reveal_type(query.all())  # revealed: list[Row[tuple[Unknown, Unknown]]]
-
-for row in query:
-    # TODO: should be `Row[tuple[int, str]]`
-    reveal_type(row)  # revealed: Row[tuple[Unknown, Unknown]]
-```
-
-## Async API
-
-The async API is supported as well:
-
-```py
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, Integer, Text
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
-
-class Base(DeclarativeBase):
-    pass
-
-class User(Base):
-    __tablename__ = "users"
-
-    id: Mapped[int] = mapped_column(Integer, primary_key=True)
-    name: Mapped[str] = mapped_column(Text)
-
-async def test_async(session: AsyncSession):
-    stmt = select(User).where(User.name == "Alice")
-    alice = await session.scalar(stmt)
-    reveal_type(alice)  # revealed: User | None
-
-    stmt = select(User.id, User.name)
-    result = await session.execute(stmt)
-    for user_id, name in result.tuples():
-        # TODO: should be `int`
-        reveal_type(user_id)  # revealed: Unknown
-        # TODO: should be `str`
-        reveal_type(name)  # revealed: Unknown
-```

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

@@ -1,30 +0,0 @@
-# SQLModel
-
-```toml
-[environment]
-python-version = "3.13"
-python-platform = "linux"
-
-[project]
-dependencies = ["sqlmodel==0.0.27"]
-```
-
-## Basic model
-
-```py
-from sqlmodel import SQLModel
-
-class User(SQLModel):
-    id: int
-    name: str
-
-user = User(id=1, name="John Doe")
-reveal_type(user.id)  # revealed: int
-reveal_type(user.name)  # revealed: str
-
-# TODO: this should not mention `__pydantic_self__`, and have proper parameters defined by the fields
-reveal_type(User.__init__)  # revealed: def __init__(__pydantic_self__, **data: Any) -> None
-
-# TODO: this should be an error
-User()
-```

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

@@ -1,27 +0,0 @@
-# Strawberry GraphQL
-
-```toml
-[environment]
-python-version = "3.13"
-python-platform = "linux"
-
-[project]
-dependencies = ["strawberry-graphql==0.283.3"]
-```
-
-## Basic model
-
-```py
-import strawberry
-
-@strawberry.type
-class User:
-    id: int
-    role: str = strawberry.field(default="user")
-
-reveal_type(User.__init__)  # revealed: (self: User, *, id: int, role: str = Any) -> None
-
-user = User(id=1)
-reveal_type(user.id)  # revealed: int
-reveal_type(user.role)  # revealed: str
-```

crates/ty_python_semantic/resources/mdtest/function/return_type.md

@@ -80,7 +80,7 @@ class Foo(Protocol):
     def f[T](self, v: T) -> T: ...
 
 t = (Protocol, int)
-reveal_type(t[0])  # revealed: <special form 'typing.Protocol'>
+reveal_type(t[0])  # revealed: typing.Protocol
 
 class Lorem(t[0]):
     def f(self) -> int: ...

crates/ty_python_semantic/resources/mdtest/generics/legacy/classes.md

@@ -301,7 +301,6 @@ consistent with each other.
 
 ```py
 from typing_extensions import Generic, TypeVar
-from ty_extensions import generic_context, into_callable
 
 T = TypeVar("T")
 
@@ -309,11 +308,6 @@ class C(Generic[T]):
     def __new__(cls, x: T) -> "C[T]":
         return object.__new__(cls)
 
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C(1))  # revealed: C[int]
 
 # error: [invalid-assignment] "Object of type `C[int | str]` is not assignable to `C[int]`"
@@ -324,18 +318,12 @@ wrong_innards: C[int] = C("five")
 
 ```py
 from typing_extensions import Generic, TypeVar
-from ty_extensions import generic_context, into_callable
 
 T = TypeVar("T")
 
 class C(Generic[T]):
     def __init__(self, x: T) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C(1))  # revealed: C[int]
 
 # error: [invalid-assignment] "Object of type `C[int | str]` is not assignable to `C[int]`"
@@ -346,7 +334,6 @@ wrong_innards: C[int] = C("five")
 
 ```py
 from typing_extensions import Generic, TypeVar
-from ty_extensions import generic_context, into_callable
 
 T = TypeVar("T")
 
@@ -356,11 +343,6 @@ class C(Generic[T]):
 
     def __init__(self, x: T) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C(1))  # revealed: C[int]
 
 # error: [invalid-assignment] "Object of type `C[int | str]` is not assignable to `C[int]`"
@@ -371,7 +353,6 @@ wrong_innards: C[int] = C("five")
 
 ```py
 from typing_extensions import Generic, TypeVar
-from ty_extensions import generic_context, into_callable
 
 T = TypeVar("T")
 
@@ -381,11 +362,6 @@ class C(Generic[T]):
 
     def __init__(self, x: T) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C(1))  # revealed: C[int]
 
 # error: [invalid-assignment] "Object of type `C[int | str]` is not assignable to `C[int]`"
@@ -397,11 +373,6 @@ class D(Generic[T]):
 
     def __init__(self, *args, **kwargs) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@D]
-reveal_type(generic_context(D))
-# revealed: ty_extensions.GenericContext[T@D]
-reveal_type(generic_context(into_callable(D)))
-
 reveal_type(D(1))  # revealed: D[int]
 
 # error: [invalid-assignment] "Object of type `D[int | str]` is not assignable to `D[int]`"
@@ -415,7 +386,6 @@ to specialize the class.
 
 ```py
 from typing_extensions import Generic, TypeVar
-from ty_extensions import generic_context, into_callable
 
 T = TypeVar("T")
 U = TypeVar("U")
@@ -428,11 +398,6 @@ class C(Generic[T, U]):
 class D(C[V, int]):
     def __init__(self, x: V) -> None: ...
 
-# revealed: ty_extensions.GenericContext[V@D]
-reveal_type(generic_context(D))
-# revealed: ty_extensions.GenericContext[V@D]
-reveal_type(generic_context(into_callable(D)))
-
 reveal_type(D(1))  # revealed: D[int]
 ```
 
@@ -440,7 +405,6 @@ reveal_type(D(1))  # revealed: D[int]
 
 ```py
 from typing_extensions import Generic, TypeVar
-from ty_extensions import generic_context, into_callable
 
 T = TypeVar("T")
 U = TypeVar("U")
@@ -451,11 +415,6 @@ class C(Generic[T, U]):
 class D(C[T, U]):
     pass
 
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(D))
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(into_callable(D)))
-
 reveal_type(C(1, "str"))  # revealed: C[int, str]
 reveal_type(D(1, "str"))  # revealed: D[int, str]
 ```
@@ -466,7 +425,6 @@ This is a specific example of the above, since it was reported specifically by a
 
 ```py
 from typing_extensions import Generic, TypeVar
-from ty_extensions import generic_context, into_callable
 
 T = TypeVar("T")
 U = TypeVar("U")
@@ -474,11 +432,6 @@ U = TypeVar("U")
 class D(dict[T, U]):
     pass
 
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(D))
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(into_callable(D)))
-
 reveal_type(D(key=1))  # revealed: D[str, int]
 ```
 
@@ -490,18 +443,12 @@ context. But from the user's point of view, this is another example of the above
 
 ```py
 from typing_extensions import Generic, TypeVar
-from ty_extensions import generic_context, into_callable
 
 T = TypeVar("T")
 U = TypeVar("U")
 
 class C(tuple[T, U]): ...
 
-# revealed: ty_extensions.GenericContext[T@C, U@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C, U@C]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C((1, 2)))  # revealed: C[int, int]
 ```
 
@@ -533,7 +480,6 @@ def func8(t1: tuple[complex, list[int]], t2: tuple[int, *tuple[str, ...]], t3: t
 
 ```py
 from typing_extensions import Generic, TypeVar
-from ty_extensions import generic_context, into_callable
 
 S = TypeVar("S")
 T = TypeVar("T")
@@ -541,11 +487,6 @@ T = TypeVar("T")
 class C(Generic[T]):
     def __init__(self, x: T, y: S) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C, S@__init__]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C(1, 1))  # revealed: C[int]
 reveal_type(C(1, "string"))  # revealed: C[int]
 reveal_type(C(1, True))  # revealed: C[int]
@@ -558,7 +499,6 @@ wrong_innards: C[int] = C("five", 1)
 
 ```py
 from typing_extensions import overload, Generic, TypeVar
-from ty_extensions import generic_context, into_callable
 
 T = TypeVar("T")
 U = TypeVar("U")
@@ -574,11 +514,6 @@ class C(Generic[T]):
     def __init__(self, x: int) -> None: ...
     def __init__(self, x: str | bytes | int) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C("string"))  # revealed: C[str]
 reveal_type(C(b"bytes"))  # revealed: C[bytes]
 reveal_type(C(12))  # revealed: C[Unknown]
@@ -606,11 +541,6 @@ class D(Generic[T, U]):
     def __init__(self, t: T, u: U) -> None: ...
     def __init__(self, *args) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(D))
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(into_callable(D)))
-
 reveal_type(D("string"))  # revealed: D[str, str]
 reveal_type(D(1))  # revealed: D[str, int]
 reveal_type(D(1, "string"))  # revealed: D[int, str]
@@ -621,7 +551,6 @@ reveal_type(D(1, "string"))  # revealed: D[int, str]
 ```py
 from dataclasses import dataclass
 from typing_extensions import Generic, TypeVar
-from ty_extensions import generic_context, into_callable
 
 T = TypeVar("T")
 
@@ -629,11 +558,6 @@ T = TypeVar("T")
 class A(Generic[T]):
     x: T
 
-# revealed: ty_extensions.GenericContext[T@A]
-reveal_type(generic_context(A))
-# revealed: ty_extensions.GenericContext[T@A]
-reveal_type(generic_context(into_callable(A)))
-
 reveal_type(A(x=1))  # revealed: A[int]
 ```
 
@@ -641,28 +565,17 @@ reveal_type(A(x=1))  # revealed: A[int]
 
 ```py
 from typing_extensions import Generic, TypeVar
-from ty_extensions import generic_context, into_callable
 
 T = TypeVar("T")
 U = TypeVar("U", default=T)
 
 class C(Generic[T, U]): ...
 
-# revealed: ty_extensions.GenericContext[T@C, U@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C, U@C]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C())  # revealed: C[Unknown, Unknown]
 
 class D(Generic[T, U]):
     def __init__(self) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(D))
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(into_callable(D)))
-
 reveal_type(D())  # revealed: D[Unknown, Unknown]
 ```
 

crates/ty_python_semantic/resources/mdtest/generics/legacy/functions.md

@@ -379,14 +379,13 @@ T = TypeVar("T")
 def invoke(fn: Callable[[A], B], value: A) -> B:
     return fn(value)
 
-def identity(x: T) -> T:
+def identity(x: T, /) -> T:
     return x
 
-def head(xs: list[T]) -> T:
+def head(xs: list[T], /) -> T:
     return xs[0]
 
-# TODO: this should be `Literal[1]`
-reveal_type(invoke(identity, 1))  # revealed: Unknown
+reveal_type(invoke(identity, 1))  # revealed: Literal[1]
 
 # TODO: this should be `Unknown | int`
 reveal_type(invoke(head, [1, 2, 3]))  # revealed: Unknown

crates/ty_python_semantic/resources/mdtest/generics/legacy/paramspec.md

@@ -102,38 +102,6 @@ Other values are invalid.
 P4 = ParamSpec("P4", default=int)
 ```
 
-### `default` parameter in `typing_extensions.ParamSpec`
-
-```toml
-[environment]
-python-version = "3.12"
-```
-
-The `default` parameter to `ParamSpec` is available from `typing_extensions` in Python 3.12 and
-earlier.
-
-```py
-from typing import ParamSpec
-from typing_extensions import ParamSpec as ExtParamSpec
-
-# This shouldn't emit a diagnostic
-P1 = ExtParamSpec("P1", default=[int, str])
-
-# But, this should
-# error: [invalid-paramspec] "The `default` parameter of `typing.ParamSpec` was added in Python 3.13"
-P2 = ParamSpec("P2", default=[int, str])
-```
-
-And, it allows the same set of values as `typing.ParamSpec`.
-
-```py
-P3 = ExtParamSpec("P3", default=...)
-P4 = ExtParamSpec("P4", default=P3)
-
-# error: [invalid-paramspec]
-P5 = ExtParamSpec("P5", default=int)
-```
-
 ### Forward references in stub files
 
 Stubs natively support forward references, so patterns that would raise `NameError` at runtime are
@@ -147,297 +115,3 @@ P = ParamSpec("P", default=[A, B])
 class A: ...
 class B: ...
 ```
-
-## Validating `ParamSpec` usage
-
-In type annotations, `ParamSpec` is only valid as the first element to `Callable`, the final element
-to `Concatenate`, or as a type parameter to `Protocol` or `Generic`.
-
-```py
-from typing import ParamSpec, Callable, Concatenate, Protocol, Generic
-
-P = ParamSpec("P")
-
-class ValidProtocol(Protocol[P]):
-    def method(self, c: Callable[P, int]) -> None: ...
-
-class ValidGeneric(Generic[P]):
-    def method(self, c: Callable[P, int]) -> None: ...
-
-def valid(
-    a1: Callable[P, int],
-    a2: Callable[Concatenate[int, P], int],
-) -> None: ...
-def invalid(
-    # TODO: error
-    a1: P,
-    # TODO: error
-    a2: list[P],
-    # TODO: error
-    a3: Callable[[P], int],
-    # TODO: error
-    a4: Callable[..., P],
-    # TODO: error
-    a5: Callable[Concatenate[P, ...], int],
-) -> None: ...
-```
-
-## Validating `P.args` and `P.kwargs` usage
-
-The components of `ParamSpec` i.e., `P.args` and `P.kwargs` are only valid when used as the
-annotated types of `*args` and `**kwargs` respectively.
-
-```py
-from typing import Generic, Callable, ParamSpec
-
-P = ParamSpec("P")
-
-def foo1(c: Callable[P, int]) -> None:
-    def nested1(*args: P.args, **kwargs: P.kwargs) -> None: ...
-    def nested2(
-        # error: [invalid-type-form] "`P.kwargs` is valid only in `**kwargs` annotation: Did you mean `P.args`?"
-        *args: P.kwargs,
-        # error: [invalid-type-form] "`P.args` is valid only in `*args` annotation: Did you mean `P.kwargs`?"
-        **kwargs: P.args,
-    ) -> None: ...
-
-    # TODO: error
-    def nested3(*args: P.args) -> None: ...
-
-    # TODO: error
-    def nested4(**kwargs: P.kwargs) -> None: ...
-
-    # TODO: error
-    def nested5(*args: P.args, x: int, **kwargs: P.kwargs) -> None: ...
-
-# TODO: error
-def bar1(*args: P.args, **kwargs: P.kwargs) -> None:
-    pass
-
-class Foo1:
-    # TODO: error
-    def method(self, *args: P.args, **kwargs: P.kwargs) -> None: ...
-```
-
-And, they need to be used together.
-
-```py
-def foo2(c: Callable[P, int]) -> None:
-    # TODO: error
-    def nested1(*args: P.args) -> None: ...
-
-    # TODO: error
-    def nested2(**kwargs: P.kwargs) -> None: ...
-
-class Foo2:
-    # TODO: error
-    args: P.args
-
-    # TODO: error
-    kwargs: P.kwargs
-```
-
-The name of these parameters does not need to be `args` or `kwargs`, it's the annotated type to the
-respective variadic parameter that matters.
-
-```py
-class Foo3(Generic[P]):
-    def method1(self, *paramspec_args: P.args, **paramspec_kwargs: P.kwargs) -> None: ...
-    def method2(
-        self,
-        # error: [invalid-type-form] "`P.kwargs` is valid only in `**kwargs` annotation: Did you mean `P.args`?"
-        *paramspec_args: P.kwargs,
-        # error: [invalid-type-form] "`P.args` is valid only in `*args` annotation: Did you mean `P.kwargs`?"
-        **paramspec_kwargs: P.args,
-    ) -> None: ...
-```
-
-## Specializing generic classes explicitly
-
-```py
-from typing import Any, Generic, ParamSpec, Callable, TypeVar
-
-P1 = ParamSpec("P1")
-P2 = ParamSpec("P2")
-T1 = TypeVar("T1")
-
-class OnlyParamSpec(Generic[P1]):
-    attr: Callable[P1, None]
-
-class TwoParamSpec(Generic[P1, P2]):
-    attr1: Callable[P1, None]
-    attr2: Callable[P2, None]
-
-class TypeVarAndParamSpec(Generic[T1, P1]):
-    attr: Callable[P1, T1]
-```
-
-Explicit specialization of a generic class involving `ParamSpec` is done by providing either a list
-of types, `...`, or another in-scope `ParamSpec`.
-
-```py
-reveal_type(OnlyParamSpec[[]]().attr)  # revealed: () -> None
-reveal_type(OnlyParamSpec[[int, str]]().attr)  # revealed: (int, str, /) -> None
-reveal_type(OnlyParamSpec[...]().attr)  # revealed: (...) -> None
-
-def func(c: Callable[P2, None]):
-    reveal_type(OnlyParamSpec[P2]().attr)  # revealed: (**P2@func) -> None
-
-# TODO: error: paramspec is unbound
-reveal_type(OnlyParamSpec[P2]().attr)  # revealed: (...) -> None
-
-# error: [invalid-type-arguments] "No type argument provided for required type variable `P1` of class `OnlyParamSpec`"
-reveal_type(OnlyParamSpec[()]().attr)  # revealed: (...) -> None
-```
-
-An explicit tuple expression (unlike an implicit one that omits the parentheses) is also accepted
-when the `ParamSpec` is the only type variable. But, this isn't recommended is mainly a fallout of
-it having the same AST as the one without the parentheses. Both mypy and Pyright also allow this.
-
-```py
-reveal_type(OnlyParamSpec[(int, str)]().attr)  # revealed: (int, str, /) -> None
-```
-
-<!-- blacken-docs:off -->
-
-```py
-# error: [invalid-syntax]
-reveal_type(OnlyParamSpec[]().attr)  # revealed: (...) -> None
-```
-
-<!-- blacken-docs:on -->
-
-The square brackets can be omitted when `ParamSpec` is the only type variable
-
-```py
-reveal_type(OnlyParamSpec[int, str]().attr)  # revealed: (int, str, /) -> None
-reveal_type(OnlyParamSpec[int,]().attr)  # revealed: (int, /) -> None
-
-# Even when there is only one element
-reveal_type(OnlyParamSpec[Any]().attr)  # revealed: (Any, /) -> None
-reveal_type(OnlyParamSpec[object]().attr)  # revealed: (object, /) -> None
-reveal_type(OnlyParamSpec[int]().attr)  # revealed: (int, /) -> None
-```
-
-But, they cannot be omitted when there are multiple type variables.
-
-```py
-reveal_type(TypeVarAndParamSpec[int, []]().attr)  # revealed: () -> int
-reveal_type(TypeVarAndParamSpec[int, [int, str]]().attr)  # revealed: (int, str, /) -> int
-reveal_type(TypeVarAndParamSpec[int, [str]]().attr)  # revealed: (str, /) -> int
-reveal_type(TypeVarAndParamSpec[int, ...]().attr)  # revealed: (...) -> int
-
-# TODO: We could still specialize for `T1` as the type is valid which would reveal `(...) -> int`
-# TODO: error: paramspec is unbound
-reveal_type(TypeVarAndParamSpec[int, P2]().attr)  # revealed: (...) -> Unknown
-# error: [invalid-type-arguments] "Type argument for `ParamSpec` must be"
-reveal_type(TypeVarAndParamSpec[int, int]().attr)  # revealed: (...) -> Unknown
-# error: [invalid-type-arguments] "Type argument for `ParamSpec` must be"
-reveal_type(TypeVarAndParamSpec[int, ()]().attr)  # revealed: (...) -> Unknown
-# error: [invalid-type-arguments] "Type argument for `ParamSpec` must be"
-reveal_type(TypeVarAndParamSpec[int, (int, str)]().attr)  # revealed: (...) -> Unknown
-```
-
-Nor can they be omitted when there are more than one `ParamSpec`s.
-
-```py
-p = TwoParamSpec[[int, str], [int]]()
-reveal_type(p.attr1)  # revealed: (int, str, /) -> None
-reveal_type(p.attr2)  # revealed: (int, /) -> None
-
-# error: [invalid-type-arguments]
-# error: [invalid-type-arguments]
-TwoParamSpec[int, str]
-```
-
-Specializing `ParamSpec` type variable using `typing.Any` isn't explicitly allowed by the spec but
-both mypy and Pyright allow this and there are usages of this in the wild e.g.,
-`staticmethod[Any, Any]`.
-
-```py
-reveal_type(TypeVarAndParamSpec[int, Any]().attr)  # revealed: (...) -> int
-```
-
-## Specialization when defaults are involved
-
-```toml
-[environment]
-python-version = "3.13"
-```
-
-```py
-from typing import Any, Generic, ParamSpec, Callable, TypeVar
-
-P = ParamSpec("P")
-PList = ParamSpec("PList", default=[int, str])
-PEllipsis = ParamSpec("PEllipsis", default=...)
-PAnother = ParamSpec("PAnother", default=P)
-PAnotherWithDefault = ParamSpec("PAnotherWithDefault", default=PList)
-```
-
-```py
-class ParamSpecWithDefault1(Generic[PList]):
-    attr: Callable[PList, None]
-
-reveal_type(ParamSpecWithDefault1().attr)  # revealed: (int, str, /) -> None
-reveal_type(ParamSpecWithDefault1[[int]]().attr)  # revealed: (int, /) -> None
-```
-
-```py
-class ParamSpecWithDefault2(Generic[PEllipsis]):
-    attr: Callable[PEllipsis, None]
-
-reveal_type(ParamSpecWithDefault2().attr)  # revealed: (...) -> None
-reveal_type(ParamSpecWithDefault2[[int, str]]().attr)  # revealed: (int, str, /) -> None
-```
-
-```py
-class ParamSpecWithDefault3(Generic[P, PAnother]):
-    attr1: Callable[P, None]
-    attr2: Callable[PAnother, None]
-
-# `P` hasn't been specialized, so it defaults to `Unknown` gradual form
-p1 = ParamSpecWithDefault3()
-reveal_type(p1.attr1)  # revealed: (...) -> None
-reveal_type(p1.attr2)  # revealed: (...) -> None
-
-p2 = ParamSpecWithDefault3[[int, str]]()
-reveal_type(p2.attr1)  # revealed: (int, str, /) -> None
-reveal_type(p2.attr2)  # revealed: (int, str, /) -> None
-
-p3 = ParamSpecWithDefault3[[int], [str]]()
-reveal_type(p3.attr1)  # revealed: (int, /) -> None
-reveal_type(p3.attr2)  # revealed: (str, /) -> None
-
-class ParamSpecWithDefault4(Generic[PList, PAnotherWithDefault]):
-    attr1: Callable[PList, None]
-    attr2: Callable[PAnotherWithDefault, None]
-
-p1 = ParamSpecWithDefault4()
-reveal_type(p1.attr1)  # revealed: (int, str, /) -> None
-reveal_type(p1.attr2)  # revealed: (int, str, /) -> None
-
-p2 = ParamSpecWithDefault4[[int]]()
-reveal_type(p2.attr1)  # revealed: (int, /) -> None
-reveal_type(p2.attr2)  # revealed: (int, /) -> None
-
-p3 = ParamSpecWithDefault4[[int], [str]]()
-reveal_type(p3.attr1)  # revealed: (int, /) -> None
-reveal_type(p3.attr2)  # revealed: (str, /) -> None
-
-# TODO: error
-# Un-ordered type variables as the default of `PAnother` is `P`
-class ParamSpecWithDefault5(Generic[PAnother, P]):
-    attr: Callable[PAnother, None]
-
-# TODO: error
-# PAnother has default as P (another ParamSpec) which is not in scope
-class ParamSpecWithDefault6(Generic[PAnother]):
-    attr: Callable[PAnother, None]
-```
-
-## Semantics
-
-The semantics of `ParamSpec` are described in
-[the PEP 695 `ParamSpec` document](./../pep695/paramspec.md) to avoid duplication unless there are
-any behavior specific to the legacy `ParamSpec` implementation.

crates/ty_python_semantic/resources/mdtest/generics/pep695/aliases.md

@@ -25,11 +25,11 @@ reveal_type(generic_context(SingleTypevar))
 # revealed: ty_extensions.GenericContext[T@MultipleTypevars, S@MultipleTypevars]
 reveal_type(generic_context(MultipleTypevars))
 
-# TODO: support `TypeVarTuple` properly
-# (these should include the `TypeVarTuple`s in their generic contexts)
-# revealed: ty_extensions.GenericContext[P@SingleParamSpec]
+# TODO: support `ParamSpec`/`TypeVarTuple` properly
+# (these should include the `ParamSpec`s and `TypeVarTuple`s in their generic contexts)
+# revealed: ty_extensions.GenericContext[]
 reveal_type(generic_context(SingleParamSpec))
-# revealed: ty_extensions.GenericContext[T@TypeVarAndParamSpec, P@TypeVarAndParamSpec]
+# revealed: ty_extensions.GenericContext[T@TypeVarAndParamSpec]
 reveal_type(generic_context(TypeVarAndParamSpec))
 # revealed: ty_extensions.GenericContext[]
 reveal_type(generic_context(SingleTypeVarTuple))
@@ -62,7 +62,7 @@ The specialization must match the generic types:
 
 ```py
 # error: [invalid-type-arguments] "Too many type arguments: expected 1, got 2"
-reveal_type(C[int, int])  # revealed: <type alias 'C[Unknown]'>
+reveal_type(C[int, int])  # revealed: C[Unknown]
 ```
 
 And non-generic types cannot be specialized:
@@ -85,19 +85,19 @@ type BoundedByUnion[T: int | str] = ...
 
 class IntSubclass(int): ...
 
-reveal_type(Bounded[int])  # revealed: <type alias 'Bounded[int]'>
-reveal_type(Bounded[IntSubclass])  # revealed: <type alias 'Bounded[IntSubclass]'>
+reveal_type(Bounded[int])  # revealed: Bounded[int]
+reveal_type(Bounded[IntSubclass])  # revealed: Bounded[IntSubclass]
 
 # error: [invalid-type-arguments] "Type `str` is not assignable to upper bound `int` of type variable `T@Bounded`"
-reveal_type(Bounded[str])  # revealed: <type alias 'Bounded[Unknown]'>
+reveal_type(Bounded[str])  # revealed: Bounded[Unknown]
 
 # error: [invalid-type-arguments] "Type `int | str` is not assignable to upper bound `int` of type variable `T@Bounded`"
-reveal_type(Bounded[int | str])  # revealed: <type alias 'Bounded[Unknown]'>
+reveal_type(Bounded[int | str])  # revealed: Bounded[Unknown]
 
-reveal_type(BoundedByUnion[int])  # revealed: <type alias 'BoundedByUnion[int]'>
-reveal_type(BoundedByUnion[IntSubclass])  # revealed: <type alias 'BoundedByUnion[IntSubclass]'>
-reveal_type(BoundedByUnion[str])  # revealed: <type alias 'BoundedByUnion[str]'>
-reveal_type(BoundedByUnion[int | str])  # revealed: <type alias 'BoundedByUnion[int | str]'>
+reveal_type(BoundedByUnion[int])  # revealed: BoundedByUnion[int]
+reveal_type(BoundedByUnion[IntSubclass])  # revealed: BoundedByUnion[IntSubclass]
+reveal_type(BoundedByUnion[str])  # revealed: BoundedByUnion[str]
+reveal_type(BoundedByUnion[int | str])  # revealed: BoundedByUnion[int | str]
 ```
 
 If the type variable is constrained, the specialized type must satisfy those constraints:
@@ -105,20 +105,20 @@ If the type variable is constrained, the specialized type must satisfy those con
 ```py
 type Constrained[T: (int, str)] = ...
 
-reveal_type(Constrained[int])  # revealed: <type alias 'Constrained[int]'>
+reveal_type(Constrained[int])  # revealed: Constrained[int]
 
 # TODO: error: [invalid-argument-type]
 # TODO: revealed: Constrained[Unknown]
-reveal_type(Constrained[IntSubclass])  # revealed: <type alias 'Constrained[IntSubclass]'>
+reveal_type(Constrained[IntSubclass])  # revealed: Constrained[IntSubclass]
 
-reveal_type(Constrained[str])  # revealed: <type alias 'Constrained[str]'>
+reveal_type(Constrained[str])  # revealed: Constrained[str]
 
 # TODO: error: [invalid-argument-type]
 # TODO: revealed: Unknown
-reveal_type(Constrained[int | str])  # revealed: <type alias 'Constrained[int | str]'>
+reveal_type(Constrained[int | str])  # revealed: Constrained[int | str]
 
 # error: [invalid-type-arguments] "Type `object` does not satisfy constraints `int`, `str` of type variable `T@Constrained`"
-reveal_type(Constrained[object])  # revealed: <type alias 'Constrained[Unknown]'>
+reveal_type(Constrained[object])  # revealed: Constrained[Unknown]
 ```
 
 If the type variable has a default, it can be omitted:
@@ -126,8 +126,8 @@ If the type variable has a default, it can be omitted:
 ```py
 type WithDefault[T, U = int] = ...
 
-reveal_type(WithDefault[str, str])  # revealed: <type alias 'WithDefault[str, str]'>
-reveal_type(WithDefault[str])  # revealed: <type alias 'WithDefault[str, int]'>
+reveal_type(WithDefault[str, str])  # revealed: WithDefault[str, str]
+reveal_type(WithDefault[str])  # revealed: WithDefault[str, int]
 ```
 
 If the type alias is not specialized explicitly, it is implicitly specialized to `Unknown`:

crates/ty_python_semantic/resources/mdtest/generics/pep695/classes.md

@@ -25,11 +25,11 @@ reveal_type(generic_context(SingleTypevar))
 # revealed: ty_extensions.GenericContext[T@MultipleTypevars, S@MultipleTypevars]
 reveal_type(generic_context(MultipleTypevars))
 
-# TODO: support `TypeVarTuple` properly
-# (these should include the `TypeVarTuple`s in their generic contexts)
-# revealed: ty_extensions.GenericContext[P@SingleParamSpec]
+# TODO: support `ParamSpec`/`TypeVarTuple` properly
+# (these should include the `ParamSpec`s and `TypeVarTuple`s in their generic contexts)
+# revealed: ty_extensions.GenericContext[]
 reveal_type(generic_context(SingleParamSpec))
-# revealed: ty_extensions.GenericContext[T@TypeVarAndParamSpec, P@TypeVarAndParamSpec]
+# revealed: ty_extensions.GenericContext[T@TypeVarAndParamSpec]
 reveal_type(generic_context(TypeVarAndParamSpec))
 # revealed: ty_extensions.GenericContext[]
 reveal_type(generic_context(SingleTypeVarTuple))
@@ -264,19 +264,12 @@ signatures don't count towards variance).
 ### `__new__` only
 
 ```py
-from ty_extensions import generic_context, into_callable
-
 class C[T]:
     x: T
 
     def __new__(cls, x: T) -> "C[T]":
         return object.__new__(cls)
 
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C(1))  # revealed: C[int]
 
 # error: [invalid-assignment] "Object of type `C[int | str]` is not assignable to `C[int]`"
@@ -286,18 +279,11 @@ wrong_innards: C[int] = C("five")
 ### `__init__` only
 
 ```py
-from ty_extensions import generic_context, into_callable
-
 class C[T]:
     x: T
 
     def __init__(self, x: T) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C(1))  # revealed: C[int]
 
 # error: [invalid-assignment] "Object of type `C[int | str]` is not assignable to `C[int]`"
@@ -307,8 +293,6 @@ wrong_innards: C[int] = C("five")
 ### Identical `__new__` and `__init__` signatures
 
 ```py
-from ty_extensions import generic_context, into_callable
-
 class C[T]:
     x: T
 
@@ -317,11 +301,6 @@ class C[T]:
 
     def __init__(self, x: T) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C(1))  # revealed: C[int]
 
 # error: [invalid-assignment] "Object of type `C[int | str]` is not assignable to `C[int]`"
@@ -331,8 +310,6 @@ wrong_innards: C[int] = C("five")
 ### Compatible `__new__` and `__init__` signatures
 
 ```py
-from ty_extensions import generic_context, into_callable
-
 class C[T]:
     x: T
 
@@ -341,11 +318,6 @@ class C[T]:
 
     def __init__(self, x: T) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C(1))  # revealed: C[int]
 
 # error: [invalid-assignment] "Object of type `C[int | str]` is not assignable to `C[int]`"
@@ -359,11 +331,6 @@ class D[T]:
 
     def __init__(self, *args, **kwargs) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@D]
-reveal_type(generic_context(D))
-# revealed: ty_extensions.GenericContext[T@D]
-reveal_type(generic_context(into_callable(D)))
-
 reveal_type(D(1))  # revealed: D[int]
 
 # error: [invalid-assignment] "Object of type `D[int | str]` is not assignable to `D[int]`"
@@ -376,8 +343,6 @@ If either method comes from a generic base class, we don't currently use its inf
 to specialize the class.
 
 ```py
-from ty_extensions import generic_context, into_callable
-
 class C[T, U]:
     def __new__(cls, *args, **kwargs) -> "C[T, U]":
         return object.__new__(cls)
@@ -385,30 +350,18 @@ class C[T, U]:
 class D[V](C[V, int]):
     def __init__(self, x: V) -> None: ...
 
-# revealed: ty_extensions.GenericContext[V@D]
-reveal_type(generic_context(D))
-# revealed: ty_extensions.GenericContext[V@D]
-reveal_type(generic_context(into_callable(D)))
-
 reveal_type(D(1))  # revealed: D[Literal[1]]
 ```
 
 ### Generic class inherits `__init__` from generic base class
 
 ```py
-from ty_extensions import generic_context, into_callable
-
 class C[T, U]:
     def __init__(self, t: T, u: U) -> None: ...
 
 class D[T, U](C[T, U]):
     pass
 
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(D))
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(into_callable(D)))
-
 reveal_type(C(1, "str"))  # revealed: C[Literal[1], Literal["str"]]
 reveal_type(D(1, "str"))  # revealed: D[Literal[1], Literal["str"]]
 ```
@@ -418,16 +371,9 @@ reveal_type(D(1, "str"))  # revealed: D[Literal[1], Literal["str"]]
 This is a specific example of the above, since it was reported specifically by a user.
 
 ```py
-from ty_extensions import generic_context, into_callable
-
 class D[T, U](dict[T, U]):
     pass
 
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(D))
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(into_callable(D)))
-
 reveal_type(D(key=1))  # revealed: D[str, int]
 ```
 
@@ -438,15 +384,8 @@ for `tuple`, so we use a different mechanism to make sure it has the right inher
 context. But from the user's point of view, this is another example of the above.)
 
 ```py
-from ty_extensions import generic_context, into_callable
-
 class C[T, U](tuple[T, U]): ...
 
-# revealed: ty_extensions.GenericContext[T@C, U@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C, U@C]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C((1, 2)))  # revealed: C[Literal[1], Literal[2]]
 ```
 
@@ -470,18 +409,11 @@ def func8(t1: tuple[complex, list[int]], t2: tuple[int, *tuple[str, ...]], t3: t
 ### `__init__` is itself generic
 
 ```py
-from ty_extensions import generic_context, into_callable
-
 class C[T]:
     x: T
 
     def __init__[S](self, x: T, y: S) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C, S@__init__]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C(1, 1))  # revealed: C[int]
 reveal_type(C(1, "string"))  # revealed: C[int]
 reveal_type(C(1, True))  # revealed: C[int]
@@ -495,7 +427,6 @@ wrong_innards: C[int] = C("five", 1)
 ```py
 from __future__ import annotations
 from typing import overload
-from ty_extensions import generic_context, into_callable
 
 class C[T]:
     # we need to use the type variable or else the class is bivariant in T, and
@@ -512,11 +443,6 @@ class C[T]:
     def __init__(self, x: int) -> None: ...
     def __init__(self, x: str | bytes | int) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C("string"))  # revealed: C[str]
 reveal_type(C(b"bytes"))  # revealed: C[bytes]
 reveal_type(C(12))  # revealed: C[Unknown]
@@ -544,11 +470,6 @@ class D[T, U]:
     def __init__(self, t: T, u: U) -> None: ...
     def __init__(self, *args) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(D))
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(into_callable(D)))
-
 reveal_type(D("string"))  # revealed: D[str, Literal["string"]]
 reveal_type(D(1))  # revealed: D[str, Literal[1]]
 reveal_type(D(1, "string"))  # revealed: D[Literal[1], Literal["string"]]
@@ -558,42 +479,24 @@ reveal_type(D(1, "string"))  # revealed: D[Literal[1], Literal["string"]]
 
 ```py
 from dataclasses import dataclass
-from ty_extensions import generic_context, into_callable
 
 @dataclass
 class A[T]:
     x: T
 
-# revealed: ty_extensions.GenericContext[T@A]
-reveal_type(generic_context(A))
-# revealed: ty_extensions.GenericContext[T@A]
-reveal_type(generic_context(into_callable(A)))
-
 reveal_type(A(x=1))  # revealed: A[int]
 ```
 
 ### Class typevar has another typevar as a default
 
 ```py
-from ty_extensions import generic_context, into_callable
-
 class C[T, U = T]: ...
 
-# revealed: ty_extensions.GenericContext[T@C, U@C]
-reveal_type(generic_context(C))
-# revealed: ty_extensions.GenericContext[T@C, U@C]
-reveal_type(generic_context(into_callable(C)))
-
 reveal_type(C())  # revealed: C[Unknown, Unknown]
 
 class D[T, U = T]:
     def __init__(self) -> None: ...
 
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(D))
-# revealed: ty_extensions.GenericContext[T@D, U@D]
-reveal_type(generic_context(into_callable(D)))
-
 reveal_type(D())  # revealed: D[Unknown, Unknown]
 ```
 

crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md

@@ -334,14 +334,13 @@ from typing import Callable
 def invoke[A, B](fn: Callable[[A], B], value: A) -> B:
     return fn(value)
 
-def identity[T](x: T) -> T:
+def identity[T](x: T, /) -> T:
     return x
 
-def head[T](xs: list[T]) -> T:
+def head[T](xs: list[T], /) -> T:
     return xs[0]
 
-# TODO: this should be `Literal[1]`
-reveal_type(invoke(identity, 1))  # revealed: Unknown
+reveal_type(invoke(identity, 1))  # revealed: Literal[1]
 
 # TODO: this should be `Unknown | int`
 reveal_type(invoke(head, [1, 2, 3]))  # revealed: Unknown
@@ -583,3 +582,102 @@ def f[T](x: T, y: Not[T]) -> T:
     y = x  # error: [invalid-assignment]
     return x
 ```
+
+## `Callable` parameters
+
+We can recurse into the parameters and return values of `Callable` parameters to infer
+specializations of a generic function.
+
+```py
+from typing import Any, Callable, NoReturn, overload, Self
+
+def accepts_callable[**P, R](callable: Callable[P, R]) -> Callable[P, R]:
+    return callable
+
+def returns_int() -> int:
+    raise NotImplementedError
+
+# revealed: int
+reveal_type(accepts_callable(returns_int)())
+
+class ClassWithoutConstructor: ...
+
+# revealed: ClassWithoutConstructor
+reveal_type(accepts_callable(ClassWithoutConstructor)())
+
+class ClassWithNew:
+    def __new__(cls, *args, **kwargs) -> Self:
+        raise NotImplementedError
+
+# revealed: ClassWithNew
+reveal_type(accepts_callable(ClassWithNew)())
+
+class ClassWithInit:
+    def __init__(self) -> None: ...
+
+# revealed: ClassWithInit
+reveal_type(accepts_callable(ClassWithInit)())
+
+class ClassWithNewAndInit:
+    def __new__(cls, *args, **kwargs) -> Self:
+        raise NotImplementedError
+
+    def __init__(self, x: int) -> None: ...
+
+# revealed: ClassWithNewAndInit
+reveal_type(accepts_callable(ClassWithNewAndInit)())
+
+class Meta(type):
+    def __call__(cls, *args: Any, **kwargs: Any) -> NoReturn:
+        raise NotImplementedError
+
+class ClassWithNoReturnMetatype(metaclass=Meta):
+    def __new__(cls, *args: Any, **kwargs: Any) -> Self:
+        raise NotImplementedError
+
+# revealed: Never
+reveal_type(accepts_callable(ClassWithNoReturnMetatype)())
+
+class Proxy: ...
+
+class ClassWithIgnoredInit:
+    def __new__(cls) -> Proxy:
+        return Proxy()
+
+    def __init__(self, x: int) -> None: ...
+
+# revealed: Proxy
+reveal_type(accepts_callable(ClassWithIgnoredInit)())
+
+class ClassWithOverloadedInit[T]:
+    t: T  # invariant
+
+    @overload
+    def __init__(self: "ClassWithOverloadedInit[int]", x: int) -> None: ...
+    @overload
+    def __init__(self: "ClassWithOverloadedInit[str]", x: str) -> None: ...
+    def __init__(self, x: int | str) -> None: ...
+
+# TODO: These unions are because we don't handle the ParamSpec in accepts_callable, so when
+# inferring a specialization through the Callable we lose the information about how the parameter
+# types distinguish the two overloads.
+# TODO: revealed: ClassWithOverloadedInit[int]
+# revealed: ClassWithOverloadedInit[int] | ClassWithOverloadedInit[str]
+reveal_type(accepts_callable(ClassWithOverloadedInit)(0))
+# TODO: revealed: ClassWithOverloadedInit[str]
+# revealed: ClassWithOverloadedInit[int] | ClassWithOverloadedInit[str]
+reveal_type(accepts_callable(ClassWithOverloadedInit)(""))
+
+class GenericClass[T]:
+    t: T  # invariant
+
+    def __new__(cls, x: list[T], y: list[T]) -> Self:
+        raise NotImplementedError
+
+def _(x: list[str]):
+    # TODO: This fails because we are not propagating GenericClass's generic context into the
+    # Callable that we create for it.
+    # TODO: revealed: GenericClass[str]
+    # revealed: Unknown
+    reveal_type(accepts_callable(GenericClass)(x, x))
+```

crates/ty_python_semantic/resources/mdtest/generics/pep695/paramspec.md

@@ -62,614 +62,3 @@ Other values are invalid.
 def foo[**P = int]() -> None:
     pass
 ```
-
-## Validating `ParamSpec` usage
-
-`ParamSpec` is only valid as the first element to `Callable` or the final element to `Concatenate`.
-
-```py
-from typing import ParamSpec, Callable, Concatenate
-
-def valid[**P](
-    a1: Callable[P, int],
-    a2: Callable[Concatenate[int, P], int],
-) -> None: ...
-def invalid[**P](
-    # TODO: error
-    a1: P,
-    # TODO: error
-    a2: list[P],
-    # TODO: error
-    a3: Callable[[P], int],
-    # TODO: error
-    a4: Callable[..., P],
-    # TODO: error
-    a5: Callable[Concatenate[P, ...], int],
-) -> None: ...
-```
-
-## Validating `P.args` and `P.kwargs` usage
-
-The components of `ParamSpec` i.e., `P.args` and `P.kwargs` are only valid when used as the
-annotated types of `*args` and `**kwargs` respectively.
-
-```py
-from typing import Callable
-
-def foo[**P](c: Callable[P, int]) -> None:
-    def nested1(*args: P.args, **kwargs: P.kwargs) -> None: ...
-
-    # error: [invalid-type-form] "`P.kwargs` is valid only in `**kwargs` annotation: Did you mean `P.args`?"
-    # error: [invalid-type-form] "`P.args` is valid only in `*args` annotation: Did you mean `P.kwargs`?"
-    def nested2(*args: P.kwargs, **kwargs: P.args) -> None: ...
-
-    # TODO: error
-    def nested3(*args: P.args) -> None: ...
-
-    # TODO: error
-    def nested4(**kwargs: P.kwargs) -> None: ...
-
-    # TODO: error
-    def nested5(*args: P.args, x: int, **kwargs: P.kwargs) -> None: ...
-```
-
-And, they need to be used together.
-
-```py
-def foo[**P](c: Callable[P, int]) -> None:
-    # TODO: error
-    def nested1(*args: P.args) -> None: ...
-
-    # TODO: error
-    def nested2(**kwargs: P.kwargs) -> None: ...
-
-class Foo[**P]:
-    # TODO: error
-    args: P.args
-
-    # TODO: error
-    kwargs: P.kwargs
-```
-
-The name of these parameters does not need to be `args` or `kwargs`, it's the annotated type to the
-respective variadic parameter that matters.
-
-```py
-class Foo3[**P]:
-    def method1(self, *paramspec_args: P.args, **paramspec_kwargs: P.kwargs) -> None: ...
-    def method2(
-        self,
-        # error: [invalid-type-form] "`P.kwargs` is valid only in `**kwargs` annotation: Did you mean `P.args`?"
-        *paramspec_args: P.kwargs,
-        # error: [invalid-type-form] "`P.args` is valid only in `*args` annotation: Did you mean `P.kwargs`?"
-        **paramspec_kwargs: P.args,
-    ) -> None: ...
-```
-
-It isn't allowed to annotate an instance attribute either:
-
-```py
-class Foo4[**P]:
-    def __init__(self, fn: Callable[P, int], *args: P.args, **kwargs: P.kwargs) -> None:
-        self.fn = fn
-        # TODO: error
-        self.args: P.args = args
-        # TODO: error
-        self.kwargs: P.kwargs = kwargs
-```
-
-## Semantics of `P.args` and `P.kwargs`
-
-The type of `args` and `kwargs` inside the function is `P.args` and `P.kwargs` respectively instead
-of `tuple[P.args, ...]` and `dict[str, P.kwargs]`.
-
-### Passing `*args` and `**kwargs` to a callable
-
-```py
-from typing import Callable
-
-def f[**P](func: Callable[P, int]) -> Callable[P, None]:
-    def wrapper(*args: P.args, **kwargs: P.kwargs) -> None:
-        reveal_type(args)  # revealed: P@f.args
-        reveal_type(kwargs)  # revealed: P@f.kwargs
-        reveal_type(func(*args, **kwargs))  # revealed: int
-
-        # error: [invalid-argument-type] "Argument is incorrect: Expected `P@f.args`, found `P@f.kwargs`"
-        # error: [invalid-argument-type] "Argument is incorrect: Expected `P@f.kwargs`, found `P@f.args`"
-        reveal_type(func(*kwargs, **args))  # revealed: int
-
-        # error: [invalid-argument-type] "Argument is incorrect: Expected `P@f.args`, found `P@f.kwargs`"
-        reveal_type(func(args, kwargs))  # revealed: int
-
-        # Both parameters are required
-        # TODO: error
-        reveal_type(func())  # revealed: int
-        reveal_type(func(*args))  # revealed: int
-        reveal_type(func(**kwargs))  # revealed: int
-    return wrapper
-```
-
-### Operations on `P.args` and `P.kwargs`
-
-The type of `P.args` and `P.kwargs` behave like a `tuple` and `dict` respectively. Internally, they
-are represented as a type variable that has an upper bound of `tuple[object, ...]` and
-`Top[dict[str, Any]]` respectively.
-
-```py
-from typing import Callable, Any
-
-def f[**P](func: Callable[P, int], *args: P.args, **kwargs: P.kwargs) -> None:
-    reveal_type(args + ("extra",))  # revealed: tuple[object, ...]
-    reveal_type(args + (1, 2, 3))  # revealed: tuple[object, ...]
-    reveal_type(args[0])  # revealed: object
-
-    reveal_type("key" in kwargs)  # revealed: bool
-    reveal_type(kwargs.get("key"))  # revealed: object
-    reveal_type(kwargs["key"])  # revealed: object
-```
-
-## Specializing generic classes explicitly
-
-```py
-from typing import Any, Callable, ParamSpec
-
-class OnlyParamSpec[**P1]:
-    attr: Callable[P1, None]
-
-class TwoParamSpec[**P1, **P2]:
-    attr1: Callable[P1, None]
-    attr2: Callable[P2, None]
-
-class TypeVarAndParamSpec[T1, **P1]:
-    attr: Callable[P1, T1]
-```
-
-Explicit specialization of a generic class involving `ParamSpec` is done by providing either a list
-of types, `...`, or another in-scope `ParamSpec`.
-
-```py
-reveal_type(OnlyParamSpec[[]]().attr)  # revealed: () -> None
-reveal_type(OnlyParamSpec[[int, str]]().attr)  # revealed: (int, str, /) -> None
-reveal_type(OnlyParamSpec[...]().attr)  # revealed: (...) -> None
-
-def func[**P2](c: Callable[P2, None]):
-    reveal_type(OnlyParamSpec[P2]().attr)  # revealed: (**P2@func) -> None
-
-P2 = ParamSpec("P2")
-
-# TODO: error: paramspec is unbound
-reveal_type(OnlyParamSpec[P2]().attr)  # revealed: (...) -> None
-
-# error: [invalid-type-arguments] "No type argument provided for required type variable `P1` of class `OnlyParamSpec`"
-reveal_type(OnlyParamSpec[()]().attr)  # revealed: (...) -> None
-```
-
-An explicit tuple expression (unlike an implicit one that omits the parentheses) is also accepted
-when the `ParamSpec` is the only type variable. But, this isn't recommended is mainly a fallout of
-it having the same AST as the one without the parentheses. Both mypy and Pyright also allow this.
-
-```py
-reveal_type(OnlyParamSpec[(int, str)]().attr)  # revealed: (int, str, /) -> None
-```
-
-<!-- blacken-docs:off -->
-
-```py
-# error: [invalid-syntax]
-reveal_type(OnlyParamSpec[]().attr)  # revealed: (...) -> None
-```
-
-<!-- blacken-docs:on -->
-
-The square brackets can be omitted when `ParamSpec` is the only type variable
-
-```py
-reveal_type(OnlyParamSpec[int, str]().attr)  # revealed: (int, str, /) -> None
-reveal_type(OnlyParamSpec[int,]().attr)  # revealed: (int, /) -> None
-
-# Even when there is only one element
-reveal_type(OnlyParamSpec[Any]().attr)  # revealed: (Any, /) -> None
-reveal_type(OnlyParamSpec[object]().attr)  # revealed: (object, /) -> None
-reveal_type(OnlyParamSpec[int]().attr)  # revealed: (int, /) -> None
-```
-
-But, they cannot be omitted when there are multiple type variables.
-
-```py
-reveal_type(TypeVarAndParamSpec[int, []]().attr)  # revealed: () -> int
-reveal_type(TypeVarAndParamSpec[int, [int, str]]().attr)  # revealed: (int, str, /) -> int
-reveal_type(TypeVarAndParamSpec[int, [str]]().attr)  # revealed: (str, /) -> int
-reveal_type(TypeVarAndParamSpec[int, ...]().attr)  # revealed: (...) -> int
-
-# TODO: error: paramspec is unbound
-reveal_type(TypeVarAndParamSpec[int, P2]().attr)  # revealed: (...) -> Unknown
-# error: [invalid-type-arguments] "Type argument for `ParamSpec` must be"
-reveal_type(TypeVarAndParamSpec[int, int]().attr)  # revealed: (...) -> Unknown
-# error: [invalid-type-arguments] "Type argument for `ParamSpec` must be"
-reveal_type(TypeVarAndParamSpec[int, ()]().attr)  # revealed: (...) -> Unknown
-# error: [invalid-type-arguments] "Type argument for `ParamSpec` must be"
-reveal_type(TypeVarAndParamSpec[int, (int, str)]().attr)  # revealed: (...) -> Unknown
-```
-
-Nor can they be omitted when there are more than one `ParamSpec`.
-
-```py
-p = TwoParamSpec[[int, str], [int]]()
-reveal_type(p.attr1)  # revealed: (int, str, /) -> None
-reveal_type(p.attr2)  # revealed: (int, /) -> None
-
-# error: [invalid-type-arguments] "Type argument for `ParamSpec` must be either a list of types, `ParamSpec`, `Concatenate`, or `...`"
-# error: [invalid-type-arguments] "Type argument for `ParamSpec` must be either a list of types, `ParamSpec`, `Concatenate`, or `...`"
-TwoParamSpec[int, str]
-```
-
-Specializing `ParamSpec` type variable using `typing.Any` isn't explicitly allowed by the spec but
-both mypy and Pyright allow this and there are usages of this in the wild e.g.,
-`staticmethod[Any, Any]`.
-
-```py
-reveal_type(TypeVarAndParamSpec[int, Any]().attr)  # revealed: (...) -> int
-```
-
-## Specialization when defaults are involved
-
-```py
-from typing import Callable, ParamSpec
-
-class ParamSpecWithDefault1[**P1 = [int, str]]:
-    attr: Callable[P1, None]
-
-reveal_type(ParamSpecWithDefault1().attr)  # revealed: (int, str, /) -> None
-reveal_type(ParamSpecWithDefault1[int]().attr)  # revealed: (int, /) -> None
-```
-
-```py
-class ParamSpecWithDefault2[**P1 = ...]:
-    attr: Callable[P1, None]
-
-reveal_type(ParamSpecWithDefault2().attr)  # revealed: (...) -> None
-reveal_type(ParamSpecWithDefault2[int, str]().attr)  # revealed: (int, str, /) -> None
-```
-
-```py
-class ParamSpecWithDefault3[**P1, **P2 = P1]:
-    attr1: Callable[P1, None]
-    attr2: Callable[P2, None]
-
-# `P1` hasn't been specialized, so it defaults to `...` gradual form
-p1 = ParamSpecWithDefault3()
-reveal_type(p1.attr1)  # revealed: (...) -> None
-reveal_type(p1.attr2)  # revealed: (...) -> None
-
-p2 = ParamSpecWithDefault3[[int, str]]()
-reveal_type(p2.attr1)  # revealed: (int, str, /) -> None
-reveal_type(p2.attr2)  # revealed: (int, str, /) -> None
-
-p3 = ParamSpecWithDefault3[[int], [str]]()
-reveal_type(p3.attr1)  # revealed: (int, /) -> None
-reveal_type(p3.attr2)  # revealed: (str, /) -> None
-
-class ParamSpecWithDefault4[**P1 = [int, str], **P2 = P1]:
-    attr1: Callable[P1, None]
-    attr2: Callable[P2, None]
-
-p1 = ParamSpecWithDefault4()
-reveal_type(p1.attr1)  # revealed: (int, str, /) -> None
-reveal_type(p1.attr2)  # revealed: (int, str, /) -> None
-
-p2 = ParamSpecWithDefault4[[int]]()
-reveal_type(p2.attr1)  # revealed: (int, /) -> None
-reveal_type(p2.attr2)  # revealed: (int, /) -> None
-
-p3 = ParamSpecWithDefault4[[int], [str]]()
-reveal_type(p3.attr1)  # revealed: (int, /) -> None
-reveal_type(p3.attr2)  # revealed: (str, /) -> None
-
-P2 = ParamSpec("P2")
-
-# TODO: error: paramspec is out of scope
-class ParamSpecWithDefault5[**P1 = P2]:
-    attr: Callable[P1, None]
-```
-
-## Semantics
-
-Most of these test cases are adopted from the
-[typing documentation on `ParamSpec` semantics](https://typing.python.org/en/latest/spec/generics.html#semantics).
-
-### Return type change using `ParamSpec` once
-
-```py
-from typing import Callable
-
-def converter[**P](func: Callable[P, int]) -> Callable[P, bool]:
-    def wrapper(*args: P.args, **kwargs: P.kwargs) -> bool:
-        func(*args, **kwargs)
-        return True
-    return wrapper
-
-def f1(x: int, y: str) -> int:
-    return 1
-
-# This should preserve all the information about the parameters of `f1`
-f2 = converter(f1)
-
-reveal_type(f2)  # revealed: (x: int, y: str) -> bool
-
-reveal_type(f1(1, "a"))  # revealed: int
-reveal_type(f2(1, "a"))  # revealed: bool
-
-# As it preserves the parameter kinds, the following should work as well
-reveal_type(f2(1, y="a"))  # revealed: bool
-reveal_type(f2(x=1, y="a"))  # revealed: bool
-reveal_type(f2(y="a", x=1))  # revealed: bool
-
-# error: [missing-argument] "No argument provided for required parameter `y`"
-f2(1)
-# error: [invalid-argument-type] "Argument is incorrect: Expected `int`, found `Literal["a"]`"
-f2("a", "b")
-```
-
-The `converter` function act as a decorator here:
-
-```py
-@converter
-def f3(x: int, y: str) -> int:
-    return 1
-
-# TODO: This should reveal `(x: int, y: str) -> bool` but there's a cycle: https://github.com/astral-sh/ty/issues/1729
-reveal_type(f3)  # revealed: ((x: int, y: str) -> bool) | ((x: Divergent, y: Divergent) -> bool)
-
-reveal_type(f3(1, "a"))  # revealed: bool
-reveal_type(f3(x=1, y="a"))  # revealed: bool
-reveal_type(f3(1, y="a"))  # revealed: bool
-reveal_type(f3(y="a", x=1))  # revealed: bool
-
-# TODO: There should only be one error but the type of `f3` is a union: https://github.com/astral-sh/ty/issues/1729
-# error: [missing-argument] "No argument provided for required parameter `y`"
-# error: [missing-argument] "No argument provided for required parameter `y`"
-f3(1)
-# error: [invalid-argument-type] "Argument is incorrect: Expected `int`, found `Literal["a"]`"
-f3("a", "b")
-```
-
-### Return type change using the same `ParamSpec` multiple times
-
-```py
-from typing import Callable
-
-def multiple[**P](func1: Callable[P, int], func2: Callable[P, int]) -> Callable[P, bool]:
-    def wrapper(*args: P.args, **kwargs: P.kwargs) -> bool:
-        func1(*args, **kwargs)
-        func2(*args, **kwargs)
-        return True
-    return wrapper
-```
-
-As per the spec,
-
-> A user may include the same `ParamSpec` multiple times in the arguments of the same function, to
-> indicate a dependency between multiple arguments. In these cases a type checker may choose to
-> solve to a common behavioral supertype (i.e. a set of parameters for which all of the valid calls
-> are valid in both of the subtypes), but is not obligated to do so.
-
-TODO: Currently, we don't do this
-
-```py
-def xy(x: int, y: str) -> int:
-    return 1
-
-def yx(y: int, x: str) -> int:
-    return 2
-
-reveal_type(multiple(xy, xy))  # revealed: (x: int, y: str) -> bool
-
-# The common supertype is `(int, str, /)` which is converting the positional-or-keyword parameters
-# into positional-only parameters because the position of the types are the same.
-# TODO: This shouldn't error
-# error: [invalid-argument-type]
-reveal_type(multiple(xy, yx))  # revealed: (x: int, y: str) -> bool
-
-def keyword_only_with_default_1(*, x: int = 42) -> int:
-    return 1
-
-def keyword_only_with_default_2(*, y: int = 42) -> int:
-    return 2
-
-# The common supertype for two functions with only keyword-only parameters would be an empty
-# parameter list i.e., `()`
-# TODO: This shouldn't error
-# error: [invalid-argument-type]
-# revealed: (*, x: int = Literal[42]) -> bool
-reveal_type(multiple(keyword_only_with_default_1, keyword_only_with_default_2))
-
-def keyword_only1(*, x: int) -> int:
-    return 1
-
-def keyword_only2(*, y: int) -> int:
-    return 2
-
-# On the other hand, combining two functions with only keyword-only parameters does not have a
-# common supertype, so it should result in an error.
-# error: [invalid-argument-type] "Argument to function `multiple` is incorrect: Expected `(*, x: int) -> int`, found `def keyword_only2(*, y: int) -> int`"
-reveal_type(multiple(keyword_only1, keyword_only2))  # revealed: (*, x: int) -> bool
-```
-
-### Constructors of user-defined generic class on `ParamSpec`
-
-```py
-from typing import Callable
-
-class C[**P]:
-    f: Callable[P, int]
-
-    def __init__(self, f: Callable[P, int]) -> None:
-        self.f = f
-
-def f(x: int, y: str) -> bool:
-    return True
-
-c = C(f)
-reveal_type(c.f)  # revealed: (x: int, y: str) -> int
-```
-
-### `ParamSpec` in prepended positional parameters
-
-> If one of these prepended positional parameters contains a free `ParamSpec`, we consider that
-> variable in scope for the purposes of extracting the components of that `ParamSpec`.
-
-```py
-from typing import Callable
-
-def foo1[**P1](func: Callable[P1, int], *args: P1.args, **kwargs: P1.kwargs) -> int:
-    return func(*args, **kwargs)
-
-def foo1_with_extra_arg[**P1](func: Callable[P1, int], extra: str, *args: P1.args, **kwargs: P1.kwargs) -> int:
-    return func(*args, **kwargs)
-
-def foo2[**P2](func: Callable[P2, int], *args: P2.args, **kwargs: P2.kwargs) -> None:
-    foo1(func, *args, **kwargs)
-
-    # error: [invalid-argument-type] "Argument to function `foo1` is incorrect: Expected `P2@foo2.args`, found `Literal[1]`"
-    foo1(func, 1, *args, **kwargs)
-
-    # error: [invalid-argument-type] "Argument to function `foo1_with_extra_arg` is incorrect: Expected `str`, found `P2@foo2.args`"
-    foo1_with_extra_arg(func, *args, **kwargs)
-
-    foo1_with_extra_arg(func, "extra", *args, **kwargs)
-```
-
-Here, the first argument to `f` can specialize `P` to the parameters of the callable passed to it
-which is then used to type the `ParamSpec` components used in `*args` and `**kwargs`.
-
-```py
-def f1(x: int, y: str) -> int:
-    return 1
-
-foo1(f1, 1, "a")
-foo1(f1, x=1, y="a")
-foo1(f1, 1, y="a")
-
-# error: [missing-argument] "No arguments provided for required parameters `x`, `y` of function `foo1`"
-foo1(f1)
-
-# error: [missing-argument] "No argument provided for required parameter `y` of function `foo1`"
-foo1(f1, 1)
-
-# error: [invalid-argument-type] "Argument to function `foo1` is incorrect: Expected `str`, found `Literal[2]`"
-foo1(f1, 1, 2)
-
-# error: [too-many-positional-arguments] "Too many positional arguments to function `foo1`: expected 2, got 3"
-foo1(f1, 1, "a", "b")
-
-# error: [missing-argument] "No argument provided for required parameter `y` of function `foo1`"
-# error: [unknown-argument] "Argument `z` does not match any known parameter of function `foo1`"
-foo1(f1, x=1, z="a")
-```
-
-### Specializing `ParamSpec` with another `ParamSpec`
-
-```py
-class Foo[**P]:
-    def __init__(self, *args: P.args, **kwargs: P.kwargs) -> None:
-        self.args = args
-        self.kwargs = kwargs
-
-def bar[**P](foo: Foo[P]) -> None:
-    reveal_type(foo)  # revealed: Foo[P@bar]
-    reveal_type(foo.args)  # revealed: Unknown | P@bar.args
-    reveal_type(foo.kwargs)  # revealed: Unknown | P@bar.kwargs
-```
-
-ty will check whether the argument after `**` is a mapping type but as instance attribute are
-unioned with `Unknown`, it shouldn't error here.
-
-```py
-from typing import Callable
-
-def baz[**P](fn: Callable[P, None], foo: Foo[P]) -> None:
-    fn(*foo.args, **foo.kwargs)
-```
-
-The `Unknown` can be eliminated by using annotating these attributes with `Final`:
-
-```py
-from typing import Final
-
-class FooWithFinal[**P]:
-    def __init__(self, *args: P.args, **kwargs: P.kwargs) -> None:
-        self.args: Final = args
-        self.kwargs: Final = kwargs
-
-def with_final[**P](foo: FooWithFinal[P]) -> None:
-    reveal_type(foo)  # revealed: FooWithFinal[P@with_final]
-    reveal_type(foo.args)  # revealed: P@with_final.args
-    reveal_type(foo.kwargs)  # revealed: P@with_final.kwargs
-```
-
-### Specializing `Self` when `ParamSpec` is involved
-
-```py
-class Foo[**P]:
-    def method(self, *args: P.args, **kwargs: P.kwargs) -> str:
-        return "hello"
-
-foo = Foo[int, str]()
-
-reveal_type(foo)  # revealed: Foo[(int, str, /)]
-reveal_type(foo.method)  # revealed: bound method Foo[(int, str, /)].method(int, str, /) -> str
-reveal_type(foo.method(1, "a"))  # revealed: str
-```
-
-### Overloads
-
-`overloaded.pyi`:
-
-```pyi
-from typing import overload
-
-@overload
-def int_int(x: int) -> int: ...
-@overload
-def int_int(x: str) -> int: ...
-
-@overload
-def int_str(x: int) -> int: ...
-@overload
-def int_str(x: str) -> str: ...
-
-@overload
-def str_str(x: int) -> str: ...
-@overload
-def str_str(x: str) -> str: ...
-```
-
-```py
-from typing import Callable
-from overloaded import int_int, int_str, str_str
-
-def change_return_type[**P](f: Callable[P, int]) -> Callable[P, str]:
-    def nested(*args: P.args, **kwargs: P.kwargs) -> str:
-        return str(f(*args, **kwargs))
-    return nested
-
-def with_parameters[**P](f: Callable[P, int], *args: P.args, **kwargs: P.kwargs) -> Callable[P, str]:
-    def nested(*args: P.args, **kwargs: P.kwargs) -> str:
-        return str(f(*args, **kwargs))
-    return nested
-
-reveal_type(change_return_type(int_int))  # revealed: Overload[(x: int) -> str, (x: str) -> str]
-
-# TODO: This shouldn't error and should pick the first overload because of the return type
-# error: [invalid-argument-type]
-reveal_type(change_return_type(int_str))  # revealed: Overload[(x: int) -> str, (x: str) -> str]
-
-# error: [invalid-argument-type]
-reveal_type(change_return_type(str_str))  # revealed: Overload[(x: int) -> str, (x: str) -> str]
-
-# TODO: Both of these shouldn't raise an error
-# error: [invalid-argument-type]
-reveal_type(with_parameters(int_int, 1))  # revealed: Overload[(x: int) -> str, (x: str) -> str]
-# error: [invalid-argument-type]
-reveal_type(with_parameters(int_int, "a"))  # revealed: Overload[(x: int) -> str, (x: str) -> str]
-```

crates/ty_python_semantic/resources/mdtest/implicit_type_aliases.md

@@ -77,44 +77,44 @@ IntOrTypeVar = int | T
 TypeVarOrNone = T | None
 NoneOrTypeVar = None | T
 
-reveal_type(IntOrStr)  # revealed: <types.UnionType special form 'int | str'>
-reveal_type(IntOrStrOrBytes1)  # revealed: <types.UnionType special form 'int | str | bytes'>
-reveal_type(IntOrStrOrBytes2)  # revealed: <types.UnionType special form 'int | str | bytes'>
-reveal_type(IntOrStrOrBytes3)  # revealed: <types.UnionType special form 'int | str | bytes'>
-reveal_type(IntOrStrOrBytes4)  # revealed: <types.UnionType special form 'int | str | bytes'>
-reveal_type(IntOrStrOrBytes5)  # revealed: <types.UnionType special form 'int | str | bytes'>
-reveal_type(IntOrStrOrBytes6)  # revealed: <types.UnionType special form 'int | str | bytes'>
-reveal_type(BytesOrIntOrStr)  # revealed: <types.UnionType special form 'bytes | int | str'>
-reveal_type(IntOrNone)  # revealed: <types.UnionType special form 'int | None'>
-reveal_type(NoneOrInt)  # revealed: <types.UnionType special form 'None | int'>
-reveal_type(IntOrStrOrNone)  # revealed: <types.UnionType special form 'int | str | None'>
-reveal_type(NoneOrIntOrStr)  # revealed: <types.UnionType special form 'None | int | str'>
-reveal_type(IntOrAny)  # revealed: <types.UnionType special form 'int | Any'>
-reveal_type(AnyOrInt)  # revealed: <types.UnionType special form 'Any | int'>
-reveal_type(NoneOrAny)  # revealed: <types.UnionType special form 'None | Any'>
-reveal_type(AnyOrNone)  # revealed: <types.UnionType special form 'Any | None'>
-reveal_type(NeverOrAny)  # revealed: <types.UnionType special form 'Any'>
-reveal_type(AnyOrNever)  # revealed: <types.UnionType special form 'Any'>
-reveal_type(UnknownOrInt)  # revealed: <types.UnionType special form 'Unknown | int'>
-reveal_type(IntOrUnknown)  # revealed: <types.UnionType special form 'int | Unknown'>
-reveal_type(StrOrZero)  # revealed: <types.UnionType special form 'str | Literal[0]'>
-reveal_type(ZeroOrStr)  # revealed: <types.UnionType special form 'Literal[0] | str'>
-reveal_type(IntOrLiteralString)  # revealed: <types.UnionType special form 'int | LiteralString'>
-reveal_type(LiteralStringOrInt)  # revealed: <types.UnionType special form 'LiteralString | int'>
-reveal_type(NoneOrTuple)  # revealed: <types.UnionType special form 'None | tuple[int, str]'>
-reveal_type(TupleOrNone)  # revealed: <types.UnionType special form 'tuple[int, str] | None'>
-reveal_type(IntOrAnnotated)  # revealed: <types.UnionType special form 'int | str'>
-reveal_type(AnnotatedOrInt)  # revealed: <types.UnionType special form 'str | int'>
-reveal_type(IntOrOptional)  # revealed: <types.UnionType special form 'int | str | None'>
-reveal_type(OptionalOrInt)  # revealed: <types.UnionType special form 'str | None | int'>
-reveal_type(IntOrTypeOfStr)  # revealed: <types.UnionType special form 'int | type[str]'>
-reveal_type(TypeOfStrOrInt)  # revealed: <types.UnionType special form 'type[str] | int'>
-reveal_type(IntOrCallable)  # revealed: <types.UnionType special form 'int | ((str, /) -> bytes)'>
-reveal_type(CallableOrInt)  # revealed: <types.UnionType special form '((str, /) -> bytes) | int'>
-reveal_type(TypeVarOrInt)  # revealed: <types.UnionType special form 'T@TypeVarOrInt | int'>
-reveal_type(IntOrTypeVar)  # revealed: <types.UnionType special form 'int | T@IntOrTypeVar'>
-reveal_type(TypeVarOrNone)  # revealed: <types.UnionType special form 'T@TypeVarOrNone | None'>
-reveal_type(NoneOrTypeVar)  # revealed: <types.UnionType special form 'None | T@NoneOrTypeVar'>
+reveal_type(IntOrStr)  # revealed: types.UnionType
+reveal_type(IntOrStrOrBytes1)  # revealed: types.UnionType
+reveal_type(IntOrStrOrBytes2)  # revealed: types.UnionType
+reveal_type(IntOrStrOrBytes3)  # revealed: types.UnionType
+reveal_type(IntOrStrOrBytes4)  # revealed: types.UnionType
+reveal_type(IntOrStrOrBytes5)  # revealed: types.UnionType
+reveal_type(IntOrStrOrBytes6)  # revealed: types.UnionType
+reveal_type(BytesOrIntOrStr)  # revealed: types.UnionType
+reveal_type(IntOrNone)  # revealed: types.UnionType
+reveal_type(NoneOrInt)  # revealed: types.UnionType
+reveal_type(IntOrStrOrNone)  # revealed: types.UnionType
+reveal_type(NoneOrIntOrStr)  # revealed: types.UnionType
+reveal_type(IntOrAny)  # revealed: types.UnionType
+reveal_type(AnyOrInt)  # revealed: types.UnionType
+reveal_type(NoneOrAny)  # revealed: types.UnionType
+reveal_type(AnyOrNone)  # revealed: types.UnionType
+reveal_type(NeverOrAny)  # revealed: types.UnionType
+reveal_type(AnyOrNever)  # revealed: types.UnionType
+reveal_type(UnknownOrInt)  # revealed: types.UnionType
+reveal_type(IntOrUnknown)  # revealed: types.UnionType
+reveal_type(StrOrZero)  # revealed: types.UnionType
+reveal_type(ZeroOrStr)  # revealed: types.UnionType
+reveal_type(IntOrLiteralString)  # revealed: types.UnionType
+reveal_type(LiteralStringOrInt)  # revealed: types.UnionType
+reveal_type(NoneOrTuple)  # revealed: types.UnionType
+reveal_type(TupleOrNone)  # revealed: types.UnionType
+reveal_type(IntOrAnnotated)  # revealed: types.UnionType
+reveal_type(AnnotatedOrInt)  # revealed: types.UnionType
+reveal_type(IntOrOptional)  # revealed: types.UnionType
+reveal_type(OptionalOrInt)  # revealed: types.UnionType
+reveal_type(IntOrTypeOfStr)  # revealed: types.UnionType
+reveal_type(TypeOfStrOrInt)  # revealed: types.UnionType
+reveal_type(IntOrCallable)  # revealed: types.UnionType
+reveal_type(CallableOrInt)  # revealed: types.UnionType
+reveal_type(TypeVarOrInt)  # revealed: types.UnionType
+reveal_type(IntOrTypeVar)  # revealed: types.UnionType
+reveal_type(TypeVarOrNone)  # revealed: types.UnionType
+reveal_type(NoneOrTypeVar)  # revealed: types.UnionType
 
 def _(
     int_or_str: IntOrStr,
@@ -295,7 +295,7 @@ X = Foo | Bar
 # In an ideal world, perhaps we would respect `Meta.__or__` here and reveal `str`?
 # But we still need to record what the elements are, since (according to the typing spec)
 # `X` is still a valid type alias
-reveal_type(X)  # revealed: <types.UnionType special form 'Foo | Bar'>
+reveal_type(X)  # revealed: types.UnionType
 
 def f(obj: X):
     reveal_type(obj)  # revealed: Foo | Bar
@@ -391,17 +391,16 @@ MyOptional = T | None
 
 reveal_type(MyList)  # revealed: <class 'list[T@MyList]'>
 reveal_type(MyDict)  # revealed: <class 'dict[T@MyDict, U@MyDict]'>
-reveal_type(MyType)  # revealed: <special form 'type[T@MyType]'>
+reveal_type(MyType)  # revealed: GenericAlias
 reveal_type(IntAndType)  # revealed: <class 'tuple[int, T@IntAndType]'>
 reveal_type(Pair)  # revealed: <class 'tuple[T@Pair, T@Pair]'>
 reveal_type(Sum)  # revealed: <class 'tuple[T@Sum, U@Sum]'>
-reveal_type(ListOrTuple)  # revealed: <types.UnionType special form 'list[T@ListOrTuple] | tuple[T@ListOrTuple, ...]'>
-# revealed: <types.UnionType special form 'list[T@ListOrTupleLegacy] | tuple[T@ListOrTupleLegacy, ...]'>
-reveal_type(ListOrTupleLegacy)
-reveal_type(MyCallable)  # revealed: <typing.Callable special form '(**P@MyCallable) -> T@MyCallable'>
-reveal_type(AnnotatedType)  # revealed: <special form 'typing.Annotated[T@AnnotatedType, <metadata>]'>
+reveal_type(ListOrTuple)  # revealed: types.UnionType
+reveal_type(ListOrTupleLegacy)  # revealed: types.UnionType
+reveal_type(MyCallable)  # revealed: @Todo(Callable[..] specialized with ParamSpec)
+reveal_type(AnnotatedType)  # revealed: <typing.Annotated special form>
 reveal_type(TransparentAlias)  # revealed: typing.TypeVar
-reveal_type(MyOptional)  # revealed: <types.UnionType special form 'T@MyOptional | None'>
+reveal_type(MyOptional)  # revealed: types.UnionType
 
 def _(
     list_of_ints: MyList[int],
@@ -425,7 +424,8 @@ def _(
     reveal_type(int_and_bytes)  # revealed: tuple[int, bytes]
     reveal_type(list_or_tuple)  # revealed: list[int] | tuple[int, ...]
     reveal_type(list_or_tuple_legacy)  # revealed: list[int] | tuple[int, ...]
-    reveal_type(my_callable)  # revealed: (str, bytes, /) -> int
+    # TODO: This should be `(str, bytes) -> int`
+    reveal_type(my_callable)  # revealed: @Todo(Callable[..] specialized with ParamSpec)
     reveal_type(annotated_int)  # revealed: int
     reveal_type(transparent_alias)  # revealed: int
     reveal_type(optional_int)  # revealed: int | None
@@ -456,13 +456,13 @@ AnnotatedInt = AnnotatedType[int]
 SubclassOfInt = MyType[int]
 CallableIntToStr = MyCallable[[int], str]
 
-reveal_type(IntsOrNone)  # revealed: <types.UnionType special form 'list[int] | None'>
-reveal_type(IntsOrStrs)  # revealed: <types.UnionType special form 'tuple[int, int] | tuple[str, str]'>
+reveal_type(IntsOrNone)  # revealed: types.UnionType
+reveal_type(IntsOrStrs)  # revealed: types.UnionType
 reveal_type(ListOfPairs)  # revealed: <class 'list[tuple[str, str]]'>
-reveal_type(ListOrTupleOfInts)  # revealed: <types.UnionType special form 'list[int] | tuple[int, ...]'>
-reveal_type(AnnotatedInt)  # revealed: <special form 'typing.Annotated[int, <metadata>]'>
-reveal_type(SubclassOfInt)  # revealed: <special form 'type[int]'>
-reveal_type(CallableIntToStr)  # revealed: <typing.Callable special form '(int, /) -> str'>
+reveal_type(ListOrTupleOfInts)  # revealed: types.UnionType
+reveal_type(AnnotatedInt)  # revealed: <typing.Annotated special form>
+reveal_type(SubclassOfInt)  # revealed: GenericAlias
+reveal_type(CallableIntToStr)  # revealed: @Todo(Callable[..] specialized with ParamSpec)
 
 def _(
     ints_or_none: IntsOrNone,
@@ -479,7 +479,8 @@ def _(
     reveal_type(list_or_tuple_of_ints)  # revealed: list[int] | tuple[int, ...]
     reveal_type(annotated_int)  # revealed: int
     reveal_type(subclass_of_int)  # revealed: type[int]
-    reveal_type(callable_int_to_str)  # revealed: (int, /) -> str
+    # TODO: This should be `(int, /) -> str`
+    reveal_type(callable_int_to_str)  # revealed: @Todo(Callable[..] specialized with ParamSpec)
 ```
 
 A generic implicit type alias can also be used in another generic implicit type alias:
@@ -494,8 +495,8 @@ MyOtherType = MyType[T]
 TypeOrList = MyType[B] | MyList[B]
 
 reveal_type(MyOtherList)  # revealed: <class 'list[T@MyOtherList]'>
-reveal_type(MyOtherType)  # revealed: <special form 'type[T@MyOtherType]'>
-reveal_type(TypeOrList)  # revealed: <types.UnionType special form 'type[B@TypeOrList] | list[B@TypeOrList]'>
+reveal_type(MyOtherType)  # revealed: GenericAlias
+reveal_type(TypeOrList)  # revealed: types.UnionType
 
 def _(
     list_of_ints: MyOtherList[int],
@@ -532,7 +533,8 @@ def _(
     reveal_type(unknown_and_unknown)  # revealed: tuple[Unknown, Unknown]
     reveal_type(list_or_tuple)  # revealed: list[Unknown] | tuple[Unknown, ...]
     reveal_type(list_or_tuple_legacy)  # revealed: list[Unknown] | tuple[Unknown, ...]
-    reveal_type(my_callable)  # revealed: (...) -> Unknown
+    # TODO: should be (...) -> Unknown
+    reveal_type(my_callable)  # revealed: @Todo(Callable[..] specialized with ParamSpec)
     reveal_type(annotated_unknown)  # revealed: Unknown
     reveal_type(optional_unknown)  # revealed: Unknown | None
 ```
@@ -896,7 +898,7 @@ from typing import Optional
 
 MyOptionalInt = Optional[int]
 
-reveal_type(MyOptionalInt)  # revealed: <types.UnionType special form 'int | None'>
+reveal_type(MyOptionalInt)  # revealed: types.UnionType
 
 def _(optional_int: MyOptionalInt):
     reveal_type(optional_int)  # revealed: int | None
@@ -929,9 +931,9 @@ MyLiteralString = LiteralString
 MyNoReturn = NoReturn
 MyNever = Never
 
-reveal_type(MyLiteralString)  # revealed: <special form 'typing.LiteralString'>
-reveal_type(MyNoReturn)  # revealed: <special form 'typing.NoReturn'>
-reveal_type(MyNever)  # revealed: <special form 'typing.Never'>
+reveal_type(MyLiteralString)  # revealed: typing.LiteralString
+reveal_type(MyNoReturn)  # revealed: typing.NoReturn
+reveal_type(MyNever)  # revealed: typing.Never
 
 def _(
     ls: MyLiteralString,
@@ -984,8 +986,8 @@ from typing import Union
 IntOrStr = Union[int, str]
 IntOrStrOrBytes = Union[int, Union[str, bytes]]
 
-reveal_type(IntOrStr)  # revealed: <types.UnionType special form 'int | str'>
-reveal_type(IntOrStrOrBytes)  # revealed: <types.UnionType special form 'int | str | bytes'>
+reveal_type(IntOrStr)  # revealed: types.UnionType
+reveal_type(IntOrStrOrBytes)  # revealed: types.UnionType
 
 def _(
     int_or_str: IntOrStr,
@@ -1013,7 +1015,7 @@ An empty `typing.Union` leads to a `TypeError` at runtime, so we emit an error.
 # error: [invalid-type-form] "`typing.Union` requires at least one type argument"
 EmptyUnion = Union[()]
 
-reveal_type(EmptyUnion)  # revealed: <types.UnionType special form 'Never'>
+reveal_type(EmptyUnion)  # revealed: types.UnionType
 
 def _(empty: EmptyUnion):
     reveal_type(empty)  # revealed: Never
@@ -1058,14 +1060,14 @@ SubclassOfG = type[G]
 SubclassOfGInt = type[G[int]]
 SubclassOfP = type[P]
 
-reveal_type(SubclassOfA)  # revealed: <special form 'type[A]'>
-reveal_type(SubclassOfAny)  # revealed: <special form 'type[Any]'>
-reveal_type(SubclassOfAOrB1)  # revealed: <special form 'type[A | B]'>
-reveal_type(SubclassOfAOrB2)  # revealed: <types.UnionType special form 'type[A] | type[B]'>
-reveal_type(SubclassOfAOrB3)  # revealed: <types.UnionType special form 'type[A] | type[B]'>
-reveal_type(SubclassOfG)  # revealed: <special form 'type[G[Unknown]]'>
-reveal_type(SubclassOfGInt)  # revealed: <special form 'type[G[int]]'>
-reveal_type(SubclassOfP)  # revealed: <special form 'type[P]'>
+reveal_type(SubclassOfA)  # revealed: GenericAlias
+reveal_type(SubclassOfAny)  # revealed: GenericAlias
+reveal_type(SubclassOfAOrB1)  # revealed: GenericAlias
+reveal_type(SubclassOfAOrB2)  # revealed: types.UnionType
+reveal_type(SubclassOfAOrB3)  # revealed: types.UnionType
+reveal_type(SubclassOfG)  # revealed: GenericAlias
+reveal_type(SubclassOfGInt)  # revealed: GenericAlias
+reveal_type(SubclassOfP)  # revealed: GenericAlias
 
 def _(
     subclass_of_a: SubclassOfA,
@@ -1146,14 +1148,14 @@ SubclassOfG = Type[G]
 SubclassOfGInt = Type[G[int]]
 SubclassOfP = Type[P]
 
-reveal_type(SubclassOfA)  # revealed: <special form 'type[A]'>
-reveal_type(SubclassOfAny)  # revealed: <special form 'type[Any]'>
-reveal_type(SubclassOfAOrB1)  # revealed: <special form 'type[A | B]'>
-reveal_type(SubclassOfAOrB2)  # revealed: <types.UnionType special form 'type[A] | type[B]'>
-reveal_type(SubclassOfAOrB3)  # revealed: <types.UnionType special form 'type[A] | type[B]'>
-reveal_type(SubclassOfG)  # revealed: <special form 'type[G[Unknown]]'>
-reveal_type(SubclassOfGInt)  # revealed: <special form 'type[G[int]]'>
-reveal_type(SubclassOfP)  # revealed: <special form 'type[P]'>
+reveal_type(SubclassOfA)  # revealed: GenericAlias
+reveal_type(SubclassOfAny)  # revealed: GenericAlias
+reveal_type(SubclassOfAOrB1)  # revealed: GenericAlias
+reveal_type(SubclassOfAOrB2)  # revealed: types.UnionType
+reveal_type(SubclassOfAOrB3)  # revealed: types.UnionType
+reveal_type(SubclassOfG)  # revealed: GenericAlias
+reveal_type(SubclassOfGInt)  # revealed: GenericAlias
+reveal_type(SubclassOfP)  # revealed: GenericAlias
 
 def _(
     subclass_of_a: SubclassOfA,
@@ -1268,25 +1270,25 @@ DefaultDictOrNone = DefaultDict[str, int] | None
 DequeOrNone = Deque[str] | None
 OrderedDictOrNone = OrderedDict[str, int] | None
 
-reveal_type(NoneOrList)  # revealed: <types.UnionType special form 'None | list[str]'>
-reveal_type(NoneOrSet)  # revealed: <types.UnionType special form 'None | set[str]'>
-reveal_type(NoneOrDict)  # revealed: <types.UnionType special form 'None | dict[str, int]'>
-reveal_type(NoneOrFrozenSet)  # revealed: <types.UnionType special form 'None | frozenset[str]'>
-reveal_type(NoneOrChainMap)  # revealed: <types.UnionType special form 'None | ChainMap[str, int]'>
-reveal_type(NoneOrCounter)  # revealed: <types.UnionType special form 'None | Counter[str]'>
-reveal_type(NoneOrDefaultDict)  # revealed: <types.UnionType special form 'None | defaultdict[str, int]'>
-reveal_type(NoneOrDeque)  # revealed: <types.UnionType special form 'None | deque[str]'>
-reveal_type(NoneOrOrderedDict)  # revealed: <types.UnionType special form 'None | OrderedDict[str, int]'>
+reveal_type(NoneOrList)  # revealed: types.UnionType
+reveal_type(NoneOrSet)  # revealed: types.UnionType
+reveal_type(NoneOrDict)  # revealed: types.UnionType
+reveal_type(NoneOrFrozenSet)  # revealed: types.UnionType
+reveal_type(NoneOrChainMap)  # revealed: types.UnionType
+reveal_type(NoneOrCounter)  # revealed: types.UnionType
+reveal_type(NoneOrDefaultDict)  # revealed: types.UnionType
+reveal_type(NoneOrDeque)  # revealed: types.UnionType
+reveal_type(NoneOrOrderedDict)  # revealed: types.UnionType
 
-reveal_type(ListOrNone)  # revealed: <types.UnionType special form 'list[int] | None'>
-reveal_type(SetOrNone)  # revealed: <types.UnionType special form 'set[int] | None'>
-reveal_type(DictOrNone)  # revealed: <types.UnionType special form 'dict[str, int] | None'>
-reveal_type(FrozenSetOrNone)  # revealed: <types.UnionType special form 'frozenset[int] | None'>
-reveal_type(ChainMapOrNone)  # revealed: <types.UnionType special form 'ChainMap[str, int] | None'>
-reveal_type(CounterOrNone)  # revealed: <types.UnionType special form 'Counter[str] | None'>
-reveal_type(DefaultDictOrNone)  # revealed: <types.UnionType special form 'defaultdict[str, int] | None'>
-reveal_type(DequeOrNone)  # revealed: <types.UnionType special form 'deque[str] | None'>
-reveal_type(OrderedDictOrNone)  # revealed: <types.UnionType special form 'OrderedDict[str, int] | None'>
+reveal_type(ListOrNone)  # revealed: types.UnionType
+reveal_type(SetOrNone)  # revealed: types.UnionType
+reveal_type(DictOrNone)  # revealed: types.UnionType
+reveal_type(FrozenSetOrNone)  # revealed: types.UnionType
+reveal_type(ChainMapOrNone)  # revealed: types.UnionType
+reveal_type(CounterOrNone)  # revealed: types.UnionType
+reveal_type(DefaultDictOrNone)  # revealed: types.UnionType
+reveal_type(DequeOrNone)  # revealed: types.UnionType
+reveal_type(OrderedDictOrNone)  # revealed: types.UnionType
 
 def _(
     none_or_list: NoneOrList,
@@ -1379,9 +1381,9 @@ CallableNoArgs = Callable[[], None]
 BasicCallable = Callable[[int, str], bytes]
 GradualCallable = Callable[..., str]
 
-reveal_type(CallableNoArgs)  # revealed: <typing.Callable special form '() -> None'>
-reveal_type(BasicCallable)  # revealed: <typing.Callable special form '(int, str, /) -> bytes'>
-reveal_type(GradualCallable)  # revealed: <typing.Callable special form '(...) -> str'>
+reveal_type(CallableNoArgs)  # revealed: GenericAlias
+reveal_type(BasicCallable)  # revealed: GenericAlias
+reveal_type(GradualCallable)  # revealed: GenericAlias
 
 def _(
     callable_no_args: CallableNoArgs,
@@ -1413,8 +1415,8 @@ InvalidCallable1 = Callable[[int]]
 # error: [invalid-type-form] "The first argument to `Callable` must be either a list of types, ParamSpec, Concatenate, or `...`"
 InvalidCallable2 = Callable[int, str]
 
-reveal_type(InvalidCallable1)  # revealed: <typing.Callable special form '(...) -> Unknown'>
-reveal_type(InvalidCallable2)  # revealed: <typing.Callable special form '(...) -> Unknown'>
+reveal_type(InvalidCallable1)  # revealed: GenericAlias
+reveal_type(InvalidCallable2)  # revealed: GenericAlias
 
 def _(invalid_callable1: InvalidCallable1, invalid_callable2: InvalidCallable2):
     reveal_type(invalid_callable1)  # revealed: (...) -> Unknown

crates/ty_python_semantic/resources/mdtest/import/conventions.md

@@ -53,8 +53,8 @@ in `import os.path as os.path` the `os.path` is not a valid identifier.
 ```py
 from b import Any, Literal, foo
 
-reveal_type(Any)  # revealed: <special form 'typing.Any'>
-reveal_type(Literal)  # revealed: <special form 'typing.Literal'>
+reveal_type(Any)  # revealed: typing.Any
+reveal_type(Literal)  # revealed: typing.Literal
 reveal_type(foo)  # revealed: <module 'foo'>
 ```
 
@@ -132,7 +132,7 @@ reveal_type(Any)  # revealed: Unknown
 ```pyi
 from typing import Any
 
-reveal_type(Any)  # revealed: <special form 'typing.Any'>
+reveal_type(Any)  # revealed: typing.Any
 ```
 
 ## Nested mixed re-export and not
@@ -169,7 +169,7 @@ reveal_type(Any)  # revealed: Unknown
 ```pyi
 from typing import Any
 
-reveal_type(Any)  # revealed: <special form 'typing.Any'>
+reveal_type(Any)  # revealed: typing.Any
 ```
 
 ## Exported as different name

crates/ty_python_semantic/resources/mdtest/import/site_packages_discovery.md

@@ -22,10 +22,10 @@ python = "/.venv"
 `/.venv/pyvenv.cfg`:
 
 ```cfg
-home = /do/re/mi//cpython-3.13.2-macos-aarch64-none/bin
+home = /doo/doo/wop/cpython-3.13.2-macos-aarch64-none/bin
 ```
 
-`/do/re/mi//cpython-3.13.2-macos-aarch64-none/bin/python`:
+`/doo/doo/wop/cpython-3.13.2-macos-aarch64-none/bin/python`:
 
 ```text
 ```
@@ -54,11 +54,11 @@ python = "/.venv"
 `/.venv/pyvenv.cfg`:
 
 ```cfg
-home = /do/re/mi//cpython-3.13.2-macos-aarch64-none/bin
+home = /doo/doo/wop/cpython-3.13.2-macos-aarch64-none/bin
 version = wut
 ```
 
-`/do/re/mi//cpython-3.13.2-macos-aarch64-none/bin/python`:
+`/doo/doo/wop/cpython-3.13.2-macos-aarch64-none/bin/python`:
 
 ```text
 ```
@@ -87,11 +87,11 @@ python = "/.venv"
 `/.venv/pyvenv.cfg`:
 
 ```cfg
-home = /do/re/mi//cpython-3.13.2-macos-aarch64-none/bin
+home = /doo/doo/wop/cpython-3.13.2-macos-aarch64-none/bin
 version_info = no-really-wut
 ```
 
-`/do/re/mi//cpython-3.13.2-macos-aarch64-none/bin/python`:
+`/doo/doo/wop/cpython-3.13.2-macos-aarch64-none/bin/python`:
 
 ```text
 ```
@@ -132,7 +132,7 @@ python = "/.venv"
 `/.venv/pyvenv.cfg`:
 
 ```cfg
-home = /do/re/mi//cpython-3.13.2-macos-aarch64-none/bin
+home = /doo/doo/wop/cpython-3.13.2-macos-aarch64-none/bin
 implementation = CPython
 uv = 0.7.6
 version_info = 3.13.2
@@ -141,7 +141,7 @@ prompt = ruff
 extends-environment = /.other-environment
 ```
 
-`/do/re/mi//cpython-3.13.2-macos-aarch64-none/bin/python`:
+`/doo/doo/wop/cpython-3.13.2-macos-aarch64-none/bin/python`:
 
 ```text
 ```
@@ -182,12 +182,12 @@ python = "/.venv"
 `/.venv/pyvenv.cfg`:
 
 ```cfg
-home = /do/re/mi//cpython-3.13.2-macos-aarch64-none/bin
+home = /doo/doo/wop/cpython-3.13.2-macos-aarch64-none/bin
 version_info = 3.13
 command = /.pyenv/versions/3.13.3/bin/python3.13 -m venv --without-pip --prompt="python-default/3.13.3" /somewhere-else/python/virtualenvs/python-default/3.13.3
 ```
 
-`/do/re/mi//cpython-3.13.2-macos-aarch64-none/bin/python`:
+`/doo/doo/wop/cpython-3.13.2-macos-aarch64-none/bin/python`:
 
 ```text
 ```

crates/ty_python_semantic/resources/mdtest/import/star.md

@@ -1336,69 +1336,6 @@ reveal_type(g)  # revealed: Unknown
 reveal_type(h)  # revealed: Unknown
 ```
 
-## Star-imports can affect member states
-
-If a star-import pulls in a symbol that was previously defined in the importing module (e.g. `obj`),
-it can affect the state of associated member expressions (e.g. `obj.attr` or `obj[0]`). In the test
-below, note how the types of the corresponding attribute expressions change after the star import
-affects the object:
-
-`common.py`:
-
-```py
-class C:
-    attr: int | None
-```
-
-`exporter.py`:
-
-```py
-from common import C
-
-def flag() -> bool:
-    return True
-
-should_be_imported: C = C()
-
-if flag():
-    might_be_imported: C = C()
-
-if False:
-    should_not_be_imported: C = C()
-```
-
-`main.py`:
-
-```py
-from common import C
-
-should_be_imported = C()
-might_be_imported = C()
-should_not_be_imported = C()
-
-# We start with the plain attribute types:
-reveal_type(should_be_imported.attr)  # revealed: int | None
-reveal_type(might_be_imported.attr)  # revealed: int | None
-reveal_type(should_not_be_imported.attr)  # revealed: int | None
-
-# Now we narrow the types by assignment:
-should_be_imported.attr = 1
-might_be_imported.attr = 1
-should_not_be_imported.attr = 1
-
-reveal_type(should_be_imported.attr)  # revealed: Literal[1]
-reveal_type(might_be_imported.attr)  # revealed: Literal[1]
-reveal_type(should_not_be_imported.attr)  # revealed: Literal[1]
-
-# This star import adds bindings for `should_be_imported` and `might_be_imported`:
-from exporter import *
-
-# As expected, narrowing is "reset" for the first two variables, but not for the third:
-reveal_type(should_be_imported.attr)  # revealed: int | None
-reveal_type(might_be_imported.attr)  # revealed: int | None
-reveal_type(should_not_be_imported.attr)  # revealed: Literal[1]
-```
-
 ## Cyclic star imports
 
 Believe it or not, this code does *not* raise an exception at runtime!
@@ -1437,7 +1374,7 @@ are present due to `*` imports.
 import collections.abc
 
 reveal_type(collections.abc.Sequence)  # revealed: <class 'Sequence'>
-reveal_type(collections.abc.Callable)  # revealed: <special form 'typing.Callable'>
+reveal_type(collections.abc.Callable)  # revealed: typing.Callable
 reveal_type(collections.abc.Set)  # revealed: <class 'AbstractSet'>
 ```
 

crates/ty_python_semantic/resources/mdtest/import/workspaces.md

@@ -6,15 +6,6 @@ python file in some random workspace, and so we need to be more tolerant of situ
 fly in a published package, cases where we're not configured as well as we'd like, or cases where
 two projects in a monorepo have conflicting definitions (but we want to analyze both at once).
 
-In practice these tests cover what we call "desperate module resolution" which, when an import
-fails, results in us walking up the ancestor directories of the importing file and trying those as
-"desperate search-paths".
-
-Currently desperate search-paths are restricted to subdirectories of the first-party search-path
-(the directory you're running `ty` in). Currently we only consider one desperate search-path: the
-closest ancestor directory containing a `pyproject.toml`. In the future we may want to try every
-ancestor `pyproject.toml` or every ancestor directory.
-
 ## Invalid Names
 
 While you can't syntactically refer to a module with an invalid name (i.e. one with a `-`, or that
@@ -27,10 +18,9 @@ strings and does in fact allow syntactically invalid module names.
 
 ### Current File Is Invalid Module Name
 
-Relative and absolute imports should resolve fine in a file that isn't a valid module name (in this
-case, it could be imported via `importlib.import_module`).
+Relative and absolute imports should resolve fine in a file that isn't a valid module name.
 
-`tests/my-mod.py`:
+`my-main.py`:
 
 ```py
 # TODO: there should be no errors in this file
@@ -47,13 +37,13 @@ reveal_type(mod2.y)  # revealed: Unknown
 reveal_type(mod3.z)  # revealed: int
 ```
 
-`tests/mod1.py`:
+`mod1.py`:
 
 ```py
 x: int = 1
 ```
 
-`tests/mod2.py`:
+`mod2.py`:
 
 ```py
 y: int = 2
@@ -67,16 +57,13 @@ z: int = 2
 
 ### Current Directory Is Invalid Module Name
 
-If python files are rooted in a directory with an invalid module name and they relatively import
-each other, there's probably no coherent explanation for what's going on and it's fine that the
-relative import don't resolve (but maybe we could provide some good diagnostics).
+Relative and absolute imports should resolve fine in a dir that isn't a valid module name.
 
-This is a case that sufficient desperation might "accidentally" make work, so it's included here as
-a canary in the coal mine.
-
-`my-tests/mymod.py`:
+`my-tests/main.py`:
 
 ```py
+# TODO: there should be no errors in this file
+
 # error: [unresolved-import]
 from .mod1 import x
 
@@ -107,97 +94,46 @@ y: int = 2
 z: int = 2
 ```
 
-### Ancestor Directory Is Invalid Module Name
+### Current Directory Is Invalid Package Name
 
-Relative and absolute imports *could* resolve fine in the first-party search-path, even if one of
-the ancestor dirs is an invalid module. i.e. in this case we will be inclined to compute module
-names like `my-proj.tests.mymod`, but it could be that in practice the user always runs this code
-rooted in the `my-proj` directory.
+Relative and absolute imports should resolve fine in a dir that isn't a valid package name, even if
+it contains an `__init__.py`:
 
-This case is hard for us to detect and handle in a principled way, but two more extreme kinds of
-desperation could handle this:
-
-- try every ancestor as a desperate search-path
-- try the closest ancestor with an invalid module name as a desperate search-path
-
-The second one is a bit messed up because it could result in situations where someone can get a
-worse experience because a directory happened to *not* be invalid as a module name (`myproj` or
-`my_proj`).
-
-`my-proj/tests/mymod.py`:
+`my-tests/__init__.py`:
 
 ```py
-# TODO: it would be *nice* if there were no errors in this file
+```
+
+`my-tests/main.py`:
+
+```py
+# TODO: there should be no errors in this file
 
 # error: [unresolved-import]
 from .mod1 import x
 
 # error: [unresolved-import]
 from . import mod2
-
-# error: [unresolved-import]
 import mod3
 
 reveal_type(x)  # revealed: Unknown
 reveal_type(mod2.y)  # revealed: Unknown
-reveal_type(mod3.z)  # revealed: Unknown
-```
-
-`my-proj/tests/mod1.py`:
-
-```py
-x: int = 1
-```
-
-`my-proj/tests/mod2.py`:
-
-```py
-y: int = 2
-```
-
-`my-proj/mod3.py`:
-
-```py
-z: int = 2
-```
-
-### Ancestor Directory Above `pyproject.toml` is invalid
-
-Like the previous tests but with a `pyproject.toml` existing between the invalid name and the python
-files. This is an "easier" case in case we use the `pyproject.toml` as a hint about what's going on.
-
-`my-proj/pyproject.toml`:
-
-```text
-name = "my_proj"
-version = "0.1.0"
-```
-
-`my-proj/tests/main.py`:
-
-```py
-from .mod1 import x
-from . import mod2
-import mod3
-
-reveal_type(x)  # revealed: int
-reveal_type(mod2.y)  # revealed: int
 reveal_type(mod3.z)  # revealed: int
 ```
 
-`my-proj/tests/mod1.py`:
+`my-tests/mod1.py`:
 
 ```py
 x: int = 1
 ```
 
-`my-proj/tests/mod2.py`:
+`my-tests/mod2.py`:
 
 ```py
 y: int = 2
 ```
 
-`my-proj/mod3.py`:
+`mod3.py`:
 
 ```py
 z: int = 2
@@ -205,7 +141,7 @@ z: int = 2
 
 ## Multiple Projects
 
-It's common for a monorepo to define many separate projects that may or may not depend on each other
+It's common for a monorepo to define many separate projects that may or may not depend on eachother
 and are stitched together with a package manager like `uv` or `poetry`, often as editables. In this
 case, especially when running as an LSP, we want to be able to analyze all of the projects at once,
 allowing us to reuse results between projects, without getting confused about things that only make
@@ -214,7 +150,7 @@ sense when analyzing the project separately.
 The following tests will feature two projects, `a` and `b` where the "real" packages are found under
 `src/` subdirectories (and we've been configured to understand that), but each project also contains
 other python files in their roots or subdirectories that contains python files which relatively
-import each other and also absolutely import the main package of the project. All of these imports
+import eachother and also absolutely import the main package of the project. All of these imports
 *should* resolve.
 
 Often the fact that there is both an `a` and `b` project seemingly won't matter, but many possible
@@ -228,36 +164,13 @@ following examples include them in case they help.
 
 Here we have fairly typical situation where there are two projects `aproj` and `bproj` where the
 "real" packages are found under `src/` subdirectories, but each project also contains a `tests/`
-directory that contains python files which relatively import each other and also absolutely import
+directory that contains python files which relatively import eachother and also absolutely import
 the package they test. All of these imports *should* resolve.
 
 ```toml
 [environment]
-# Setup a venv with editables for aproj/src/ and bproj/src/
-python = "/.venv"
-```
-
-`/.venv/pyvenv.cfg`:
-
-```cfg
-home = /do/re/mi//cpython-3.13.2-macos-aarch64-none/bin
-```
-
-`/do/re/mi//cpython-3.13.2-macos-aarch64-none/bin/python`:
-
-```text
-```
-
-`/.venv/<path-to-site-packages>/a.pth`:
-
-```pth
-aproj/src/
-```
-
-`/.venv/<path-to-site-packages>/b.pth`:
-
-```pth
-bproj/src/
+# This is similar to what we would compute for installed editables
+extra-paths = ["aproj/src/", "bproj/src/"]
 ```
 
 `aproj/tests/test1.py`:
@@ -326,60 +239,16 @@ version = "0.1.0"
 y: str = "20"
 ```
 
-### Tests Directory With Ambiguous Project Directories Via Editables
+### Tests Directory With Ambiguous Project Directories
 
 The same situation as the previous test but instead of the project `a` being in a directory `aproj`
 to disambiguate, we now need to avoid getting confused about whether `a/` or `a/src/a/` is the
 package `a` while still resolving imports.
 
-Unfortunately this is a quite difficult square to circle as `a/` is a namespace package of `a` and
-`a/src/a/` is a regular package of `a`. **This is a very bad situation you're not supposed to ever
-create, and we are now very sensitive to precise search-path ordering.**
-
-Here the use of editables means that `a/` has higher priority than `a/src/a/`.
-
-Somehow this results in `a/tests/test1.py` being able to resolve `.setup` but not `.`.
-
-My best guess is that in this state we can resolve regular modules in `a/tests/` but not namespace
-packages because we have some extra validation for namespace packages conflicted by regular
-packages, but that validation isn't applied when we successfully resolve a submodule of the
-namespace package.
-
-In this case, as we find that `a/tests/test1.py` matches on the first-party path as `a.tests.test1`
-and is syntactically valid. We then resolve `a.tests.test1` and because the namespace package
-(`/a/`) comes first we succeed. We then syntactically compute `.` to be `a.tests`.
-
-When we go to lookup `a.tests.setup`, whatever grace that allowed `a.tests.test1` to resolve still
-works so it resolves too. However when we try to resolve `a.tests` on its own some additional
-validation rejects the namespace package conflicting with the regular package.
-
 ```toml
 [environment]
-# Setup a venv with editables for a/src/ and b/src/
-python = "/.venv"
-```
-
-`/.venv/pyvenv.cfg`:
-
-```cfg
-home = /do/re/mi//cpython-3.13.2-macos-aarch64-none/bin
-```
-
-`/do/re/mi//cpython-3.13.2-macos-aarch64-none/bin/python`:
-
-```text
-```
-
-`/.venv/<path-to-site-packages>/a.pth`:
-
-```pth
-a/src/
-```
-
-`/.venv/<path-to-site-packages>/b.pth`:
-
-```pth
-b/src/
+# This is similar to what we would compute for installed editables
+extra-paths = ["a/src/", "b/src/"]
 ```
 
 `a/tests/test1.py`:
@@ -387,6 +256,7 @@ b/src/
 ```py
 # TODO: there should be no errors in this file.
 
+# error: [unresolved-import]
 from .setup import x
 
 # error: [unresolved-import]
@@ -394,7 +264,7 @@ from . import setup
 from a import y
 import a
 
-reveal_type(x)  # revealed: int
+reveal_type(x)  # revealed: Unknown
 reveal_type(setup.x)  # revealed: Unknown
 reveal_type(y)  # revealed: int
 reveal_type(a.y)  # revealed: int
@@ -424,6 +294,7 @@ y: int = 10
 ```py
 # TODO: there should be no errors in this file
 
+# error: [unresolved-import]
 from .setup import x
 
 # error: [unresolved-import]
@@ -431,7 +302,7 @@ from . import setup
 from b import y
 import b
 
-reveal_type(x)  # revealed: str
+reveal_type(x)  # revealed: Unknown
 reveal_type(setup.x)  # revealed: Unknown
 reveal_type(y)  # revealed: str
 reveal_type(b.y)  # revealed: str
@@ -456,15 +327,10 @@ version = "0.1.0"
 y: str = "20"
 ```
 
-### Tests Directory With Ambiguous Project Directories Via `extra-paths`
+### Tests Package With Ambiguous Project Directories
 
-The same situation as the previous test but instead of using editables we use `extra-paths` which
-have higher priority than the first-party search-path. Thus, `/a/src/a/` is always seen before
-`/a/`.
-
-In this case everything works well because the namespace package `a.tests` (`a/tests/`) is
-completely hidden by the regular package `a` (`a/src/a/`) and so we immediately enter desperate
-resolution and use the now-unambiguous namespace package `tests`.
+The same situation as the previous test but `tests/__init__.py` is also defined, in case that
+complicates the situation.
 
 ```toml
 [environment]
@@ -474,17 +340,27 @@ extra-paths = ["a/src/", "b/src/"]
 `a/tests/test1.py`:
 
 ```py
+# TODO: there should be no errors in this file.
+
+# error: [unresolved-import]
 from .setup import x
+
+# error: [unresolved-import]
 from . import setup
 from a import y
 import a
 
-reveal_type(x)  # revealed: int
-reveal_type(setup.x)  # revealed: int
+reveal_type(x)  # revealed: Unknown
+reveal_type(setup.x)  # revealed: Unknown
 reveal_type(y)  # revealed: int
 reveal_type(a.y)  # revealed: int
 ```
 
+`a/tests/__init__.py`:
+
+```py
+```
+
 `a/tests/setup.py`:
 
 ```py
@@ -507,17 +383,27 @@ y: int = 10
 `b/tests/test1.py`:
 
 ```py
+# TODO: there should be no errors in this file
+
+# error: [unresolved-import]
 from .setup import x
+
+# error: [unresolved-import]
 from . import setup
 from b import y
 import b
 
-reveal_type(x)  # revealed: str
-reveal_type(setup.x)  # revealed: str
+reveal_type(x)  # revealed: Unknown
+reveal_type(setup.x)  # revealed: Unknown
 reveal_type(y)  # revealed: str
 reveal_type(b.y)  # revealed: str
 ```
 
+`b/tests/__init__.py`:
+
+```py
+```
+
 `b/tests/setup.py`:
 
 ```py
@@ -545,16 +431,21 @@ that `import main` and expect that to work.
 `a/tests/test1.py`:
 
 ```py
+# TODO: there should be no errors in this file.
+
 from .setup import x
 from . import setup
 
+# error: [unresolved-import]
 from main import y
+
+# error: [unresolved-import]
 import main
 
 reveal_type(x)  # revealed: int
 reveal_type(setup.x)  # revealed: int
-reveal_type(y)  # revealed: int
-reveal_type(main.y)  # revealed: int
+reveal_type(y)  # revealed: Unknown
+reveal_type(main.y)  # revealed: Unknown
 ```
 
 `a/tests/setup.py`:
@@ -579,16 +470,113 @@ y: int = 10
 `b/tests/test1.py`:
 
 ```py
+# TODO: there should be no errors in this file
+
 from .setup import x
 from . import setup
 
+# error: [unresolved-import]
 from main import y
+
+# error: [unresolved-import]
 import main
 
 reveal_type(x)  # revealed: str
 reveal_type(setup.x)  # revealed: str
-reveal_type(y)  # revealed: str
-reveal_type(main.y)  # revealed: str
+reveal_type(y)  # revealed: Unknown
+reveal_type(main.y)  # revealed: Unknown
+```
+
+`b/tests/setup.py`:
+
+```py
+x: str = "2"
+```
+
+`b/pyproject.toml`:
+
+```text
+name = "a"
+version = "0.1.0"
+```
+
+`b/main.py`:
+
+```py
+y: str = "20"
+```
+
+### Tests Package Absolute Importing `main.py`
+
+The same as the previous case but `tests/__init__.py` exists in case that causes different issues.
+
+`a/tests/test1.py`:
+
+```py
+# TODO: there should be no errors in this file.
+
+from .setup import x
+from . import setup
+
+# error: [unresolved-import]
+from main import y
+
+# error: [unresolved-import]
+import main
+
+reveal_type(x)  # revealed: int
+reveal_type(setup.x)  # revealed: int
+reveal_type(y)  # revealed: Unknown
+reveal_type(main.y)  # revealed: Unknown
+```
+
+`a/tests/__init__.py`:
+
+```py
+```
+
+`a/tests/setup.py`:
+
+```py
+x: int = 1
+```
+
+`a/pyproject.toml`:
+
+```text
+name = "a"
+version = "0.1.0"
+```
+
+`a/main.py`:
+
+```py
+y: int = 10
+```
+
+`b/tests/test1.py`:
+
+```py
+# TODO: there should be no errors in this file
+
+from .setup import x
+from . import setup
+
+# error: [unresolved-import]
+from main import y
+
+# error: [unresolved-import]
+import main
+
+reveal_type(x)  # revealed: str
+reveal_type(setup.x)  # revealed: str
+reveal_type(y)  # revealed: Unknown
+reveal_type(main.y)  # revealed: Unknown
+```
+
+`b/tests/__init__.py`:
+
+```py
 ```
 
 `b/tests/setup.py`:
@@ -618,11 +606,16 @@ imports it.
 `a/main.py`:
 
 ```py
+# TODO: there should be no errors in this file.
+
+# error: [unresolved-import]
 from utils import x
+
+# error: [unresolved-import]
 import utils
 
-reveal_type(x)  # revealed: int
-reveal_type(utils.x)  # revealed: int
+reveal_type(x)  # revealed: Unknown
+reveal_type(utils.x)  # revealed: Unknown
 ```
 
 `a/utils/__init__.py`:
@@ -641,11 +634,16 @@ version = "0.1.0"
 `b/main.py`:
 
 ```py
+# TODO: there should be no errors in this file.
+
+# error: [unresolved-import]
 from utils import x
+
+# error: [unresolved-import]
 import utils
 
-reveal_type(x)  # revealed: str
-reveal_type(utils.x)  # revealed: str
+reveal_type(x)  # revealed: Unknown
+reveal_type(utils.x)  # revealed: Unknown
 ```
 
 `b/utils/__init__.py`:

crates/ty_python_semantic/resources/mdtest/invalid_syntax.md

@@ -128,16 +128,3 @@ InvalidEmptyUnion = Union[]
 def _(u: InvalidEmptyUnion):
     reveal_type(u)  # revealed: Unknown
 ```
-
-### `typing.Annotated`
-
-```py
-from typing import Annotated
-
-# error: [invalid-syntax] "Expected index or slice expression"
-# error: [invalid-type-form] "Special form `typing.Annotated` expected at least 2 arguments (one type and at least one metadata element)"
-InvalidEmptyAnnotated = Annotated[]
-
-def _(a: InvalidEmptyAnnotated):
-    reveal_type(a)  # revealed: Unknown
-```

crates/ty_python_semantic/resources/mdtest/liskov.md

@@ -218,8 +218,8 @@ class E(A[int]):
     def method(self, x: object) -> None: ...  # fine
 
 class F[T](A[T]):
+    # TODO: we should emit `invalid-method-override` on this:
     # `str` is not necessarily a supertype of `T`!
-    # error: [invalid-method-override]
     def method(self, x: str) -> None: ...
 
 class G(A[int]):

crates/ty_python_semantic/resources/mdtest/literal_promotion.md

@@ -304,7 +304,7 @@ x11: list[Literal[1] | Literal[2] | Literal[3]] = [1, 2, 3]
 reveal_type(x11)  # revealed: list[Literal[1, 2, 3]]
 
 x12: Y[Y[Literal[1]]] = [[1]]
-reveal_type(x12)  # revealed: list[Y[Literal[1]]]
+reveal_type(x12)  # revealed: list[list[Literal[1]]]
 
 x13: list[tuple[Literal[1], Literal[2], Literal[3]]] = [(1, 2, 3)]
 reveal_type(x13)  # revealed: list[tuple[Literal[1], Literal[2], Literal[3]]]

crates/ty_python_semantic/resources/mdtest/mro.md

@@ -301,7 +301,7 @@ class B: ...
 
 EitherOr = A | B
 
-# error: [invalid-base] "Invalid class base with type `<types.UnionType special form 'A | B'>`"
+# error: [invalid-base] "Invalid class base with type `types.UnionType`"
 class Foo(EitherOr): ...
 ```
 

crates/ty_python_semantic/resources/mdtest/narrow/isinstance.md

@@ -156,7 +156,7 @@ from typing import Union
 
 IntOrStr = Union[int, str]
 
-reveal_type(IntOrStr)  # revealed: <types.UnionType special form 'int | str'>
+reveal_type(IntOrStr)  # revealed: types.UnionType
 
 def _(x: int | str | bytes | memoryview | range):
     if isinstance(x, IntOrStr):