Fix: Detect type errors for bare return statements (#1508) (#1524)

Summary:
## Changes

1. Added `range` field to `ReturnExplicit` struct to track the return statement location
2. Updated `binding/function.rs` to pass the range when creating `ReturnExplicit`
3. Added type checking in `solve.rs` for bare return

## Testing
  - ✅ Added 3 new test cases in returns.rs

<img width="1738" height="2120" alt="CleanShot 2025-11-07 at 10 29 00@2x" src="https://github.com/user-attachments/assets/baae6d23-befc-42b3-8e87-22727d61a441" />

Fixes #1508

Pull Request resolved: #1524

Reviewed By: grievejia

Differential Revision: D86550828

Pulled By: yangdanny97

fbshipit-source-id: 38267c7ac0f67a2053eb76bb06dd76e82499ea6a

Author: AryanBagade

pyrefly/lib/alt/solve.rs

@@ -2908,8 +2908,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 let annot = x.annot.map(|k| self.get_idx(k));
                 let hint = annot.as_ref().and_then(|ann| ann.ty(self.stdlib));
 
-                if let Some(expr) = &x.expr {
-                    if x.is_async && x.is_generator {
+                if x.is_async && x.is_generator {
+                    if let Some(box expr) = &x.expr {
                         self.expr_infer(expr, errors);
                         self.error(
                             errors,
@@ -2918,24 +2918,44 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                             "Return statement with value is not allowed in async generator"
                                 .to_owned(),
                         )
-                    } else if x.is_generator {
-                        let hint =
-                            hint.and_then(|ty| self.decompose_generator(&ty).map(|(_, _, r)| r));
-                        let tcc: &dyn Fn() -> TypeCheckContext =
-                            &|| TypeCheckContext::of_kind(TypeCheckKind::ExplicitFunctionReturn);
-                        self.expr(expr, hint.as_ref().map(|t| (t, tcc)), errors)
-                    } else if matches!(hint, Some(Type::TypeGuard(_) | Type::TypeIs(_))) {
-                        let hint = Some(Type::ClassType(self.stdlib.bool().clone()));
-                        let tcc: &dyn Fn() -> TypeCheckContext =
-                            &|| TypeCheckContext::of_kind(TypeCheckKind::TypeGuardReturn);
+                    } else {
+                        Type::None
+                    }
+                } else if x.is_generator {
+                    let hint = hint.and_then(|ty| self.decompose_generator(&ty).map(|(_, _, r)| r));
+                    let tcc: &dyn Fn() -> TypeCheckContext =
+                        &|| TypeCheckContext::of_kind(TypeCheckKind::ExplicitFunctionReturn);
+                    if let Some(box expr) = &x.expr {
                         self.expr(expr, hint.as_ref().map(|t| (t, tcc)), errors)
+                    } else if let Some(hint) = hint {
+                        self.check_type(&Type::None, &hint, x.range, errors, tcc);
+                        Type::None
                     } else {
-                        let tcc: &dyn Fn() -> TypeCheckContext =
-                            &|| TypeCheckContext::of_kind(TypeCheckKind::ExplicitFunctionReturn);
+                        Type::None
+                    }
+                } else if matches!(hint, Some(Type::TypeGuard(_) | Type::TypeIs(_))) {
+                    let hint = Some(Type::ClassType(self.stdlib.bool().clone()));
+                    let tcc: &dyn Fn() -> TypeCheckContext =
+                        &|| TypeCheckContext::of_kind(TypeCheckKind::TypeGuardReturn);
+                    if let Some(box expr) = &x.expr {
                         self.expr(expr, hint.as_ref().map(|t| (t, tcc)), errors)
+                    } else if let Some(hint) = hint {
+                        self.check_type(&Type::None, &hint, x.range, errors, tcc);
+                        Type::None
+                    } else {
+                        Type::None
                     }
                 } else {
-                    Type::None
+                    let tcc: &dyn Fn() -> TypeCheckContext =
+                        &|| TypeCheckContext::of_kind(TypeCheckKind::ExplicitFunctionReturn);
+                    if let Some(box expr) = &x.expr {
+                        self.expr(expr, hint.as_ref().map(|t| (t, tcc)), errors)
+                    } else if let Some(hint) = hint {
+                        self.check_type(&Type::None, &hint, x.range, errors, tcc);
+                        Type::None
+                    } else {
+                        Type::None
+                    }
                 }
             }
             Binding::ReturnImplicit(x) => {

pyrefly/lib/binding/binding.rs

@@ -1046,6 +1046,7 @@ pub struct ReturnExplicit {
     pub expr: Option<Box<Expr>>,
     pub is_generator: bool,
     pub is_async: bool,
+    pub range: TextRange,
 }
 
 #[derive(Clone, Debug)]

pyrefly/lib/binding/function.rs

@@ -369,6 +369,7 @@ impl<'a> BindingsBuilder<'a> {
                         expr: x.value,
                         is_generator,
                         is_async,
+                        range: x.range,
                     }),
                 )
             })

pyrefly/lib/test/returns.rs

@@ -286,3 +286,30 @@ def f(x: str): pass
 return f(1) # E: Invalid `return` outside of a function # E: `Literal[1]` is not assignable to parameter `x` with type `str`
 "#,
 );
+
+testcase!(
+    test_bare_return_with_non_none_type,
+    r#"
+def test() -> int:
+    return  # E: Returned type `None` is not assignable to declared return type `int`
+"#,
+);
+
+testcase!(
+    test_bare_return_with_none_type,
+    r#"
+def test() -> None:
+    return  # Should work - None is assignable to None
+"#,
+);
+
+testcase!(
+    test_bare_return_in_generator,
+    r#"
+from typing import Generator
+
+def gen() -> Generator[int, None, str]:
+    yield 1
+    return  # E: Returned type `None` is not assignable to declared return type `str`
+"#,
+);