Merge branch 'main' into charlie/metaclass

* main:
  [ty] Take myself out of the reviewer pool for the next few days (#23618)
  [ty] Fix bug where ty would think that a `Callable` with a variadic positional parameter could be a subtype of a `Callable` with a positional-or-keyword parameter (#23610)
  [`ruff`] Add fix for `none-not-at-end-of-union` (`RUF036`)  (#22829)
  Bump cargo dist to 0.31 (#23614)
  [`pyflakes`] Fix false positive for names shadowing re-exports (`F811`) (#23356)
  [`fastapi`] Handle callable class dependencies with `__call__` method (`FAST003`) (#23553)
  [ty] Recurse into tuples and nested tuples when applying special-cased validation of `isinstance()` and `issubclass()` (#23607)
  Update typing conformance suite commit (#23606)
  [ty] Detect invalid uses of `@final` on non-methods (#23604)
  [ty] Move the type hierarchy request handlers to individual modules
  [ty] Wire up the type hierarchy implementation with the LSP
  [ty] Add routine for mapping from system path to vendored path
  [ty] Implement internal routines for providing the LSP "type hierarchy" feature
  [ty] Add some helper methods on `ClassLiteral`
  [ty] Move some module name helper routines to methods on `ModuleName`
  [ty] Bump version of `lsp-types`
  [ty] Refactor to support building constraint sets differently (#23600)
  [ty] Dataclass transform: neither frozen nor non-frozen (#23366)
  [ty] Add snapshot tests for advanced `invalid-assignment` scenarios (#23581)
  [ty] disallow negative narrowing on SubclassOf types (#23598)

Author: carljm

.github/pr-assignee-pools.toml

@@ -9,7 +9,7 @@ reviewers = ["amyreese", "ntBre"]
 [[pools]]
 name = "ty-semantic"
 paths = ["/crates/ty_python_semantic/**"]
-reviewers = ["carljm", "sharkdp", "dcreager", "ibraheemdev", "oconnor663"]
+reviewers = ["carljm", "dcreager", "ibraheemdev", "oconnor663"]
 
 [[pools]]
 name = "ty-module-resolver"

.github/workflows/release.yml

@@ -68,7 +68,7 @@ jobs:
         # we specify bash to get pipefail; it guards against the `curl` command
         # failing. otherwise `sh` won't catch that `curl` returned non-0
         shell: bash
-        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.30.2/cargo-dist-installer.sh | sh"
+        run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.31.0/cargo-dist-installer.sh | sh"
       - name: Cache dist
         uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f
         with:

.github/workflows/typing_conformance.yaml

@@ -34,7 +34,7 @@ env:
   CARGO_TERM_COLOR: always
   RUSTUP_MAX_RETRIES: 10
   RUST_BACKTRACE: 1
-  CONFORMANCE_SUITE_COMMIT: 21b07859158d2d10ed7fe8d9b365412518ed9888
+  CONFORMANCE_SUITE_COMMIT: e9fccc9dbbd8f1e8b24b4f88911c3d3155059e2a
   PYTHON_VERSION: 3.12
 
 jobs:

Cargo.lock

@@ -127,7 +127,7 @@ libc = { version = "0.2.153" }
 libcst = { version = "1.8.4", default-features = false }
 log = { version = "0.4.17" }
 lsp-server = { version = "0.7.6" }
-lsp-types = { git = "https://github.com/astral-sh/lsp-types.git", rev = "3512a9f", features = [
+lsp-types = { git = "https://github.com/astral-sh/lsp-types.git", rev = "e15db0593f0ecbbd80599c3f5880e4bf5da1ca0c", features = [
     "proposed",
 ] }
 matchit = { version = "0.9.0" }

Cargo.toml

@@ -299,3 +299,73 @@ async def read_thing_posonly_default_trailing(query: str = "", /,): ...
 
 @app.get("/things/{thing_id}")
 async def read_thing_posonly_with_regular(query: str = "", /, x=None): ...
+
+
+# https://github.com/astral-sh/ruff/issues/23526
+
+# Error: `Depends(CallableQuery)` passes the class itself, so FastAPI uses
+# `__init__` (which has no params here), not `__call__`. The path parameter
+# `thing_id` is unused.
+class CallableQuery:
+    def __call__(self, thing_id: int):
+        pass
+
+
+@app.get("/things/{thing_id}")
+async def read_thing_callable_dep(query: Annotated[str, Depends(CallableQuery)]): ...
+
+
+# OK: `Depends(CallableQuery())` passes an instance, so FastAPI uses `__call__`,
+# which declares `thing_id`.
+@app.get("/things/{thing_id}")
+async def read_thing_callable_dep_instance(query: Annotated[str, Depends(CallableQuery())]): ...
+
+
+# OK: class with both __init__ and __call__, passed as class reference.
+# FastAPI uses `__init__`, which declares `thing_id`.
+class InitAndCallQuery:
+    def __init__(self, thing_id: int):
+        pass
+
+    def __call__(self, other: str):
+        pass
+
+
+@app.get("/things/{thing_id}")
+async def read_thing_init_and_call_dep(query: Annotated[str, Depends(InitAndCallQuery)]): ...
+
+
+# Error: `Depends(CallableQueryOther)` — class reference, uses `__init__` (no
+# params). `thing_id` is unused.
+class CallableQueryOther:
+    def __call__(self, other: str):
+        pass
+
+
+@app.get("/things/{thing_id}")
+async def read_thing_callable_dep_missing(query: Annotated[str, Depends(CallableQueryOther)]): ...
+
+
+# Error: `Depends(InitAndCallQuery())` passes an instance, so FastAPI uses
+# `__call__`, which has `other` — not `thing_id`.
+@app.get("/things/{thing_id}")
+async def read_thing_init_and_call_instance(query: Annotated[str, Depends(InitAndCallQuery())]): ...
+
+
+# Error: class with no __init__ and no __call__; FastAPI calls __init__ which
+# has no parameters, so `thing_id` is not covered by the dependency.
+class EmptyClass:
+    pass
+
+
+@app.get("/things/{thing_id}")
+async def read_thing_empty_class_dep(query: Annotated[str, Depends(EmptyClass)]): ...
+
+
+# Same instance patterns as default values (not Annotated).
+# OK: `__call__` declares `thing_id`.
+@app.get("/things/{thing_id}")
+async def read_thing_callable_dep_instance_default(query: str = Depends(CallableQuery())): ...
+# Error: `__call__` has `other`, not `thing_id`.
+@app.get("/things/{thing_id}")
+async def read_thing_init_and_call_instance_default(query: str = Depends(InitAndCallQuery())): ...

crates/ruff_linter/resources/test/fixtures/fastapi/FAST003.py

@@ -0,0 +1,7 @@
+# Regression test for https://github.com/astral-sh/ruff/issues/10874
+# Explicit re-exports at module scope should not be flagged as redefined
+# by class-scoped attributes with the same name.
+from x import y as y
+
+class Foo:
+    y = 42  # OK — class attribute, different scope from module-level re-export

crates/ruff_linter/resources/test/fixtures/pyflakes/F811_33.pyi

@@ -21,12 +21,53 @@ def func5() -> U[None, int]:
     ...
 
 
-def func6(arg: U[None, None, int]): 
+def func6(arg: U[None, None, int]):
+    ...
+
+
+# Comments in annotation (unsafe fix)
+def func7() -> U[
+    None,
+    # comment
+    int
+]:
+    ...
+
+
+# Nested unions - no fix should be provided
+def func8(x: None | U[None, int]):
+    ...
+
+
+def func9(x: int | (str | None) | list):
+    ...
+
+
+def func10(x: U[int, U[None, list | set]]):
+    ...
+
+
+# Multiple annotations in the same function
+def func11(x: None | int) -> None | int:
+    ...
+
+
+# With default argument (from poetry ecosystem check)
+def func12(io: None | int = None) -> int | None:
+    ...
+
+
+# 3+ member PEP 604 chains
+def func13(arg: None | int | str):
+    ...
+
+
+def func14(arg: None | int | str | bytes):
     ...
 
 
 # Ok
-def good_func1(arg: int | None): 
+def good_func1(arg: int | None):
     ...
 
 

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

@@ -13,6 +13,19 @@ def func5() -> U[None, int]: ...
 
 def func6(arg: U[None, None, int]): ...
 
+# Nested unions - no fix should be provided
+def func7(x: None | U[None, int]): ...
+
+def func8(x: U[int, U[None, list | set]]): ...
+
+# Multiple annotations in the same function
+def func9(x: None | int) -> None | int: ...
+
+# 3+ member PEP 604 chains
+def func10(arg: None | int | str): ...
+
+def func11(arg: None | int | str | bytes): ...
+
 # Ok
 def good_func1(arg: int | None): ...
 

crates/ruff_linter/resources/test/fixtures/ruff/RUF036.pyi

@@ -307,13 +307,27 @@ impl<'a> Dependency<'a> {
     }
 
     fn from_depends_call(arguments: &'a Arguments, semantic: &SemanticModel<'a>) -> Option<Self> {
-        let Some(Expr::Name(name)) = arguments.find_argument_value("dependency", 0) else {
-            return None;
-        };
-
-        Self::from_dependency_name(name, semantic)
+        let dep_arg = arguments.find_argument_value("dependency", 0)?;
+
+        match dep_arg {
+            // `Depends(some_callable)` — a name reference (function or class).
+            Expr::Name(name) => Self::from_dependency_name(name, semantic),
+            // `Depends(SomeClass(...))` — a call expression. If the callee is a
+            // class, FastAPI will invoke `__call__` on the resulting instance.
+            Expr::Call(call) => {
+                let Expr::Name(name) = call.func.as_ref() else {
+                    return None;
+                };
+                Self::from_dependency_instance(name, semantic)
+            }
+            _ => None,
+        }
     }
 
+    /// Resolve a dependency that is a name reference (e.g. `Depends(Query)`).
+    ///
+    /// For classes, FastAPI calls the class constructor, so the parameters come
+    /// from `__init__`.
     fn from_dependency_name(name: &'a ast::ExprName, semantic: &SemanticModel<'a>) -> Option<Self> {
         let Some(binding) = semantic.only_binding(name).map(|id| semantic.binding(id)) else {
             return Some(Self::Unknown);
@@ -334,46 +348,74 @@ impl<'a> Dependency<'a> {
                 Some(Self::Function(parameter_names))
             }
             BindingKind::ClassDefinition(scope_id) => {
-                let scope = &semantic.scopes[scope_id];
-
-                let ScopeKind::Class(class_def) = scope.kind else {
-                    return Some(Self::Unknown);
-                };
+                Self::class_params_from_method(semantic, scope_id, "__init__")
+            }
+            _ => Some(Self::Unknown),
+        }
+    }
 
-                let parameter_names = if class_def
-                    .bases()
-                    .iter()
-                    .any(|expr| is_pydantic_base_model(expr, semantic))
-                {
-                    class_def
-                        .body
-                        .iter()
-                        .filter_map(|stmt| {
-                            stmt.as_ann_assign_stmt()
-                                .and_then(|ann_assign| ann_assign.target.as_name_expr())
-                                .map(|name| name.id.as_str())
-                        })
-                        .collect()
-                } else if let Some(init_def) = class_def
-                    .body
-                    .iter()
-                    .filter_map(|stmt| stmt.as_function_def_stmt())
-                    .find(|func_def| func_def.name.as_str() == "__init__")
-                {
-                    // Skip `self` parameter
-                    non_posonly_non_variadic_parameters(init_def)
-                        .skip(1)
-                        .map(|param| param.name().as_str())
-                        .collect()
-                } else {
-                    return None;
-                };
+    /// Resolve a dependency that is a class instance (e.g. `Depends(Query())`).
+    ///
+    /// FastAPI calls the instance, so the parameters come from `__call__`.
+    fn from_dependency_instance(
+        name: &'a ast::ExprName,
+        semantic: &SemanticModel<'a>,
+    ) -> Option<Self> {
+        let Some(binding) = semantic.only_binding(name).map(|id| semantic.binding(id)) else {
+            return Some(Self::Unknown);
+        };
 
-                Some(Self::Class(parameter_names))
+        match binding.kind {
+            BindingKind::ClassDefinition(scope_id) => {
+                Self::class_params_from_method(semantic, scope_id, "__call__")
             }
             _ => Some(Self::Unknown),
         }
     }
+
+    /// Extract parameters from a specific method (`__init__` or `__call__`) of a class.
+    fn class_params_from_method(
+        semantic: &SemanticModel<'a>,
+        scope_id: ruff_python_semantic::ScopeId,
+        method_name: &str,
+    ) -> Option<Self> {
+        let scope = &semantic.scopes[scope_id];
+
+        let ScopeKind::Class(class_def) = scope.kind else {
+            return Some(Self::Unknown);
+        };
+
+        let parameter_names = if class_def
+            .bases()
+            .iter()
+            .any(|expr| is_pydantic_base_model(expr, semantic))
+        {
+            class_def
+                .body
+                .iter()
+                .filter_map(|stmt| {
+                    stmt.as_ann_assign_stmt()
+                        .and_then(|ann_assign| ann_assign.target.as_name_expr())
+                        .map(|name| name.id.as_str())
+                })
+                .collect()
+        } else if let Some(method_def) = class_def
+            .body
+            .iter()
+            .filter_map(|stmt| stmt.as_function_def_stmt())
+            .find(|func_def| func_def.name.as_str() == method_name)
+        {
+            // Skip `self` parameter
+            non_posonly_non_variadic_parameters(method_def)
+                .skip(1)
+                .map(|param| param.name().as_str())
+                .collect()
+        } else {
+            return None;
+        };
+
+        Some(Self::Class(parameter_names))
+    }
 }
 
 fn depends_arguments<'a>(expr: &'a Expr, semantic: &SemanticModel) -> Option<&'a Arguments> {