[ty] Don't add incorrect subdiagnostic for unresolved reference (#18487)

Co-authored-by: Alex Waygood <[email protected]>
Co-authored-by: Carl Meyer <[email protected]>

Author: 3 people

crates/ty_python_semantic/resources/mdtest/attributes.md

@@ -946,9 +946,9 @@ def _(flag1: bool, flag2: bool):
 
 <!-- snapshot-diagnostics -->
 
-If a non-declared variable is used and an attribute with the same name is defined and accessible,
-then we emit a subdiagnostic suggesting the use of `self.`.
-(`An attribute with the same name as 'x' is defined, consider using 'self.x'` in these cases)
+If an undefined variable is used in a method, and an attribute with the same name is defined and
+accessible, then we emit a subdiagnostic suggesting the use of `self.`. (These don't appear inline
+here; see the diagnostic snapshots.)
 
 ```py
 class Foo:
@@ -978,6 +978,107 @@ class Foo:
         y = x
 ```
 
+In a staticmethod, we don't suggest that it might be an attribute.
+
+```py
+class Foo:
+    def __init__(self):
+        self.x = 42
+
+    @staticmethod
+    def static_method():
+        # error: [unresolved-reference] "Name `x` used when not defined"
+        y = x
+```
+
+In a classmethod, if the name matches a class attribute, we suggest `cls.`.
+
+```py
+from typing import ClassVar
+
+class Foo:
+    x: ClassVar[int] = 42
+
+    @classmethod
+    def class_method(cls):
+        # error: [unresolved-reference] "Name `x` used when not defined"
+        y = x
+```
+
+In a classmethod, if the name matches an instance-only attribute, we don't suggest anything.
+
+```py
+class Foo:
+    def __init__(self):
+        self.x = 42
+
+    @classmethod
+    def class_method(cls):
+        # error: [unresolved-reference] "Name `x` used when not defined"
+        y = x
+```
+
+We also don't suggest anything if the method is (invalidly) decorated with both `@classmethod` and
+`@staticmethod`:
+
+```py
+class Foo:
+    x: ClassVar[int]
+
+    @classmethod
+    @staticmethod
+    def class_method(cls):
+        # error: [unresolved-reference] "Name `x` used when not defined"
+        y = x
+```
+
+In an instance method that uses some other parameter name in place of `self`, we use that parameter
+name in the sub-diagnostic.
+
+```py
+class Foo:
+    def __init__(self):
+        self.x = 42
+
+    def method(other):
+        # error: [unresolved-reference] "Name `x` used when not defined"
+        y = x
+```
+
+In a classmethod that uses some other parameter name in place of `cls`, we use that parameter name
+in the sub-diagnostic.
+
+```py
+from typing import ClassVar
+
+class Foo:
+    x: ClassVar[int] = 42
+
+    @classmethod
+    def class_method(c_other):
+        # error: [unresolved-reference] "Name `x` used when not defined"
+        y = x
+```
+
+We don't suggest anything if an instance method or a classmethod only has variadic arguments, or if
+the first parameter is keyword-only:
+
+```py
+from typing import ClassVar
+
+class Foo:
+    x: ClassVar[int] = 42
+
+    def instance_method(*args, **kwargs):
+        # error: [unresolved-reference] "Name `x` used when not defined"
+        print(x)
+
+    @classmethod
+    def class_method(*, cls):
+        # error: [unresolved-reference] "Name `x` used when not defined"
+        y = x
+```
+
 ## Unions of attributes
 
 If the (meta)class is a union type or if the attribute on the (meta) class has a union type, we

crates/ty_python_semantic/resources/mdtest/snapshots/attributes.md_-_Attributes_-_Invalid_access_to_at…_(5457445ffed43a87).snap

@@ -31,6 +31,68 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/attributes.md
 17 |     def method(self):
 18 |         # error: [unresolved-reference] "Name `x` used when not defined"
 19 |         y = x
+20 | class Foo:
+21 |     def __init__(self):
+22 |         self.x = 42
+23 | 
+24 |     @staticmethod
+25 |     def static_method():
+26 |         # error: [unresolved-reference] "Name `x` used when not defined"
+27 |         y = x
+28 | from typing import ClassVar
+29 | 
+30 | class Foo:
+31 |     x: ClassVar[int] = 42
+32 | 
+33 |     @classmethod
+34 |     def class_method(cls):
+35 |         # error: [unresolved-reference] "Name `x` used when not defined"
+36 |         y = x
+37 | class Foo:
+38 |     def __init__(self):
+39 |         self.x = 42
+40 | 
+41 |     @classmethod
+42 |     def class_method(cls):
+43 |         # error: [unresolved-reference] "Name `x` used when not defined"
+44 |         y = x
+45 | class Foo:
+46 |     x: ClassVar[int]
+47 | 
+48 |     @classmethod
+49 |     @staticmethod
+50 |     def class_method(cls):
+51 |         # error: [unresolved-reference] "Name `x` used when not defined"
+52 |         y = x
+53 | class Foo:
+54 |     def __init__(self):
+55 |         self.x = 42
+56 | 
+57 |     def method(other):
+58 |         # error: [unresolved-reference] "Name `x` used when not defined"
+59 |         y = x
+60 | from typing import ClassVar
+61 | 
+62 | class Foo:
+63 |     x: ClassVar[int] = 42
+64 | 
+65 |     @classmethod
+66 |     def class_method(c_other):
+67 |         # error: [unresolved-reference] "Name `x` used when not defined"
+68 |         y = x
+69 | from typing import ClassVar
+70 | 
+71 | class Foo:
+72 |     x: ClassVar[int] = 42
+73 | 
+74 |     def instance_method(*args, **kwargs):
+75 |         # error: [unresolved-reference] "Name `x` used when not defined"
+76 |         print(x)
+77 | 
+78 |     @classmethod
+79 |     def class_method(*, cls):
+80 |         # error: [unresolved-reference] "Name `x` used when not defined"
+81 |         y = x
 ```
 
 # Diagnostics
@@ -75,8 +137,128 @@ error[unresolved-reference]: Name `x` used when not defined
 18 |         # error: [unresolved-reference] "Name `x` used when not defined"
 19 |         y = x
    |             ^
+20 | class Foo:
+21 |     def __init__(self):
    |
 info: An attribute `x` is available: consider using `self.x`
 info: rule `unresolved-reference` is enabled by default
 
 ```
