[ty] Offer "Did you mean...?" suggestions for unresolved from imports and unresolved attributes

_typos.toml

@@ -8,6 +8,8 @@ extend-exclude = [
     # words naturally. It's annoying to have to make all
     # of them actually words. So just ignore typos here.
     "crates/ty_ide/src/completion.rs",
+    # Same for "Did you mean...?" levenshtein tests.
+    "crates/ty_python_semantic/src/types/diagnostic/levenshtein.rs",
 ]
 
 [default.extend-words]

crates/ty_python_semantic/resources/mdtest/attributes.md

@@ -2166,6 +2166,57 @@ reveal_type(Foo.BAR.value)  # revealed: @Todo(Attribute access on enum classes)
 reveal_type(Foo.__members__)  # revealed: @Todo(Attribute access on enum classes)
 ```
 
+## Suggestions for obvious typos
+
+<!-- snapshot-diagnostics -->
+
+For obvious typos, we add a "Did you mean...?" suggestion to the diagnostic.
+
+```py
+import collections
+
+print(collections.dequee)  # error: [unresolved-attribute]
+```
+
+But the suggestion is suppressed if the only close matches start with a leading underscore:
+
+```py
+class Foo:
+    _bar = 42
+
+print(Foo.bar)  # error: [unresolved-attribute]
+```
+
+The suggestion is not suppressed if the typo itself starts with a leading underscore, however:
+
+```py
+print(Foo._barr)  # error: [unresolved-attribute]
+```
+
+And in method contexts, the suggestion is never suppressed if accessing an attribute on an instance
+of the method's enclosing class:
+
+```py
+class Bar:
+    _attribute = 42
+
+    def f(self, x: "Bar"):
+        # TODO: we should emit `[unresolved-attribute]` here, should have the same behaviour as `x.attribute` below
+        print(self.attribute)
+
+        # We give a suggestion here, even though the only good candidates start with underscores and the typo does not,
+        # because we're in a method context and `x` is an instance of the enclosing class.
+        print(x.attribute)  # error: [unresolved-attribute]
+
+class Baz:
+    def f(self, x: Bar):
+        # No suggestion is given here, because:
+        # - the good suggestions all start with underscores
+        # - the typo does not start with an underscore
+        # - We *are* in a method context, but `x` is not an instance of the enclosing class
+        print(x.attribute)  # error: [unresolved-attribute]
+```
+
 ## References
 
 Some of the tests in the *Class and instance variables* section draw inspiration from

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

@@ -205,3 +205,39 @@ python-version = "3.13"
 import aifc  # error: [unresolved-import]
 from distutils import sysconfig  # error: [unresolved-import]
 ```
+
+## `from` import that has a typo
+
+We offer a "Did you mean?" subdiagnostic suggestion if there's a name in the module that's
+reasonably similar to the unresolved member.
+
+<!-- snapshot-diagnostics -->
+
+`foo.py`:
+
+```py
+from collections import dequee  # error: [unresolved-import]
+```
+
+However, we suppress the suggestion if the only close matches in the module start with a leading
+underscore:
+
+`bar.py`:
+
+```py
+from baz import foo  # error: [unresolved-import]
+```
+
+`baz.py`:
+
+```py
+_foo = 42
+```
+
+The suggestion is never suppressed if the typo itself starts with a leading underscore, however:
+
+`eggs.py`:
+
+```py
+from baz import _fooo  # error: [unresolved-import]
+```

crates/ty_python_semantic/resources/mdtest/snapshots/attributes.md_-_Attributes_-_Suggestions_for_obvi…_(bf7b28ef99f0ec16).snap

