Don't emit diagnostic for assigning to self

Author: Glyphack

crates/ty_python_semantic/resources/mdtest/attributes.md

@@ -695,7 +695,7 @@ class C:
     pure_class_variable2: ClassVar = 1
 
     def method(self):
-        # TODO: this should be an error
+        # error: [invalid-attribute-access] "Cannot assign to ClassVar `pure_class_variable1` from an instance of type `Self`"
         self.pure_class_variable1 = "value set through instance"
 
 reveal_type(C.pure_class_variable1)  # revealed: str
@@ -1634,6 +1634,7 @@ def external_getattribute(name) -> int:
 
 class ThisFails:
     def __init__(self):
+        # error: [invalid-assignment] "Implicit shadowing of function `__getattribute__`"
         self.__getattribute__ = external_getattribute
 
 # error: [unresolved-attribute]

crates/ty_python_semantic/src/types.rs

@@ -5975,6 +5975,17 @@ impl<'db> TypeVarInstance<'db> {
             self.kind(db),
         )
     }
+
+    pub(crate) fn is_self(self, db: &'db dyn Db) -> bool {
+        self.bound_or_constraints(db)
+            .is_some_and(|bound_or_constraints| {
+                matches!(
+                    bound_or_constraints,
+                    TypeVarBoundOrConstraints::UpperBound(Type::NominalInstance(_))
+                )
+            })
+            && self.name(db) == "Self"
+    }
 }
 
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, salsa::Update)]
@@ -8162,6 +8173,7 @@ impl<'db> BoundSuperType<'db> {
                 let Some(owner_class) = owner.into_class() else {
                     return Some(owner);
                 };
+
                 if owner_class.is_subclass_of(db, pivot_class) {
                     Some(owner)
                 } else {

crates/ty_python_semantic/src/types/function.rs

@@ -602,6 +602,11 @@ impl<'db> FunctionType<'db> {
         self.literal(db).has_known_decorator(db, decorator)
     }
 
+    /// Returns if this function is a class method.
+    pub(crate) fn is_class_method(self, db: &dyn Db) -> bool {
+        self.has_known_decorator(db, FunctionDecorators::CLASSMETHOD) || self.name(db) == "__new__"
+    }
+
     /// Returns the [`Definition`] of the implementation or first overload of this function.
     ///
     /// ## Warning

crates/ty_python_semantic/src/types/infer.rs

@@ -2308,6 +2308,10 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
         let module = &parsed_module(self.db(), self.scope().file(self.db())).load(self.db());
         let method = current_scope.node().as_function(module)?;
 
+        let parent_scope_id = current_scope.parent()?;
+        let parent_scope = self.index.scope(parent_scope_id);
+        parent_scope.node().as_class(module)?;
+
         let definition = self.index.expect_single_definition(method);
         let DefinitionKind::Function(func_def) = definition.kind(self.db()) else {
             return None;
@@ -2326,18 +2330,17 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
             return None;
         }
 
-        if func_type.has_known_decorator(self.db(), FunctionDecorators::CLASSMETHOD) {
-            // TODO: cls
+        if func_type.is_class_method(self.db()) {
+            // TODO: set the type for `cls` argument
             return None;
         } else if func_type.has_known_decorator(self.db(), FunctionDecorators::STATICMETHOD) {
             return None;
-        } else {
-            return Some(
-                Type::SpecialForm(SpecialFormType::TypingSelf)
-                    .in_type_expression(self.db(), self.scope())
-                    .unwrap(),
-            );
-        };
+        }
+        Some(
+            Type::SpecialForm(SpecialFormType::TypingSelf)
+                .in_type_expression(self.db(), self.scope())
+                .unwrap(),
+        )
     }
 
     /// Set initial declared/inferred types for a `*args` variadic positional parameter.
@@ -3246,6 +3249,14 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                     dataclass_params.is_some_and(|params| params.contains(DataclassParams::FROZEN))
                 };
 
+                // TODO: A hacky way to allow assigning instance attributes to self.
+                // Without this flag we would emit diagnostics for `self.x = 1` if `x` is unbound.
+                // The correct solution is to review how we emit diagnostics in store context.
+                let allow_instance_attribute_assignments_to_self = || match object_ty {
+                    Type::TypeVar(tv) => tv.is_self(db),
+                    _ => false,
+                };
+
                 match object_ty.class_member(db, attribute.into()) {
                     meta_attr @ PlaceAndQualifiers { .. } if meta_attr.is_class_var() => {
                         if emit_diagnostics {
@@ -3351,12 +3362,14 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                             object_ty.instance_member(db, attribute).place
                         {
                             if instance_attr_boundness == Boundness::PossiblyUnbound {
-                                report_possibly_unbound_attribute(
-                                    &self.context,
-                                    target,
-                                    attribute,
-                                    object_ty,
-                                );
+                                if !allow_instance_attribute_assignments_to_self() {
+                                    report_possibly_unbound_attribute(
+                                        &self.context,
+                                        target,
+                                        attribute,
+                                        object_ty,
+                                    );
+                                }
                             }
 
                             if is_read_only() {
@@ -3411,11 +3424,13 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                                         if let Some(builder) =
                                             self.context.report_lint(&UNRESOLVED_ATTRIBUTE, target)
                                         {
-                                            builder.into_diagnostic(format_args!(
-                                                "Unresolved attribute `{}` on type `{}`.",
-                                                attribute,
-                                                object_ty.display(db)
-                                            ));
+                                            if !allow_instance_attribute_assignments_to_self() {
+                                                builder.into_diagnostic(format_args!(
+                                                    "Unresolved attribute `{}` on type `{}`.",
+                                                    attribute,
+                                                    object_ty.display(db)
+                                                ));
+                                            }
                                         }
                                     }