Add Self and type[Self] attribute base

Summary: When we look up a method on `self`, we need to create a bound method with the bound receiver of `self`. We determine the bound receiver based on the attribute base, so this diff introduces new attribute bases.

Reviewed By: stroxler

Differential Revision: D80893392

fbshipit-source-id: 01fec4ef3aef7ccb61accce566f31ca8e5e95616

Author: samwgoldman

conformance/third_party/conformance.exp

@@ -5527,16 +5527,6 @@
     }
   ],
   "generics_self_advanced.py": [
-    {
-      "code": -2,
-      "column": 20,
-      "concise_description": "assert_type(ChildB, Self) failed",
-      "description": "assert_type(ChildB, Self) failed",
-      "line": 38,
-      "name": "assert-type",
-      "stop_column": 42,
-      "stop_line": 38
-    },
     {
       "code": -2,
       "column": 20,
@@ -5576,16 +5566,6 @@
       "name": "missing-attribute",
       "stop_column": 26,
       "stop_line": 44
-    },
-    {
-      "code": -2,
-      "column": 20,
-      "concise_description": "assert_type(ChildB, Self) failed",
-      "description": "assert_type(ChildB, Self) failed",
-      "line": 45,
-      "name": "assert-type",
-      "stop_column": 41,
-      "stop_line": 45
     }
   ],
   "generics_self_attributes.py": [

conformance/third_party/conformance.result

@@ -204,10 +204,8 @@
     "Line 96: Expected 1 errors"
   ],
   "generics_self_advanced.py": [
-    "Line 38: Unexpected errors ['assert_type(ChildB, Self) failed']",
     "Line 43: Unexpected errors ['assert_type(Any, list[Self]) failed', 'Instance-only attribute `a` of class `ChildB` is not visible on the class']",
-    "Line 44: Unexpected errors ['assert_type(Any, Self) failed', 'Instance-only attribute `a` of class `ChildB` is not visible on the class']",
-    "Line 45: Unexpected errors ['assert_type(ChildB, Self) failed']"
+    "Line 44: Unexpected errors ['assert_type(Any, Self) failed', 'Instance-only attribute `a` of class `ChildB` is not visible on the class']"
   ],
   "generics_self_attributes.py": [
     "Line 32: Expected 1 errors"

conformance/third_party/results.json

@@ -3,7 +3,7 @@
   "pass": 81,
   "fail": 57,
   "pass_rate": 0.59,
-  "differences": 262,
+  "differences": 260,
   "passing": [
     "aliases_explicit.py",
     "aliases_newtype.py",
@@ -112,7 +112,7 @@
     "generics_defaults_referential.py": 3,
     "generics_paramspec_components.py": 1,
     "generics_scoping.py": 8,
-    "generics_self_advanced.py": 4,
+    "generics_self_advanced.py": 2,
     "generics_self_attributes.py": 1,
     "generics_self_basic.py": 2,
     "generics_self_protocols.py": 1,

pyrefly/lib/alt/attr.rs

@@ -509,6 +509,8 @@ enum AttributeBase {
     /// Properties are handled via a special case so that we can understand
     /// setter decorators.
     Property(Type),
+    /// Attribute access on `Self` from inside a class
+    SelfType(ClassType),
     /// Result of a super() call. See Type::SuperInstance for details on what these fields are.
     SuperInstance(ClassType, SuperObj),
     /// Typed dictionaries have similar properties to dict and Mapping, with some exceptions
@@ -524,6 +526,7 @@ pub enum ClassBase {
     ClassDef(Class),
     ClassType(ClassType),
     Quantified(Quantified, ClassType),
+    SelfType(ClassType),
 }
 
 impl ClassBase {
@@ -532,14 +535,16 @@ impl ClassBase {
             ClassBase::ClassDef(c) => c,
             ClassBase::ClassType(c) => c.class_object(),
             ClassBase::Quantified(_, c) => c.class_object(),
+            ClassBase::SelfType(c) => c.class_object(),
         }
     }
 
     pub fn targs(&self) -> Option<&TArgs> {
         match self {
             ClassBase::ClassDef(..) => None,
-            ClassBase::ClassType(c) => Some(c.targs()),
-            ClassBase::Quantified(_, c) => Some(c.targs()),
+            ClassBase::ClassType(c) | ClassBase::Quantified(_, c) | ClassBase::SelfType(c) => {
+                Some(c.targs())
+            }
         }
     }
 
@@ -548,6 +553,7 @@ impl ClassBase {
             ClassBase::ClassDef(c) => Type::ClassDef(c),
             ClassBase::ClassType(c) => Type::Type(Box::new(c.to_type())),
             ClassBase::Quantified(q, _) => Type::type_form(q.to_type()),
+            ClassBase::SelfType(c) => Type::type_form(Type::SelfType(c)),
         }
     }
 }
@@ -1550,6 +1556,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     )),
                 }
             }
+            AttributeBase::SelfType(cls) => match self.get_self_attribute(&cls, attr_name) {
+                Some(attr) => LookupResult::found(attr),
+                None => LookupResult::not_found(NotFoundOn::ClassInstance(
+                    cls.class_object().dupe(),
+                    base_copy,
+                )),
+            },
         }
     }
 
