Handle when scope is unexpected

Author: Glyphack

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

@@ -300,7 +300,7 @@ def _(c: Callable[[int, Unpack[Ts]], int]):
 from typing import Callable
 
 def _(c: Callable[[int], int]):
-    reveal_type(c.__init__)  # revealed: def __init__(self) -> None
+    reveal_type(c.__init__)  # revealed: def __init__(self: Self) -> None
     reveal_type(c.__class__)  # revealed: type
     reveal_type(c.__call__)  # revealed: (int, /) -> int
 ```

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

@@ -130,5 +130,6 @@ class Container(Generic[T]):
     def set_value(self: Self, value: T) -> Self:
         return self
 
-reveal_type(Shape().implicit_self())  # revealed: Shape
+c = Container[int]()
+reveal_type(c.set_value(1))  # revealed: Container[int]
 ```

crates/ty_python_semantic/src/types/infer.rs

@@ -2132,53 +2132,51 @@ impl<'db> TypeInferenceBuilder<'db> {
             let ty = if let Some(default_ty) = default_ty {
                 UnionType::from_elements(self.db(), [Type::unknown(), default_ty])
             } else {
-                let func =
-                    enclosing_function_definition(self.db(), self.index, self.scope()).unwrap();
-                let DefinitionKind::Function(func_def) = func.kind(self.db()) else {
-                    panic!("Expected function definition");
-                };
-                let func_type =
-                    enclosing_function_type(self.db(), self.index, self.scope()).unwrap();
-                // TODO: Enum or something better
-                let mut first_self_or_cls = 1;
-
-                if func_type.has_known_decorator(self.db(), FunctionDecorators::CLASSMETHOD) {
-                    first_self_or_cls = 2;
-                }
-                // if func_type
-                //     .has_known_decorator(self.db(), FunctionDecorators::STATICMETHOD)
-                // {
-                //     first_self_or_cls = 3;
-                // }
-
-                // If this parameter is the first parameter
-                if func_def
-                    .parameters
-                    .index(parameter.name())
-                    .is_some_and(|index| index == 0)
-                {
-                    // if the first parameter is `self`
-                    if first_self_or_cls == 1 {
-                        let ty = Type::KnownInstance(KnownInstanceType::TypingSelf)
-                            .in_type_expression(self.db(), self.scope())
-                            .unwrap();
-                        ty
-                    // TODO: if the first parameter is `cls`
-                    } else if first_self_or_cls == 2 {
-                        // type[Self]
-                        Type::unknown()
-                    // TODO: This is a static method
-                    } else {
-                        Type::unknown()
-                    }
-                } else {
-                    Type::unknown()
-                }
+                self.special_first_method_argument(parameter)
             };
             self.add_binding(parameter.into(), definition, ty);
         }
     }
 
+    // Extract this logic into a separate function
+    fn special_first_method_argument(&self, parameter: &ast::Parameter) -> Type<'db> {
+        let Some(func_type) = enclosing_function_type(self.db(), self.index, self.scope()) else {
+            return Type::unknown();
+        };
+        let Some(func) = enclosing_function_definition(self.db(), self.index, self.scope()) else {
+            return Type::unknown();
+        };
+        let DefinitionKind::Function(func_def) = func.kind(self.db()) else {
+            return Type::unknown();
+        };
+
+        let method_type =
+            if func_type.has_known_decorator(self.db(), FunctionDecorators::CLASSMETHOD) {
+                2 // cls
+                  // } else if func_type.has_known_decorator(self.db(), FunctionDecorators::STATICMETHOD) {
+                  //     3 // static
+            } else {
+                1 // self
+            };
+
+        let is_first_param = func_def
+            .parameters
+            .index(parameter.name())
+            .is_some_and(|index| index == 0);
+
+        if !is_first_param {
+            return Type::unknown();
+        }
+
+        match method_type {
+            1 => Type::KnownInstance(KnownInstanceType::TypingSelf)
+                .in_type_expression(self.db(), self.scope())
+                .unwrap_or_else(|_| Type::unknown()),
+            2 => Type::unknown(), // TODO: type[Self]
+            _ => Type::unknown(), // TODO: This is a static method
+        }
+    }
+
     /// Set initial declared/inferred types for a `*args` variadic positional parameter.
     ///
     /// The annotated type is implicitly wrapped in a homogeneous tuple.

crates/ty_python_semantic/src/types/signatures.rs

@@ -1044,29 +1044,31 @@ impl<'db> Parameters<'db> {
         } else {
             false
         };
-        let classmethod = if matches!(definition.kind(db), DefinitionKind::Function(_)) {
-            let result = infer_definition_types(db, definition);
-            match result.declaration_type(definition).inner_type() {
-                Type::FunctionLiteral(t) => {
-                    t.decorators(db).contains(FunctionDecorators::CLASSMETHOD)
+        let classmethod = if let DefinitionKind::Function(f) = definition.kind(db) {
+            if f.name.id() == "__new__" {
+                true
+            } else {
+                let result = infer_definition_types(db, definition);
+                match result.declaration_type(definition).inner_type() {
+                    Type::FunctionLiteral(t) => {
+                        t.decorators(db).contains(FunctionDecorators::CLASSMETHOD)
+                    }
+                    _ => false,
                 }
-                _ => false,
             }
         } else {
             false
         };
         let positional_or_keyword = args.iter().enumerate().map(|(index, arg)| {
-            if index == 0 && function_is_method && arg.parameter.annotation().is_none() {
-                let implicit_annotation = if classmethod {
-                    Type::KnownInstance(KnownInstanceType::TypingSelf)
-                        .to_meta_type(db)
-                        .in_type_expression(db, definition.scope(db))
-                        .unwrap()
-                } else {
-                    Type::KnownInstance(KnownInstanceType::TypingSelf)
-                        .in_type_expression(db, definition.scope(db))
-                        .unwrap()
-                };
+            if index == 0
+                && function_is_method
+                && arg.parameter.annotation().is_none()
+                // TODO: Handle type of cls
+                && !classmethod
+            {
+                let implicit_annotation = Type::KnownInstance(KnownInstanceType::TypingSelf)
+                    .in_type_expression(db, definition.scope(db))
+                    .unwrap();
                 Parameter {
                     annotated_type: Some(implicit_annotation),
                     kind: ParameterKind::PositionalOrKeyword {