Nicer diagnostics

Author: sharkdp

Cargo.lock

@@ -48,6 +48,7 @@ test-case = { workspace = true }
 memchr = { workspace = true }
 strum = { workspace = true }
 strum_macros = { workspace = true }
+strsim = "0.11.1"
 
 [dev-dependencies]
 ruff_db = { workspace = true, features = ["testing", "os"] }

crates/ty_python_semantic/Cargo.toml

@@ -0,0 +1,77 @@
+---
+source: crates/ty_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: typed_dict.md - `TypedDict` - Diagnostics
+mdtest path: crates/ty_python_semantic/resources/mdtest/typed_dict.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+ 1 | from typing import TypedDict, Final
+ 2 | 
+ 3 | class Person(TypedDict):
+ 4 |     name: str
+ 5 |     age: int | None
+ 6 | 
+ 7 | def access_invalid_literal_string_key(person: Person):
+ 8 |     person["naem"]  # error: [invalid-key]
+ 9 | 
+10 | NAME_KEY: Final = "naem"
+11 | 
+12 | def access_invalid_key(person: Person):
+13 |     person[NAME_KEY]  # error: [invalid-key]
+14 | 
+15 | def access_with_str_key(person: Person, str_key: str):
+16 |     person[str_key]  # error: [invalid-key]
+```
+
+# Diagnostics
+
+```
+error[invalid-key]: Invalid key access on TypedDict `Person`
+  --> src/mdtest_snippet.py:8:5
+   |
+ 7 | def access_invalid_literal_string_key(person: Person):
+ 8 |     person["naem"]  # error: [invalid-key]
+   |     ------ ^^^^^^ Unknown key "naem" - did you mean "name"?
+   |     |
+   |     TypedDict `Person`
+ 9 |
+10 | NAME_KEY: Final = "naem"
+   |
+info: rule `invalid-key` is enabled by default
+
+```
+
+```
+error[invalid-key]: Invalid key access on TypedDict `Person`
+  --> src/mdtest_snippet.py:13:5
+   |
+12 | def access_invalid_key(person: Person):
+13 |     person[NAME_KEY]  # error: [invalid-key]
+   |     ------ ^^^^^^^^ Unknown key "naem" - did you mean "name"?
+   |     |
+   |     TypedDict `Person`
+14 |
+15 | def access_with_str_key(person: Person, str_key: str):
+   |
+info: rule `invalid-key` is enabled by default
+
+```
+
+```
+error[invalid-key]: TypedDict `Person` can not be indexed with a key of type `str`
+  --> src/mdtest_snippet.py:16:12
+   |
+15 | def access_with_str_key(person: Person, str_key: str):
+16 |     person[str_key]  # error: [invalid-key]
+   |            ^^^^^^^
+   |
+info: rule `invalid-key` is enabled by default
+
+```

crates/ty_python_semantic/resources/mdtest/snapshots/typed_dict.md_-_`TypedDict`_-_Diagnostics_(e5289abf5c570c29).snap

@@ -26,7 +26,7 @@ reveal_type(alice["name"])  # revealed: Unknown
 # TODO: this should be `int | None`
 reveal_type(alice["age"])  # revealed: Unknown
 
-# TODO: this should reveal `Never`, and it should emit an error
+# TODO: this should reveal `Unknown`, and it should emit an error
 reveal_type(alice["non_existing"])  # revealed: Unknown
 ```
 
@@ -38,7 +38,7 @@ bob = Person(name="Bob", age=25)
 reveal_type(bob["name"])  # revealed: str
 reveal_type(bob["age"])  # revealed: int | None
 
-# error: [invalid-key] "The `Person` TypedDict does not define a key named 'non_existing'"
+# error: [invalid-key] "Invalid key access on TypedDict `Person`: Unknown key "non_existing""
 reveal_type(bob["non_existing"])  # revealed: Unknown
 ```
 
@@ -139,7 +139,7 @@ reveal_type(alice["name"])  # revealed: Unknown
 ## Key-based access
 
 ```py
-from typing import TypedDict, Final, Literal
+from typing import TypedDict, Final, Literal, Any
 
 class Person(TypedDict):
     name: str
@@ -148,7 +148,7 @@ class Person(TypedDict):
 NAME_FINAL: Final = "name"
 AGE_FINAL: Final[Literal["age"]] = "age"
 
