disambiguate class names where necessary

Author: AlexWaygood

crates/ty_python_semantic/resources/mdtest/liskov.md

@@ -183,6 +183,26 @@ class D(C):
     def get(self, my_default): ...  # error: [invalid-method-override]
 ```
 
+## Fully qualified names are used in diagnostics where appropriate
+
+<!-- snapshot-diagnostics -->
+
+`a.pyi`:
+
+```pyi
+class A:
+    def foo(self, x): ...
+```
+
+`b.pyi`:
+
+```pyi
+import a
+
+class A(a.A):
+    def foo(self, y): ...  # error: [invalid-method-override]
+```
+
 ## Excluded methods
 
 Certain special constructor methods are excluded from Liskov checks. None of the following classes

crates/ty_python_semantic/resources/mdtest/snapshots/liskov.md_-_The_Liskov_Substitut…_-_Fully_qualified_name…_(8f6f7c5aace58329).snap

@@ -0,0 +1,47 @@
+---
+source: crates/ty_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: liskov.md - The Liskov Substitution Principle - Fully qualified names are used in diagnostics where appropriate
+mdtest path: crates/ty_python_semantic/resources/mdtest/liskov.md
+---
+
+# Python source files
+
+## a.pyi
+
+```
+1 | class A:
+2 |     def foo(self, x): ...
+```
+
+## b.pyi
+
+```
+1 | import a
+2 | 
+3 | class A(a.A):
+4 |     def foo(self, y): ...  # error: [invalid-method-override]
+```
+
+# Diagnostics
+
+```
+error[invalid-method-override]: Invalid override of method `foo`
+ --> src/b.pyi:4:9
+  |
+3 | class A(a.A):
+4 |     def foo(self, y): ...  # error: [invalid-method-override]
+  |         ^^^^^^^^^^^^ Definition is incompatible with `a.A.foo`
+  |
+ ::: src/a.pyi:2:9
+  |
+1 | class A:
+2 |     def foo(self, x): ...
+  |         ------------ `a.A.foo` defined here
+  |
+info: This violates the Liskov Substitution Principle
+info: rule `invalid-method-override` is enabled by default
+
+```

crates/ty_python_semantic/src/types/diagnostic.rs

@@ -16,6 +16,7 @@ use crate::types::KnownInstanceType;
 use crate::types::call::CallError;
 use crate::types::class::{DisjointBase, DisjointBaseKind, Field};
 use crate::types::function::KnownFunction;
+use crate::types::ide_support::Member;
 use crate::types::string_annotation::{
     BYTE_STRING_TYPE_ANNOTATION, ESCAPE_CHARACTER_IN_FORWARD_ANNOTATION, FSTRING_TYPE_ANNOTATION,
     IMPLICIT_CONCATENATED_STRING_TYPE_ANNOTATION, INVALID_SYNTAX_IN_FORWARD_ANNOTATION,
@@ -3273,6 +3274,54 @@ pub(crate) fn report_rebound_typevar<'db>(
     }
 }
 
+pub(super) fn report_invalid_method_override<'db>(
+    context: &InferContext<'db, '_>,
+    range: impl Ranged,
+    member: &Member<'db>,
+    class: ClassType<'db>,
+    supercls: ClassType<'db>,
+    type_on_supercls: Type<'db>,
+) {
+    let Some(builder) = context.report_lint(&INVALID_METHOD_OVERRIDE, range) else {
+        return;
+    };
+
+    let db = context.db();
+
+    let mut diagnostic =
+        builder.into_diagnostic(format_args!("Invalid override of method `{}`", member.name));
+
+    let supercls_name = supercls.name(db);
+
+    let overridden_method = if class.name(db) != supercls_name {
+        format!("{}.{}", supercls_name, member.name)
+    } else {
+        let mut buffer = supercls.class_literal(db).0.qualified_name(db);
+        buffer.push('.');
+        buffer.push_str(&member.name);
+        buffer
+    };
+
+    diagnostic.set_primary_message(format_args!(
+        "Definition is incompatible with `{overridden_method}`"
+    ));
+
+    diagnostic.info("This violates the Liskov Substitution Principle");
+
+    if let Type::BoundMethod(method_on_supercls) = type_on_supercls
+        && let Some(spans) = method_on_supercls
+            .function(db)
+            .literal(db)
+            .last_definition(db)
+            .spans(db)
+    {
+        diagnostic.annotate(
+            Annotation::secondary(spans.signature)
+                .message(format_args!("`{overridden_method}` defined here")),
+        );
+    }
+}
+
 /// This function receives an unresolved `from foo import bar` import,
 /// where `foo` can be resolved to a module but that module does not
 /// have a `bar` member or submodule.

crates/ty_python_semantic/src/types/display.rs

@@ -321,6 +321,16 @@ impl<'db> ClassLiteral<'db> {
         name_parts.reverse();
         name_parts
     }
+
+    pub(super) fn qualified_name(self, db: &'db dyn Db) -> String {
+        let mut qualified_name = String::new();
+        for parent in self.qualified_name_components(db) {
+            qualified_name.push_str(&parent);
+            qualified_name.push('.');
+        }
+        qualified_name.push_str(self.name(db));
+        qualified_name
+    }
 }
 
 struct ClassDisplay<'db> {

crates/ty_python_semantic/src/types/infer/builder/liskov.rs

@@ -1,5 +1,3 @@
-use ruff_db::diagnostic::Annotation;
-
 use ruff_text_size::Ranged;
 use rustc_hash::FxHashSet;
 
@@ -10,7 +8,7 @@ use crate::{
         ClassBase, ClassLiteral, ClassType, KnownClass, Type,
         class::CodeGeneratorKind,
         context::InferContext,
-        diagnostic::INVALID_METHOD_OVERRIDE,
+        diagnostic::report_invalid_method_override,
         ide_support::{MemberWithDefinition, all_declarations_and_bindings},
     },
 };
@@ -114,37 +112,12 @@ fn check_class_declaration<'db>(
             definition.focus_range(db, context.module()).range()
         };
 
-        let Some(builder) = context.report_lint(&INVALID_METHOD_OVERRIDE, range) else {
-            continue;
-        };
-
-        let mut diagnostic =
-            builder.into_diagnostic(format_args!("Invalid override of method `{}`", member.name));
-
-        diagnostic.set_primary_message(format_args!(
-            "Definition is incompatible with `{}.{}`",
-            supercls.name(db),
-            member.name
-        ));
-
-        diagnostic.info("This violates the Liskov Substitution Principle");
-
-        if let Type::BoundMethod(method_on_supercls) = type_on_supercls
-            && let Some(spans) = method_on_supercls
-                .function(db)
-                .literal(db)
-                .last_definition(db)
-                .spans(db)
-        {
-            diagnostic.annotate(Annotation::secondary(spans.signature).message(format_args!(
-                "`{}.{}` defined here",
-                supercls.name(db),
-                member.name
-            )));
-        }
+        report_invalid_method_override(context, range, member, class, supercls, type_on_supercls);
 
         // Only one diagnostic should be emitted per each invalid override,
         // even if it overrides multiple superclasses incorrectly!
+        // It's possible `report_invalid_method_override` didn't emit a diagnostic because there's a
+        // suppression comment, but that too should cause us to exit early here.
         break;
     }
 }