@@ -1579,6 +1592,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 }
             }
             AttributeBase::ClassInstance(cls)
+            | AttributeBase::SelfType(cls)
             | AttributeBase::EnumLiteral(LitEnum { class: cls, .. })
             | AttributeBase::Quantified(_, Some(cls))
             | AttributeBase::SuperInstance(cls, _)
@@ -1755,10 +1769,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         match ty {
             Type::ClassType(class_type) => Some(AttributeBase::ClassInstance(class_type)),
             Type::ClassDef(cls) => Some(AttributeBase::ClassObject(ClassBase::ClassDef(cls))),
-            Type::SelfType(class_type) => Some(AttributeBase::ClassInstance(class_type)),
-            Type::Type(box Type::SelfType(class_type)) => Some(AttributeBase::ClassObject(
-                ClassBase::ClassType(class_type.clone()),
-            )),
+            Type::SelfType(class_type) => Some(AttributeBase::SelfType(class_type)),
+            Type::Type(box Type::SelfType(class_type)) => {
+                Some(AttributeBase::ClassObject(ClassBase::SelfType(class_type)))
+            }
             Type::TypedDict(td) | Type::PartialTypedDict(td) => {
                 Some(AttributeBase::TypedDict(td.clone()))
             }
@@ -2210,6 +2224,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     ) {
         match &base {
             AttributeBase::ClassInstance(class)
+            | AttributeBase::SelfType(class)
             | AttributeBase::EnumLiteral(LitEnum { class, .. })
             | AttributeBase::Quantified(_, Some(class)) => {
                 self.completions_class_type(class, expected_attribute_name, res)

pyrefly/lib/alt/class/class_field.rs

@@ -527,6 +527,7 @@ enum InstanceKind {
     ClassType,
     TypedDict,
     TypeVar(Quantified),
+    SelfType,
 }
 
 /// Wrapper to hold a specialized instance of a class , unifying ClassType and TypedDict.
@@ -561,6 +562,14 @@ impl<'a> Instance<'a> {
         }
     }
 
+    fn of_self_type(cls: &'a ClassType) -> Self {
+        Self {
+            kind: InstanceKind::SelfType,
+            class: cls.class_object(),
+            targs: cls.targs(),
+        }
+    }
+
     /// Instantiate a type that is relative to the class type parameters
     /// by substituting in the type arguments.
     fn instantiate_member(&self, raw_member: Type) -> Type {
@@ -576,13 +585,21 @@ impl<'a> Instance<'a> {
                 Type::TypedDict(TypedDict::new(self.class.dupe(), self.targs.clone()))
             }
             InstanceKind::TypeVar(q) => q.clone().to_type(),
+            InstanceKind::SelfType => {
+                Type::SelfType(ClassType::new(self.class.dupe(), self.targs.clone()))
+            }
         }
     }
 
     /// Looking up a classmethod/staticmethod from an instance base has class-like
     /// lookup behavior. When this happens, we convert from an instance base to a class base.
     fn to_class_base(&self) -> ClassBase {
-        ClassBase::ClassType(ClassType::new(self.class.dupe(), self.targs.clone()))
+        match self.kind {
+            InstanceKind::SelfType => {
+                ClassBase::SelfType(ClassType::new(self.class.dupe(), self.targs.clone()))
+            }
+            _ => ClassBase::ClassType(ClassType::new(self.class.dupe(), self.targs.clone())),
+        }
     }
 }
 
@@ -1381,7 +1398,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             } if (descriptor_getter.is_some() || descriptor_setter.is_some())
                 // There's no situation in which you can stick a usable descriptor in a TypedDict.
                 // TODO(rechen): a descriptor in a TypedDict should be an error at class creation time.
-                && instance.kind == InstanceKind::ClassType =>
+                && (instance.kind == InstanceKind::ClassType
+                || instance.kind == InstanceKind::SelfType) =>
             {
                 Attribute::descriptor(
                     ty,
@@ -1535,6 +1553,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             ClassBase::ClassDef(c) => self.instantiate(c),
             ClassBase::ClassType(c) => c.clone().to_type(),
             ClassBase::Quantified(q, _) => q.clone().to_type(),
+            ClassBase::SelfType(c) => Type::SelfType(c.clone()),
         };
         foralled.subst_self_type_mut(&replacement, &|a, b| self.is_subset_eq(a, b));
         Some(bind_class_attribute(cls, foralled, &None))
@@ -1831,6 +1850,11 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             .map(|member| self.as_instance_attribute(&member.value, &Instance::of_class(cls)))
     }
 
+    pub fn get_self_attribute(&self, cls: &ClassType, name: &Name) -> Option<Attribute> {
+        self.get_class_member(cls.class_object(), name)
+            .map(|member| self.as_instance_attribute(&member.value, &Instance::of_self_type(cls)))
+    }
+
     pub fn get_bounded_quantified_attribute(
         &self,
         quantified: Quantified,