@@ -0,0 +1,115 @@
+---
+source: crates/ty_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: attributes.md - Attributes - Suggestions for obvious typos
+mdtest path: crates/ty_python_semantic/resources/mdtest/attributes.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+ 1 | import collections
+ 2 | 
+ 3 | print(collections.dequee)  # error: [unresolved-attribute]
+ 4 | class Foo:
+ 5 |     _bar = 42
+ 6 | 
+ 7 | print(Foo.bar)  # error: [unresolved-attribute]
+ 8 | print(Foo._barr)  # error: [unresolved-attribute]
+ 9 | class Bar:
+10 |     _attribute = 42
+11 | 
+12 |     def f(self, x: "Bar"):
+13 |         # TODO: we should emit `[unresolved-attribute]` here, should have the same behaviour as `x.attribute` below
+14 |         print(self.attribute)
+15 | 
+16 |         # We give a suggestion here, even though the only good candidates start with underscores and the typo does not,
+17 |         # because we're in a method context and `x` is an instance of the enclosing class.
+18 |         print(x.attribute)  # error: [unresolved-attribute]
+19 | 
+20 | class Baz:
+21 |     def f(self, x: Bar):
+22 |         # No suggestion is given here, because:
+23 |         # - the good suggestions all start with underscores
+24 |         # - the typo does not start with an underscore
+25 |         # - We *are* in a method context, but `x` is not an instance of the enclosing class
+26 |         print(x.attribute)  # error: [unresolved-attribute]
+```
+
+# Diagnostics
+
+```
+error[unresolved-attribute]: Type `<module 'collections'>` has no attribute `dequee`
+ --> src/mdtest_snippet.py:3:7
+  |
+1 | import collections
+2 |
+3 | print(collections.dequee)  # error: [unresolved-attribute]
+  |       ^^^^^^^^^^^^^^^^^^ Did you mean `deque`?
+4 | class Foo:
+5 |     _bar = 42
+  |
+info: rule `unresolved-attribute` is enabled by default
+
+```
+
+```
+error[unresolved-attribute]: Type `<class 'Foo'>` has no attribute `bar`
+ --> src/mdtest_snippet.py:7:7
+  |
+5 |     _bar = 42
+6 |
+7 | print(Foo.bar)  # error: [unresolved-attribute]
+  |       ^^^^^^^
+8 | print(Foo._barr)  # error: [unresolved-attribute]
+9 | class Bar:
+  |
+info: rule `unresolved-attribute` is enabled by default
+
+```
+
+```
+error[unresolved-attribute]: Type `<class 'Foo'>` has no attribute `_barr`
+  --> src/mdtest_snippet.py:8:7
+   |
+ 7 | print(Foo.bar)  # error: [unresolved-attribute]
+ 8 | print(Foo._barr)  # error: [unresolved-attribute]
+   |       ^^^^^^^^^ Did you mean `_bar`?
+ 9 | class Bar:
+10 |     _attribute = 42
+   |
+info: rule `unresolved-attribute` is enabled by default
+
+```
+
+```
+error[unresolved-attribute]: Type `Bar` has no attribute `attribute`
+  --> src/mdtest_snippet.py:18:15
+   |
+16 |         # We give a suggestion here, even though the only good candidates start with underscores and the typo does not,
+17 |         # because we're in a method context and `x` is an instance of the enclosing class.
+18 |         print(x.attribute)  # error: [unresolved-attribute]
+   |               ^^^^^^^^^^^ Did you mean `_attribute`?
+19 |
+20 | class Baz:
+   |
+info: rule `unresolved-attribute` is enabled by default
+
+```
+
+```
+error[unresolved-attribute]: Type `Bar` has no attribute `attribute`
+  --> src/mdtest_snippet.py:26:15
+   |
+24 |         # - the typo does not start with an underscore
+25 |         # - We *are* in a method context, but `x` is not an instance of the enclosing class
+26 |         print(x.attribute)  # error: [unresolved-attribute]
+   |               ^^^^^^^^^^^
+   |
+info: rule `unresolved-attribute` is enabled by default
+
+```

crates/ty_python_semantic/resources/mdtest/snapshots/basic.md_-_Structures_-_`from`_import_that_h…_(3caffc60d8390adf).snap

@@ -0,0 +1,69 @@
+---
+source: crates/ty_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: basic.md - Structures - `from` import that has a typo
+mdtest path: crates/ty_python_semantic/resources/mdtest/import/basic.md
+---
+
+# Python source files
+
+## foo.py
+
+```
+1 | from collections import dequee  # error: [unresolved-import]
+```
+
+## bar.py
+
+```
+1 | from baz import foo  # error: [unresolved-import]
+```
+
+## baz.py
+
+```
+1 | _foo = 42
+```
+
+## eggs.py
+
+```
+1 | from baz import _fooo  # error: [unresolved-import]
+```
+
+# Diagnostics
+
+```
+error[unresolved-import]: Module `collections` has no member `dequee`
+ --> src/foo.py:1:25
+  |
+1 | from collections import dequee  # error: [unresolved-import]
+  |                         ^^^^^^ Did you mean `deque`?
+  |
+info: rule `unresolved-import` is enabled by default
+
+```
+
+```
+error[unresolved-import]: Module `baz` has no member `foo`
+ --> src/bar.py:1:17
+  |
+1 | from baz import foo  # error: [unresolved-import]
+  |                 ^^^
+  |
+info: rule `unresolved-import` is enabled by default
+
+```
+
+```
+error[unresolved-import]: Module `baz` has no member `_fooo`
+ --> src/eggs.py:1:17
+  |
+1 | from baz import _fooo  # error: [unresolved-import]
+  |                 ^^^^^ Did you mean `_foo`?
+  |
+info: rule `unresolved-import` is enabled by default
+
+```

crates/ty_python_semantic/src/semantic_model.rs

@@ -10,7 +10,7 @@ use crate::module_resolver::{Module, resolve_module};
 use crate::semantic_index::ast_ids::HasScopedExpressionId;
 use crate::semantic_index::place::FileScopeId;
 use crate::semantic_index::semantic_index;
-use crate::types::ide_support::all_declarations_and_bindings;
+use crate::types::all_members::all_declarations_and_bindings;
 use crate::types::{Type, binding_type, infer_scope_types};
 
 pub struct SemanticModel<'db> {

crates/ty_python_semantic/src/types.rs

@@ -38,6 +38,7 @@ use crate::semantic_index::definition::Definition;
 use crate::semantic_index::place::{ScopeId, ScopedPlaceId};
 use crate::semantic_index::{imported_modules, place_table, semantic_index};
 use crate::suppression::check_suppressions;
+pub use crate::types::all_members::all_members;
 use crate::types::call::{Binding, Bindings, CallArgumentTypes, CallableBinding};
 pub(crate) use crate::types::class_base::ClassBase;
 use crate::types::context::{LintDiagnosticGuard, LintDiagnosticGuardBuilder};
@@ -46,7 +47,6 @@ use crate::types::function::{
     DataclassTransformerParams, FunctionSpans, FunctionType, KnownFunction,
 };
 use crate::types::generics::{GenericContext, PartialSpecialization, Specialization};
-pub use crate::types::ide_support::all_members;
 use crate::types::infer::infer_unpack_types;
 use crate::types::mro::{Mro, MroError, MroIterator};
 pub(crate) use crate::types::narrow::infer_narrowing_constraint;
@@ -58,6 +58,7 @@ use instance::Protocol;
 pub use instance::{NominalInstanceType, ProtocolInstanceType};
 pub use special_form::SpecialFormType;
 
+pub(crate) mod all_members;
 mod builder;
 mod call;
 mod class;
@@ -67,7 +68,6 @@ mod diagnostic;
 mod display;
 mod function;
 mod generics;
-pub(crate) mod ide_support;
 mod infer;
 mod instance;
 mod mro;

crates/ty_python_semantic/src/types/ide_support.rs → crates/ty_python_semantic/src/types/all_members.rs

@@ -1,3 +1,9 @@
+//! Routines to gather all members of a type.
+//!
+//! This is used in autocompletion logic from the `ty_ide` crate,
+//! but it is also used in the `ty_python_semantic` crate to provide
+//! "Did you mean...?" suggestions in diagnostics.
+
 use crate::Db;
 use crate::place::{imported_symbol, place_from_bindings, place_from_declarations};
 use crate::semantic_index::place::ScopeId;

crates/ty_python_semantic/src/types/call/bind.rs

@@ -25,7 +25,7 @@ use crate::types::signatures::{Parameter, ParameterForm};
 use crate::types::{
     BoundMethodType, ClassLiteral, DataclassParams, KnownClass, KnownInstanceType,
     MethodWrapperKind, PropertyInstanceType, SpecialFormType, TupleType, TypeMapping, UnionType,
-    WrapperDescriptorKind, ide_support, todo_type,
+    WrapperDescriptorKind, all_members, todo_type,
 };
 use ruff_db::diagnostic::{Annotation, Diagnostic, Severity, SubDiagnostic};
 use ruff_python_ast as ast;
@@ -667,7 +667,7 @@ impl<'db> Bindings<'db> {
                             if let [Some(ty)] = overload.parameter_types() {
                                 overload.set_return_type(TupleType::from_elements(
                                     db,
-                                    ide_support::all_members(db, *ty)
+                                    all_members::all_members(db, *ty)
                                         .into_iter()
                                         .sorted()
                                         .map(|member| Type::string_literal(db, &member)),

crates/ty_python_semantic/src/types/class.rs

@@ -225,6 +225,10 @@ pub enum ClassType<'db> {
 
 #[salsa::tracked]
 impl<'db> ClassType<'db> {
+    pub(super) fn is_protocol(self, db: &'db dyn Db) -> bool {
+        self.class_literal(db).0.is_protocol(db)
+    }
+
     pub(super) fn normalized(self, db: &'db dyn Db) -> Self {
         match self {
             Self::NonGeneric(_) => self,