+
+```
+error[unresolved-reference]: Name `x` used when not defined
+  --> src/mdtest_snippet.py:27:13
+   |
+25 |     def static_method():
+26 |         # error: [unresolved-reference] "Name `x` used when not defined"
+27 |         y = x
+   |             ^
+28 | from typing import ClassVar
+   |
+info: rule `unresolved-reference` is enabled by default
+
+```
+
+```
+error[unresolved-reference]: Name `x` used when not defined
+  --> src/mdtest_snippet.py:36:13
+   |
+34 |     def class_method(cls):
+35 |         # error: [unresolved-reference] "Name `x` used when not defined"
+36 |         y = x
+   |             ^
+37 | class Foo:
+38 |     def __init__(self):
+   |
+info: An attribute `x` is available: consider using `cls.x`
+info: rule `unresolved-reference` is enabled by default
+
+```
+
+```
+error[unresolved-reference]: Name `x` used when not defined
+  --> src/mdtest_snippet.py:44:13
+   |
+42 |     def class_method(cls):
+43 |         # error: [unresolved-reference] "Name `x` used when not defined"
+44 |         y = x
+   |             ^
+45 | class Foo:
+46 |     x: ClassVar[int]
+   |
+info: rule `unresolved-reference` is enabled by default
+
+```
+
+```
+error[unresolved-reference]: Name `x` used when not defined
+  --> src/mdtest_snippet.py:52:13
+   |
+50 |     def class_method(cls):
+51 |         # error: [unresolved-reference] "Name `x` used when not defined"
+52 |         y = x
+   |             ^
+53 | class Foo:
+54 |     def __init__(self):
+   |
+info: rule `unresolved-reference` is enabled by default
+
+```
+
+```
+error[unresolved-reference]: Name `x` used when not defined
+  --> src/mdtest_snippet.py:59:13
+   |
+57 |     def method(other):
+58 |         # error: [unresolved-reference] "Name `x` used when not defined"
+59 |         y = x
+   |             ^
+60 | from typing import ClassVar
+   |
+info: An attribute `x` is available: consider using `other.x`
+info: rule `unresolved-reference` is enabled by default
+
+```
+
+```
+error[unresolved-reference]: Name `x` used when not defined
+  --> src/mdtest_snippet.py:68:13
+   |
+66 |     def class_method(c_other):
+67 |         # error: [unresolved-reference] "Name `x` used when not defined"
+68 |         y = x
+   |             ^
+69 | from typing import ClassVar
+   |
+info: An attribute `x` is available: consider using `c_other.x`
+info: rule `unresolved-reference` is enabled by default
+
+```
+
+```
+error[unresolved-reference]: Name `x` used when not defined
+  --> src/mdtest_snippet.py:76:15
+   |
+74 |     def instance_method(*args, **kwargs):
+75 |         # error: [unresolved-reference] "Name `x` used when not defined"
+76 |         print(x)
+   |               ^
+77 |
+78 |     @classmethod
+   |
+info: rule `unresolved-reference` is enabled by default
+
+```
+
+```
+error[unresolved-reference]: Name `x` used when not defined
+  --> src/mdtest_snippet.py:81:13
+   |
+79 |     def class_method(*, cls):
+80 |         # error: [unresolved-reference] "Name `x` used when not defined"
+81 |         y = x
+   |             ^
+   |
+info: rule `unresolved-reference` is enabled by default
+
+```

crates/ty_python_semantic/src/semantic_index/place.rs

@@ -581,7 +581,7 @@ pub enum ScopeKind {
 }
 
 impl ScopeKind {
-    pub(crate) fn is_eager(self) -> bool {
+    pub(crate) const fn is_eager(self) -> bool {
         match self {
             ScopeKind::Module | ScopeKind::Class | ScopeKind::Comprehension => true,
             ScopeKind::Annotation
@@ -591,7 +591,7 @@ impl ScopeKind {
         }
     }
 
-    pub(crate) fn is_function_like(self) -> bool {
+    pub(crate) const fn is_function_like(self) -> bool {
         // Type parameter scopes behave like function scopes in terms of name resolution; CPython
         // place table also uses the term "function-like" for these scopes.
         matches!(
@@ -604,13 +604,17 @@ impl ScopeKind {
         )
     }
 
-    pub(crate) fn is_class(self) -> bool {
+    pub(crate) const fn is_class(self) -> bool {
         matches!(self, ScopeKind::Class)
     }
 
-    pub(crate) fn is_type_parameter(self) -> bool {
+    pub(crate) const fn is_type_parameter(self) -> bool {
         matches!(self, ScopeKind::Annotation | ScopeKind::TypeAlias)
     }
+
+    pub(crate) const fn is_non_lambda_function(self) -> bool {
+        matches!(self, ScopeKind::Function)
+    }
 }
 
 /// [`PlaceExpr`] table for a specific [`Scope`].