fix Error when calling abstract method on super() #1358 (#1363)

Summary:
fix #1358

Pull Request resolved: #1363

Reviewed By: stroxler

Differential Revision: D85364483

Pulled By: yangdanny97

fbshipit-source-id: 53e9478a88eddf1aaf9ad0b39487b382ed195a65

Author: asukaminato0721

conformance/third_party/conformance.exp

@@ -8768,6 +8768,17 @@
     }
   ],
   "protocols_explicit.py": [
+    {
+      "code": -2,
+      "column": 16,
+      "concise_description": "Method `draw` inherited from class `PColor` has no implementation and cannot be accessed via `super()`",
+      "description": "Method `draw` inherited from class `PColor` has no implementation and cannot be accessed via `super()`",
+      "line": 27,
+      "name": "missing-attribute",
+      "severity": "error",
+      "stop_column": 28,
+      "stop_line": 27
+    },
     {
       "code": -2,
       "column": 20,

conformance/third_party/conformance.result

@@ -252,7 +252,6 @@
     "Line 79: Unexpected errors ['`Concrete` is not assignable to `Template`\\n  Protocol `Template` requires attribute `temp`']"
   ],
   "protocols_explicit.py": [
-    "Line 27: Expected 1 errors",
     "Line 89: Expected 1 errors"
   ],
   "protocols_generic.py": [],

conformance/third_party/results.json

@@ -3,7 +3,7 @@
   "pass": 99,
   "fail": 39,
   "pass_rate": 0.72,
-  "differences": 158,
+  "differences": 157,
   "passing": [
     "aliases_explicit.py",
     "aliases_newtype.py",
@@ -136,7 +136,7 @@
     "literals_interactions.py": 2,
     "protocols_class_objects.py": 7,
     "protocols_definition.py": 3,
-    "protocols_explicit.py": 2,
+    "protocols_explicit.py": 1,
     "protocols_modules.py": 1,
     "protocols_runtime_checkable.py": 3,
     "protocols_variance.py": 7,

crates/pyrefly_types/src/callable.rs

@@ -344,6 +344,10 @@ pub struct FuncFlags {
     pub has_final_decoration: bool,
     /// A function decorated with `@abc.abstractmethod`
     pub is_abstract_method: bool,
+    /// Function body is treated as a stub (e.g. body is `...` or absent in a stub file)
+    pub lacks_implementation: bool,
+    /// Is the function definition in a `.pyi` file
+    pub defined_in_stub_file: bool,
     /// A function decorated with `typing.dataclass_transform(...)`, turning it into a
     /// `dataclasses.dataclass`-like decorator. Stores the keyword values passed to the
     /// `dataclass_transform` call. See

crates/pyrefly_types/src/types.rs

@@ -1106,6 +1106,13 @@ impl Type {
         self.check_toplevel_func_metadata(&|meta| meta.flags.dataclass_transform_metadata.clone())
     }
 
+    /// If a Protocol method lacks an implementation and does not come from a `.pyi` file, then it cannot be called
+    pub fn is_non_callable_protocol_method(&self) -> bool {
+        self.check_toplevel_func_metadata(&|meta| {
+            meta.flags.lacks_implementation && !meta.flags.defined_in_stub_file
+        })
+    }
+
     /// Transforms this type's function metadata, if it is a function. Note that we do *not*
     /// recurse into the type to find nested function types.
     pub fn transform_toplevel_func_metadata(&mut self, mut f: impl FnMut(&mut FuncMetadata)) {

pyrefly/lib/alt/attr.rs

@@ -239,6 +239,8 @@ pub enum NoAccessReason {
     /// We do not allow class-level mutation of descriptors (this is conservative,
     /// it is unspecified whether monkey-patching descriptors should be permitted).
     SettingDescriptorOnClass(Class),
+    /// Calling a method via `super()` when no implementation is available (e.g. abstract protocol or abstract base method).
+    SuperMethodNeedsImplementation(Class),
 }
 
 #[derive(Debug)]
@@ -294,6 +296,12 @@ impl NoAccessReason {
                     "Attribute `{attr_name}` of class `{class_name}` is a read-only descriptor with no `__set__` and cannot be set"
                 )
             }
+            NoAccessReason::SuperMethodNeedsImplementation(class) => {
+                let class_name = class.name();
+                format!(
+                    "Method `{attr_name}` inherited from class `{class_name}` has no implementation and cannot be accessed via `super()`"
+                )
+            }
         }
     }
 }

pyrefly/lib/alt/class/class_field.rs

