Better tests, address review comments

Author: sharkdp

crates/ty_python_semantic/resources/mdtest/annotations/self.md

@@ -56,7 +56,7 @@ In instance methods, the first parameter (regardless of its name) is assumed to
 
 ```toml
 [environment]
-python-version = "3.11"
+python-version = "3.12"
 ```
 
 ```py
@@ -68,11 +68,26 @@ class A:
 
         return self
 
-    def a_method(self) -> int:
-        def first_arg_is_not_self(a: int) -> int:
+    def implicit_self_generic[T](self, x: T) -> T:
+        reveal_type(self)  # revealed: Self@implicit_self_generic
+
+        return x
+
+    def method_a(self) -> None:
+        def first_param_is_not_self(a: int):
             reveal_type(a)  # revealed: int
-            return a
-        return first_arg_is_not_self(1)
+            reveal_type(self)  # revealed: Self@method_a
+
+        def first_param_is_not_self_unannotated(a):
+            reveal_type(a)  # revealed: Unknown
+            reveal_type(self)  # revealed: Self@method_a
+
+        def first_param_is_also_not_self(self) -> None:
+            reveal_type(self)  # revealed: Unknown
+
+        def first_param_is_explicit_self(this: Self) -> None:
+            reveal_type(this)  # revealed: Self@method_a
+            reveal_type(self)  # revealed: Self@method_a
 
     @classmethod
     def a_classmethod(cls) -> Self:

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

@@ -83,7 +83,7 @@ use crate::types::generics::{
     GenericContext, InferableTypeVars, LegacyGenericBase, SpecializationBuilder, bind_typevar,
     enclosing_generic_contexts, typing_self,
 };
-use crate::types::infer::{nearest_enclosing_class, nearest_enclosing_function};
+use crate::types::infer::nearest_enclosing_function;
 use crate::types::instance::SliceLiteral;
 use crate::types::mro::MroErrorKind;
 use crate::types::signatures::Signature;
@@ -2543,45 +2543,57 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
         parameter: &ast::Parameter,
     ) -> Option<Type<'db>> {
         let db = self.db();
-        let scope_id = self.scope();
-        let file = scope_id.file(db);
-        let function_scope = scope_id.scope(db);
-        let method = function_scope.node().as_function()?;
+        let file = self.file();
 
-        let parent_scope_id = function_scope.parent()?;
-        let parent_scope = self.index.scope(parent_scope_id);
-        parent_scope.node().as_class()?;
+        let function_scope_id = self.scope();
+        let function_scope = function_scope_id.scope(db);
+        let function = function_scope.node().as_function()?;
 
-        let method_definition = self.index.expect_single_definition(method);
+        let parent_file_scope_id = function_scope.parent()?;
+        let mut parent_scope_id = parent_file_scope_id.to_scope_id(db, file);
+
+        // Skip type parameter scopes, if the method itself is generic.
+        if parent_scope_id.is_annotation(db) {
+            let parent_scope = parent_scope_id.scope(db);
+            parent_scope_id = parent_scope.parent()?.to_scope_id(db, file);
+        }
+
+        // Return early if this is not a method inside a class.
+        let class = parent_scope_id.scope(db).node().as_class()?;
+
+        let method_definition = self.index.expect_single_definition(function);
         let DefinitionKind::Function(function_definition) = method_definition.kind(db) else {
             return None;
         };
 
-        let func_type = infer_definition_types(db, method_definition)
-            .declaration_type(method_definition)
-            .inner_type()
-            .as_function_literal()?;
-
-        let module = parsed_module(db, file).load(db);
         if function_definition
-            .node(&module)
+            .node(self.module())
             .parameters
             .index(parameter.name())
-            .is_some_and(|index| index != 0)
+            .is_none_or(|index| index != 0)
         {
             return None;
         }
 
-        if func_type.is_classmethod(db) {
+        let method = infer_definition_types(db, method_definition)
+            .declaration_type(method_definition)
+            .inner_type()
+            .as_function_literal()?;
+
+        if method.is_classmethod(db) {
             // TODO: set the type for `cls` argument
             return None;
-        } else if func_type.is_staticmethod(db) {
+        } else if method.is_staticmethod(db) {
             return None;
         }
 
-        let class = nearest_enclosing_class(db, self.index, scope_id).unwrap();
+        let class_definition = self.index.expect_single_definition(class);
+        let class_literal = infer_definition_types(db, class_definition)
+            .declaration_type(class_definition)
+            .inner_type()
+            .as_class_literal()?;
 
-        typing_self(db, self.scope(), Some(method_definition), class)
+        typing_self(db, self.scope(), Some(method_definition), class_literal)
     }
 
     /// Set initial declared/inferred types for a `*args` variadic positional parameter.