Merge branch 'main' into cjm/fix-spurious-async-None

* main:
  [`pydocstyle`] Improve discoverability of rules enabled for each convention (#24973)
  [ty] Deduplicate retained use-def place states (#25450)
  [ty] reduce features of low-level crates depended on by `ty_python_semantic` (#25524)
  [ty] Fix narrowing enum literal unions by member identity (#25520)
  [ty] Test tagged union narrowing for named tuples (#25519)
  [ty] Disallow file-system access in `ty_python_core` (#25518)
  [ty] Nominal Tagged Union Narrowing (#24916)
  Commit `scripts/uv.lock` (#25517)
  Fix potential index out of range in `LineIndex` computation (#25492)
  [ty] Sync vendored typeshed stubs (#25514)
  [ty] Add disjointness for protocol method members (#25315)
  [ty] Use compact sets for more immutable fields (#25476)
  [ty] Derive `Default` for `FunctionDecoratorInference` (#25482)
  [ty] Ignore rejected assignments for synthesized bindings (#25340)
  [ty] Handle cycles in function decorator inference (#25475)
  docs: fix typo `bin/active` → `bin/activate` in tutorial (#25473)
  [ty] Narrow bound method overloads by receiver (#24707)

Author: carljm

crates/ruff_source_file/src/line_index.rs

@@ -294,7 +294,15 @@ impl LineIndex {
         if row_index.saturating_add(1) >= starts.len() {
             contents.text_len()
         } else {
-            starts[row_index + 1] - TextSize::new(1)
+            let next_line_start = starts[row_index + 1].to_usize();
+            let bytes = contents.as_bytes();
+
+            let line_ending_len = if bytes[..next_line_start].ends_with(b"\r\n") {
+                2
+            } else {
+                1
+            };
+            starts[row_index + 1] - TextSize::new(line_ending_len)
         }
     }
 
@@ -812,6 +820,42 @@ mod tests {
         );
     }
 
+    #[test]
+    fn line_end_exclusive_handles_different_line_endings() {
+        let lf_contents = "a\nb";
+        let lf_index = LineIndex::from_source_text(lf_contents);
+        assert_eq!(
+            lf_index.line_end_exclusive(OneIndexed::from_zero_indexed(0), lf_contents),
+            TextSize::from(1)
+        );
+        assert_eq!(
+            lf_index.line_end_exclusive(OneIndexed::from_zero_indexed(1), lf_contents),
+            TextSize::from(3)
+        );
+
+        let crlf_contents = "a\r\nb";
+        let crlf_index = LineIndex::from_source_text(crlf_contents);
+        assert_eq!(
+            crlf_index.line_end_exclusive(OneIndexed::from_zero_indexed(0), crlf_contents),
+            TextSize::from(1)
+        );
+        assert_eq!(
+            crlf_index.line_end_exclusive(OneIndexed::from_zero_indexed(1), crlf_contents),
+            TextSize::from(4)
+        );
+
+        let cr_contents = "a\rb";
+        let cr_index = LineIndex::from_source_text(cr_contents);
+        assert_eq!(
+            cr_index.line_end_exclusive(OneIndexed::from_zero_indexed(0), cr_contents),
+            TextSize::from(1)
+        );
+        assert_eq!(
+            cr_index.line_end_exclusive(OneIndexed::from_zero_indexed(1), cr_contents),
+            TextSize::from(3)
+        );
+    }
+
     #[test]
     fn utf8_index() {
         let index = LineIndex::from_source_text("x = '🫣'");

crates/ruff_workspace/src/options.rs

@@ -3313,6 +3313,53 @@ pub struct PydocstyleOptions {
     /// convention = "google"
     /// ```
     ///
+    /// The PEP 257 convention includes all `D` errors apart from:
+    /// [`D203`](rules/incorrect-blank-line-before-class.md),
+    /// [`D212`](rules/multi-line-summary-first-line.md),
+    /// [`D213`](rules/multi-line-summary-second-line.md),
+    /// [`D214`](rules/overindented-section.md),
+    /// [`D215`](rules/overindented-section-underline.md),
+    /// [`D404`](rules/docstring-starts-with-this.md),
+    /// [`D405`](rules/non-capitalized-section-name.md),
+    /// [`D406`](rules/missing-new-line-after-section-name.md),
+    /// [`D407`](rules/missing-dashed-underline-after-section.md),
+    /// [`D408`](rules/missing-section-underline-after-name.md),
+    /// [`D409`](rules/mismatched-section-underline-length.md),
+    /// [`D410`](rules/no-blank-line-after-section.md),
+    /// [`D411`](rules/no-blank-line-before-section.md),
+    /// [`D413`](rules/missing-blank-line-after-last-section.md),
+    /// [`D415`](rules/missing-terminal-punctuation.md),
+    /// [`D416`](rules/missing-section-name-colon.md),
+    /// [`D417`](rules/undocumented-param.md), and
+    /// [`D420`](rules/incorrect-section-order.md).
+    ///
+    /// The NumPy convention includes all `D` errors apart from:
+    /// [`D107`](rules/undocumented-public-init.md),
+    /// [`D203`](rules/incorrect-blank-line-before-class.md),
+    /// [`D212`](rules/multi-line-summary-first-line.md),
+    /// [`D213`](rules/multi-line-summary-second-line.md),
+    /// [`D402`](rules/signature-in-docstring.md),
+    /// [`D413`](rules/missing-blank-line-after-last-section.md),
+    /// [`D415`](rules/missing-terminal-punctuation.md),
+    /// [`D416`](rules/missing-section-name-colon.md), and
+    /// [`D417`](rules/undocumented-param.md).
+    ///
+    /// The Google convention includes all `D` errors apart from:
+    /// [`D203`](rules/incorrect-blank-line-before-class.md),
+    /// [`D204`](rules/incorrect-blank-line-after-class.md),
+    /// [`D213`](rules/multi-line-summary-second-line.md),
+    /// [`D215`](rules/overindented-section-underline.md),
+    /// [`D400`](rules/missing-trailing-period.md),
+    /// [`D401`](rules/non-imperative-mood.md),
+    /// [`D404`](rules/docstring-starts-with-this.md),
+    /// [`D406`](rules/missing-new-line-after-section-name.md),
+    /// [`D407`](rules/missing-dashed-underline-after-section.md),
+    /// [`D408`](rules/missing-section-underline-after-name.md),
+    /// [`D409`](rules/mismatched-section-underline-length.md), and
+    /// [`D413`](rules/missing-blank-line-after-last-section.md).
+    ///
+    /// For more information see the [FAQ](faq.md#does-ruff-support-numpy-or-google-style-docstrings) entry.
+    ///
     /// To enable an additional rule that's excluded from the convention,
     /// select the desired rule via its fully qualified rule code (e.g.,
     /// `D400` instead of `D4` or `D40`):

crates/ty_ide/src/hover.rs

@@ -1529,6 +1529,87 @@ mod tests {
         ");
     }
 
+    #[test]
+    fn hover_bound_method_overload_self_type() {
+        let string = hover_test(
+            r#"
+        def f(string: str):
+            string.removesuf<CURSOR>fix("suffix")
+        "#,
+        );
+
+        assert_snapshot!(string.hover(), @r#"
+        bound method str.removesuffix(suffix: str, /) -> str
+        ---------------------------------------------
+        Return a str with the given suffix string removed if present.
+
+        If the string ends with the suffix string and that suffix is not empty,
+        return string[:-len(suffix)]. Otherwise, return a copy of the original
+        string.
+
+        ---------------------------------------------
+        ```python
+        bound method str.removesuffix(suffix: str, /) -> str
+        ```
+        ---
+        Return a str with the given suffix string removed if present.<HB>
+        <HB>
+        If the string ends with the suffix string and that suffix is not empty,<HB>
+        return string[:-len(suffix)]. Otherwise, return a copy of the original<HB>
+        string.
+        ---------------------------------------------
+        info[hover]: Hovered content is
+         --> main.py:3:12
+          |
+        3 |     string.removesuffix("suffix")
+          |            ^^^^^^^^^-^^
+          |            |        |
+          |            |        Cursor offset
+          |            source
+          |
+        "#);
+
+        let literal_string = hover_test(
+            r#"
+            from typing_extensions import LiteralString
+
+            def f(string: LiteralString):
+                string.removesuf<CURSOR>fix("suffix")
+            "#,
+        );
+
+        assert_snapshot!(literal_string.hover(), @r#"
+        def removesuffix(suffix: LiteralString, /) -> LiteralString
+        ---------------------------------------------
+        Return a str with the given suffix string removed if present.
+
+        If the string ends with the suffix string and that suffix is not empty,
+        return string[:-len(suffix)]. Otherwise, return a copy of the original
+        string.
+
+        ---------------------------------------------
+        ```python
+        def removesuffix(suffix: LiteralString, /) -> LiteralString
+        ```
+        ---
+        Return a str with the given suffix string removed if present.<HB>
+        <HB>
+        If the string ends with the suffix string and that suffix is not empty,<HB>
+        return string[:-len(suffix)]. Otherwise, return a copy of the original<HB>
+        string.
+        ---------------------------------------------
+        info[hover]: Hovered content is
+         --> main.py:5:12
+          |
+        5 |     string.removesuffix("suffix")
+          |            ^^^^^^^^^-^^
+          |            |        |
+          |            |        Cursor offset
+          |            source
+          |
+        "#);
+    }
+
     /// When the resolved overload has no docstring and neither does the
     /// implementation, we fall back to showing a sibling overload's docstring.
     #[test]

crates/ty_ide/src/inlay_hints.rs

@@ -4551,6 +4551,82 @@ Source with applied edits:
         ");
     }
 
+    #[test]
+    fn instance_method_overload_self_type() {
+        let mut test = inlay_hint_test(
+            r#"
+            from typing import overload
+
+            class Parent:
+                @overload
+                def choose(self: "Child", child_value: int) -> None: ...
+                @overload
+                def choose(self: "Parent", parent_value: int) -> None: ...
+                def choose(self, value: int) -> None: ...
+
+            class Child(Parent): pass
+
+            def f(parent: Parent, child: Child):
+                parent.choose(1)
+                child.choose(2)"#,
+        );
+
+        assert_snapshot!(test.inlay_hints(), @r#"
+
+        from typing import overload
+
+        class Parent:
+            @overload
+            def choose(self: "Child", child_value: int) -> None: ...
+            @overload
+            def choose(self: "Parent", parent_value: int) -> None: ...
+            def choose(self, value: int) -> None: ...
+
+        class Child(Parent): pass
+
+        def f(parent: Parent, child: Child):
+            parent.choose([parent_value=]1)
+            child.choose([child_value=]2)
+        ---------------------------------------------
+        info[inlay-hint-location]: Inlay Hint Target
+         --> main.py:8:32
+          |
+        8 |     def choose(self: "Parent", parent_value: int) -> None: ...
+          |                                ^^^^^^^^^^^^
+          |
+        info: Source
+          --> main2.py:14:20
+           |
+        14 |     parent.choose([parent_value=]1)
+           |                    ^^^^^^^^^^^^
+           |
+
+        info[inlay-hint-location]: Inlay Hint Target
+         --> main.py:6:31
+          |
+        6 |     def choose(self: "Child", child_value: int) -> None: ...
+          |                               ^^^^^^^^^^^
+          |
+        info: Source
+          --> main2.py:15:19
+           |
+        15 |     child.choose([child_value=]2)
+           |                   ^^^^^^^^^^^
+           |
+
+        ---------------------------------------------
+        info[inlay-hint-edit]: Inlay hint edits
+        --> main.py:1:1
+        11 | class Child(Parent): pass
+        12 |
+        13 | def f(parent: Parent, child: Child):
+           -     parent.choose(1)
+           -     child.choose(2)
+        14 +     parent.choose(parent_value=1)
+        15 +     child.choose(child_value=2)
+        "#);
+    }
+
     #[test]
     fn test_class_method_call() {
         let mut test = inlay_hint_test(

crates/ty_ide/src/signature_help.rs

@@ -353,6 +353,27 @@ mod tests {
         }
     }
 
+    #[test]
+    fn signature_help_bound_method_overload_self_type() {
+        let test = cursor_test(
+            r#"
+        def f(string: str):
+            string.removesuffix("suffix"<CURSOR>)
+        "#,
+        );
+
+        assert_snapshot!(test.signature_help_render(), @"
+
+        ============== active signature =============
+        (suffix: str, /) -> str
+        ---------------------------------------------
+
+        -------------- active parameter -------------
+        suffix: str
+        ---------------------------------------------
+        ");
+    }
+
     #[test]
     fn signature_help_nested_function_calls() {
         let test = cursor_test(

crates/ty_python_core/src/lib.rs

@@ -1,3 +1,7 @@
+#![warn(
+    clippy::disallowed_methods,
+    reason = "Prefer System trait methods over std methods in ty crates"
+)]
 use ruff_python_ast as ast;
 use std::iter::{FusedIterator, once};
 use std::sync::Arc;

crates/ty_python_core/src/place.rs

@@ -654,15 +654,30 @@ impl<'db, 'a> PossiblyNarrowedPlacesBuilder<'db, 'a> {
             self.add_narrowing_target(comparator, &mut places);
         }
 
+        let can_narrow_attribute_base =
+            matches!(&*expr_compare.ops, [ast::CmpOp::Eq | ast::CmpOp::NotEq]);
+        let can_narrow_subscript_base = matches!(
+            &*expr_compare.ops,
+            [ast::CmpOp::Eq | ast::CmpOp::NotEq | ast::CmpOp::Is | ast::CmpOp::IsNot]
+        );
+
         // For subscript expressions on either side, the subscript base can also be narrowed.
         // (TypedDict and tuple discriminated union narrowing.)
         for expr in std::iter::once(&*expr_compare.left).chain(&expr_compare.comparators) {
-            if let ast::Expr::Subscript(subscript) = expr.expression_value()
+            if can_narrow_subscript_base
+                && let ast::Expr::Subscript(subscript) = expr.expression_value()
                 && let Some(place_expr) = PlaceExpr::try_from_expr(&subscript.value)
                 && let Some(place) = self.places.place_id((&place_expr).into())
             {
                 places.insert(place);
             }
+            if can_narrow_attribute_base
+                && let ast::Expr::Attribute(attribute) = expr
+                && let Some(place_expr) = PlaceExpr::try_from_expr(&attribute.value)
+                && let Some(place) = self.places.place_id((&place_expr).into())
+            {
+                places.insert(place);
+            }
         }
 
         places
@@ -767,6 +782,12 @@ impl<'db, 'a> PossiblyNarrowedPlacesBuilder<'db, 'a> {
                 }
             }
         }
+        if let ast::Expr::Attribute(attribute) = subject_node
+            && let Some(place_expr) = PlaceExpr::try_from_expr(&attribute.value)
+            && let Some(place) = self.places.place_id((&place_expr).into())
+        {
+            places.insert(place);
+        }
 
         // Handle Or patterns by recursing into each alternative
         if let PatternPredicateKind::Or(predicates) = kind {