-def _(person: Person, literal_key: Literal["age"], union_of_keys: Literal["age", "name"], unknown_key: str) -> None:
+def _(person: Person, literal_key: Literal["age"], union_of_keys: Literal["age", "name"], str_key: str, unknown_key: Any) -> None:
     reveal_type(person["name"])  # revealed: str
     reveal_type(person["age"])  # revealed: int | None
 
@@ -159,10 +159,13 @@ def _(person: Person, literal_key: Literal["age"], union_of_keys: Literal["age",
 
     reveal_type(person[union_of_keys])  # revealed: int | None | str
 
-    # error: [invalid-key] "The `Person` TypedDict does not define a key named 'non_existing'"
+    # error: [invalid-key] "Invalid key access on TypedDict `Person`: Unknown key "non_existing""
     reveal_type(person["non_existing"])  # revealed: Unknown
 
-    # error: [invalid-key] "The `Person` TypedDict can not be indexed with a key of type `str`"
+    # error: [invalid-key] "TypedDict `Person` can not be indexed with a key of type `str`"
+    reveal_type(person[str_key])  # revealed: Unknown
+
+    # No error here:
     reveal_type(person[unknown_key])  # revealed: Unknown
 ```
 
@@ -372,4 +375,29 @@ reveal_type(Message.__required_keys__)  # revealed: @Todo(Support for `TypedDict
 msg.content
 ```
 
+## Diagnostics
+
+<!-- snapshot-diagnostics -->
+
+Snapshot tests for diagnostic messages including suggestions:
+
+```py
+from typing import TypedDict, Final
+
+class Person(TypedDict):
+    name: str
+    age: int | None
+
+def access_invalid_literal_string_key(person: Person):
+    person["naem"]  # error: [invalid-key]
+
+NAME_KEY: Final = "naem"
+
+def access_invalid_key(person: Person):
+    person[NAME_KEY]  # error: [invalid-key]
+
+def access_with_str_key(person: Person, str_key: str):
+    person[str_key]  # error: [invalid-key]
+```
+
 [`typeddict`]: https://typing.python.org/en/latest/spec/typeddict.html

crates/ty_python_semantic/resources/mdtest/typed_dict.md

@@ -38,6 +38,7 @@ use crate::semantic_index::scope::ScopeId;
 use crate::semantic_index::{imported_modules, place_table, semantic_index};
 use crate::suppression::check_suppressions;
 use crate::types::call::{Binding, Bindings, CallArguments, CallableBinding};
+use crate::types::class::{CodeGeneratorKind, Field, FxOrderMap};
 pub(crate) use crate::types::class_base::ClassBase;
 use crate::types::context::{LintDiagnosticGuard, LintDiagnosticGuardBuilder};
 use crate::types::diagnostic::{INVALID_TYPE_FORM, UNSUPPORTED_BOOL_CONVERSION};
@@ -669,10 +670,6 @@ impl<'db> Type<'db> {
         matches!(self, Type::Dynamic(_))
     }
 
-    pub(crate) const fn is_typed_dict(&self) -> bool {
-        matches!(self, Type::TypedDict(..))
-    }
-
     /// Returns the top materialization (or upper bound materialization) of this type, which is the
     /// most general form of the type that is fully static.
     #[must_use]
@@ -834,6 +831,17 @@ impl<'db> Type<'db> {
             .expect("Expected a Type::EnumLiteral variant")
     }
 
+    pub(crate) const fn is_typed_dict(&self) -> bool {
+        matches!(self, Type::TypedDict(..))
+    }
+
+    pub(crate) fn into_typed_dict(self) -> Option<TypedDictType<'db>> {
+        match self {
+            Type::TypedDict(typed_dict) => Some(typed_dict),
+            _ => None,
+        }
+    }
+
     /// Turn a class literal (`Type::ClassLiteral` or `Type::GenericAlias`) into a `ClassType`.
     /// Since a `ClassType` must be specialized, apply the default specialization to any
     /// unspecialized generic class literal.
@@ -8933,6 +8941,11 @@ impl<'db> TypedDictType<'db> {
         Type::TypedDict(Self::new(db, defining_class))
     }
 
+    pub(crate) fn items(self, db: &'db dyn Db) -> FxOrderMap<Name, Field<'db>> {
+        let (class_literal, specialization) = self.defining_class(db).class_literal(db);
+        class_literal.fields(db, specialization, CodeGeneratorKind::TypedDict)
+    }
+
     pub(crate) fn apply_type_mapping<'a>(
         self,
         db: &'db dyn Db,

crates/ty_python_semantic/src/types.rs

@@ -56,7 +56,7 @@ use ruff_python_ast::{self as ast, PythonVersion};
 use ruff_text_size::{Ranged, TextRange};
 use rustc_hash::{FxHashSet, FxHasher};
 
-type FxOrderMap<K, V> = ordermap::map::OrderMap<K, V, BuildHasherDefault<FxHasher>>;
+pub(crate) type FxOrderMap<K, V> = ordermap::map::OrderMap<K, V, BuildHasherDefault<FxHasher>>;
 
 fn explicit_bases_cycle_recover<'db>(
     _db: &'db dyn Db,
@@ -1097,11 +1097,11 @@ impl MethodDecorator {
     }
 }
 
-/// Metadata regarding a dataclass field/attribute.
+/// Metadata regarding a dataclass field/attribute or a `TypedDict` "item" / key-value pair.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct DataclassField<'db> {
+pub(crate) struct Field<'db> {
     /// The declared type of the field
-    pub(crate) field_ty: Type<'db>,
+    pub(crate) declared_ty: Type<'db>,
 
     /// The type of the default value for this field
     pub(crate) default_ty: Option<Type<'db>>,
@@ -1858,8 +1858,8 @@ impl<'db> ClassLiteral<'db> {
             let mut kw_only_field_seen = false;
             for (
                 field_name,
-                DataclassField {
-                    mut field_ty,
+                Field {
+                    declared_ty: mut field_ty,
                     mut default_ty,
                     init_only: _,
                     init,
@@ -2051,7 +2051,7 @@ impl<'db> ClassLiteral<'db> {
                             Parameter::positional_only(Some(Name::new_static("key")))
                                 .with_annotated_type(key_type),
                         ]),
-                        Some(field.field_ty),
+                        Some(field.declared_ty),
                     )
                 });
 
@@ -2154,7 +2154,7 @@ impl<'db> ClassLiteral<'db> {
         db: &'db dyn Db,
         specialization: Option<Specialization<'db>>,
         field_policy: CodeGeneratorKind,
-    ) -> FxOrderMap<Name, DataclassField<'db>> {
+    ) -> FxOrderMap<Name, Field<'db>> {
         if field_policy == CodeGeneratorKind::NamedTuple {
             // NamedTuples do not allow multiple inheritance, so it is sufficient to enumerate the
             // fields of this class only.
@@ -2201,7 +2201,7 @@ impl<'db> ClassLiteral<'db> {
         self,
         db: &'db dyn Db,
         specialization: Option<Specialization<'db>>,
-    ) -> FxOrderMap<Name, DataclassField<'db>> {
+    ) -> FxOrderMap<Name, Field<'db>> {
         let mut attributes = FxOrderMap::default();
 
         let class_body_scope = self.body_scope(db);
@@ -2253,8 +2253,8 @@ impl<'db> ClassLiteral<'db> {
 
                     attributes.insert(
                         symbol.name().clone(),
-                        DataclassField {
-                            field_ty: attr_ty.apply_optional_specialization(db, specialization),
+                        Field {
+                            declared_ty: attr_ty.apply_optional_specialization(db, specialization),
                             default_ty,
                             init_only: attr.is_init_var(),
                             init,

crates/ty_python_semantic/src/types/class.rs

@@ -2617,3 +2617,28 @@ pub(super) fn hint_if_stdlib_submodule_exists_on_other_versions(
 
     add_inferred_python_version_hint_to_diagnostic(db, &mut diagnostic, "resolving modules");
 }
+
+/// Suggest a name from `existing_names` that is similar to `wrong_name`.
+pub(super) fn did_you_mean<S: AsRef<str>, T: AsRef<str>>(
+    existing_names: impl Iterator<Item = S>,
+    wrong_name: T,
+) -> Option<String> {
+    if wrong_name.as_ref().len() < 3 {
+        return None;
+    }
+
+    existing_names
+        .map(|ref id| {
+            (
+                id.as_ref().to_string(),
+                strsim::damerau_levenshtein(
+                    &id.as_ref().to_lowercase(),
+                    &wrong_name.as_ref().to_lowercase(),
+                ),
+            )
+        })
+        .min_by_key(|(_, dist)| *dist)
+        // Heuristic to filter out bad matches
+        .filter(|(id, dist)| id.len() >= 2 && *dist <= 3)
+        .map(|(id, _)| id)
+}