@@ -564,6 +564,12 @@ impl ClassField {
         }
     }
 
+    fn is_non_callable_protocol_method(&self) -> bool {
+        match &self.0 {
+            ClassFieldInner::Simple { ty, .. } => ty.is_non_callable_protocol_method(),
+        }
+    }
+
     pub fn is_foreign_key(&self) -> bool {
         match &self.0 {
             ClassFieldInner::Simple { is_foreign_key, .. } => *is_foreign_key,
@@ -2557,16 +2563,43 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             SuperObj::Instance(obj) => self
                 .get_super_class_member(obj.class_object(), Some(start_lookup_cls), name)
                 .map(|member| {
-                    self.as_instance_attribute(&member.value, &Instance::of_self_type(obj))
+                    if let Some(reason) = self.super_method_needs_impl_reason(&member) {
+                        ClassAttribute::no_access(reason)
+                    } else {
+                        self.as_instance_attribute(&member.value, &Instance::of_self_type(obj))
+                    }
                 }),
             SuperObj::Class(obj) => self
                 .get_super_class_member(obj.class_object(), Some(start_lookup_cls), name)
                 .map(|member| {
-                    self.as_class_attribute(&member.value, &ClassBase::SelfType(obj.clone()))
+                    if let Some(reason) = self.super_method_needs_impl_reason(&member) {
+                        ClassAttribute::no_access(reason)
+                    } else {
+                        self.as_class_attribute(&member.value, &ClassBase::SelfType(obj.clone()))
+                    }
                 }),
         }
     }
 
+    fn super_method_needs_impl_reason(
+        &self,
+        member: &WithDefiningClass<Arc<ClassField>>,
+    ) -> Option<NoAccessReason> {
+        if member.value.is_abstract() {
+            return Some(NoAccessReason::SuperMethodNeedsImplementation(
+                member.defining_class.dupe(),
+            ));
+        }
+        let metadata = self.get_metadata_for_class(&member.defining_class);
+        if metadata.is_protocol() && member.value.is_non_callable_protocol_method() {
+            Some(NoAccessReason::SuperMethodNeedsImplementation(
+                member.defining_class.dupe(),
+            ))
+        } else {
+            None
+        }
+    }
+
     /// Gets an attribute from a class definition.
     ///
     /// Returns `None` if there is no such attribute, otherwise an `Attribute` object

pyrefly/lib/alt/function.rs

@@ -218,6 +218,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         class_key: Option<&Idx<KeyClass>>,
         decorators: &[(Idx<Key>, TextRange)],
         legacy_tparams: &[Idx<KeyLegacyTypeParam>],
+        module_style: ModuleStyle,
         errors: &ErrorCollector,
     ) -> Arc<UndecoratedFunction> {
         let defining_cls = class_key.and_then(|k| self.get_idx(*k).0.dupe());
@@ -263,6 +264,13 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 .map(|(idx, range)| (self.get_idx(*idx).arc_clone_ty(), *range)),
         );
 
+        if stub_or_impl == FunctionStubOrImpl::Stub {
+            flags.lacks_implementation = true;
+        }
+        if module_style == ModuleStyle::Interface {
+            flags.defined_in_stub_file = true;
+        }
+
         // Look for a @classmethod or @staticmethod decorator and change the "self" type
         // accordingly. This is not totally correct, since it doesn't account for chaining
         // decorators, or weird cases like both decorators existing at the same time.

pyrefly/lib/alt/solve.rs

@@ -3414,6 +3414,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             x.class_key.as_ref(),
             &x.decorators,
             &x.legacy_tparams,
+            x.module_style,
             errors,
         )
     }

pyrefly/lib/binding/binding.rs

@@ -15,6 +15,7 @@ use pyrefly_derive::TypeEq;
 use pyrefly_derive::VisitMut;
 use pyrefly_python::dunder;
 use pyrefly_python::module_name::ModuleName;
+use pyrefly_python::module_path::ModuleStyle;
 use pyrefly_python::nesting_context::NestingContext;
 use pyrefly_python::short_identifier::ShortIdentifier;
 use pyrefly_python::symbol_kind::SymbolKind;
@@ -1009,6 +1010,7 @@ pub struct BindingUndecoratedFunction {
     pub class_key: Option<Idx<KeyClass>>,
     pub legacy_tparams: Box<[Idx<KeyLegacyTypeParam>]>,
     pub decorators: Box<[(Idx<Key>, TextRange)]>,
+    pub module_style: ModuleStyle,
 }
 
 impl DisplayWith<Bindings> for BindingUndecoratedFunction {