Fix: Skip bad-return validation for Protocol methods (#1916)

Signed-off-by: Aryan Bagade <aryan@aryanbagade.com>

Author: AryanBagade

pyrefly/lib/alt/solve.rs

@@ -3102,6 +3102,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         annotation,
                         stub_or_impl,
                         decorators,
+                        class_key,
                         implicit_return,
                         is_generator,
                         has_explicit_return,
@@ -3110,9 +3111,18 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         // It will result in an implicit Any type, which is reasonable, but we should
                         // at least error here.
                         let ty = self.get_idx(*annotation).annotation.get_type().clone();
-                        // If the function body is stubbed out or if the function is decorated with
-                        // `@abstractmethod`, we blindly accept the return type annotation.
+                        // Check if this method is in a protocol class
+                        let is_in_protocol = class_key.is_some_and(|key| {
+                            self.get_idx(key)
+                                .0
+                                .as_ref()
+                                .is_some_and(|cls| self.get_metadata_for_class(cls).is_protocol())
+                        });
+                        // If the function body is stubbed out, if the function is decorated with
+                        // `@abstractmethod`, or if the function is a method in a protocol class,
+                        // we blindly accept the return type annotation.
                         if *stub_or_impl != FunctionStubOrImpl::Stub
+                            && !is_in_protocol
                             && !decorators.iter().any(|k| {
                                 let decorator = self.get_idx(*k);
                                 match decorator.ty.callee_kind() {

pyrefly/lib/binding/binding.rs

@@ -1150,6 +1150,8 @@ pub enum ReturnTypeKind {
         /// We keep this just so we can scan for `@abstractmethod` and use the info to decide
         /// whether to skip the validation.
         decorators: Box<[Idx<KeyDecorator>]>,
+        /// The class this function belongs to, if any. Used to skip validation for protocol methods.
+        class_key: Option<Idx<KeyClass>>,
         implicit_return: Idx<Key>,
         is_generator: bool,
         has_explicit_return: bool,

pyrefly/lib/binding/function.rs

@@ -371,6 +371,7 @@ impl<'a> BindingsBuilder<'a> {
         should_infer_return_type: bool,
         stub_or_impl: FunctionStubOrImpl,
         decorators: Box<[Idx<KeyDecorator>]>,
+        class_key: Option<Idx<KeyClass>>,
     ) {
         let is_generator =
             !(yields_and_returns.yields.is_empty() && yields_and_returns.yield_froms.is_empty());
@@ -431,6 +432,7 @@ impl<'a> BindingsBuilder<'a> {
                         annotation,
                         stub_or_impl,
                         decorators,
+                        class_key,
                         implicit_return,
                         is_generator: !(yield_keys.is_empty() && yield_from_keys.is_empty()),
                         has_explicit_return: !return_keys.is_empty(),
@@ -613,6 +615,7 @@ impl<'a> BindingsBuilder<'a> {
                         false, // this disables return type inference
                         stub_or_impl,
                         decorators.decorators.clone(),
+                        class_key,
                     );
                     self_assignments
                 }
@@ -643,6 +646,7 @@ impl<'a> BindingsBuilder<'a> {
                         false, // this disables return type inference
                         stub_or_impl,
                         decorators.decorators.clone(),
+                        class_key,
                     );
                     self_assignments
                 }
@@ -673,6 +677,7 @@ impl<'a> BindingsBuilder<'a> {
                         true,
                         stub_or_impl,
                         decorators.decorators.clone(),
+                        class_key,
                     );
                     self_assignments
                 }

pyrefly/lib/test/protocol.rs

@@ -847,3 +847,33 @@ def test():
     p: TrickyProtocol[int] = t  # E:
 "#,
 );
+
+// Regression test for https://github.com/facebook/pyrefly/issues/1916
+// Protocol methods with only a docstring should not emit "missing explicit return" errors
+testcase!(
+    test_protocol_method_with_docstring,
+    r#"
+from typing import Protocol
+
+class SortState:
+    pass
+
+class View(Protocol):
+    """A protocol with methods that have docstrings but no body."""
+
+    @property
+    def sort_state(self) -> SortState:
+        """Return the current sorting/grouping settings."""
+
+    def get_value(self) -> int:
+        """Get a value."""
+
+    def method_with_ellipsis(self) -> str:
+        """This one uses ellipsis."""
+        ...
+
+    def method_with_pass(self) -> str:
+        """This one uses pass - should still be allowed in protocol."""
+        pass
+"#,
+);