[syntax-errors] return outside function

Summary
--

This PR reimplements
[return-outside-function (F706)](https://docs.astral.sh/ruff/rules/return-outside-function/)
as a semantic syntax error.

These changes are very similar to those in #17298, which this is currently
stacked on.

Test Plan
--

Simple new inline tests, as well as updates to existing tests in the second
commit.

Author: ntBre

crates/ruff_linter/src/checkers/ast/analyze/statement.rs

@@ -380,9 +380,6 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             }
         }
         Stmt::Return(_) => {
-            if checker.enabled(Rule::ReturnOutsideFunction) {
-                pyflakes::rules::return_outside_function(checker, stmt);
-            }
             if checker.enabled(Rule::ReturnInInit) {
                 pylint::rules::return_in_init(checker, stmt);
             }

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -67,7 +67,9 @@ use crate::importer::Importer;
 use crate::noqa::NoqaMapping;
 use crate::package::PackageRoot;
 use crate::registry::Rule;
-use crate::rules::pyflakes::rules::{DeferralKeyword, LateFutureImport, YieldOutsideFunction};
+use crate::rules::pyflakes::rules::{
+    DeferralKeyword, LateFutureImport, ReturnOutsideFunction, YieldOutsideFunction,
+};
 use crate::rules::pylint::rules::LoadBeforeGlobalDeclaration;
 use crate::rules::{flake8_pyi, flake8_type_checking, pyflakes, pyupgrade};
 use crate::settings::{flags, LinterSettings};
@@ -586,6 +588,11 @@ impl SemanticSyntaxContext for Checker<'_> {
                     ));
                 }
             }
+            SemanticSyntaxErrorKind::ReturnOutsideFunction => {
+                if self.settings.rules.enabled(Rule::ReturnOutsideFunction) {
+                    self.report_diagnostic(Diagnostic::new(ReturnOutsideFunction, error.range));
+                }
+            }
             SemanticSyntaxErrorKind::ReboundComprehensionVariable
             | SemanticSyntaxErrorKind::DuplicateTypeParameter
             | SemanticSyntaxErrorKind::MultipleCaseAssignment(_)

crates/ruff_linter/src/rules/pyflakes/rules/return_outside_function.rs

@@ -1,11 +1,5 @@
-use ruff_python_ast::Stmt;
-
-use ruff_diagnostics::{Diagnostic, Violation};
+use ruff_diagnostics::Violation;
 use ruff_macros::{derive_message_formats, ViolationMetadata};
-use ruff_python_semantic::ScopeKind;
-use ruff_text_size::Ranged;
-
-use crate::checkers::ast::Checker;
 
 /// ## What it does
 /// Checks for `return` statements outside of functions.
@@ -31,12 +25,3 @@ impl Violation for ReturnOutsideFunction {
         "`return` statement outside of a function/method".to_string()
     }
 }
-
-pub(crate) fn return_outside_function(checker: &Checker, stmt: &Stmt) {
-    if matches!(
-        checker.semantic().current_scope().kind,
-        ScopeKind::Class(_) | ScopeKind::Module
-    ) {
-        checker.report_diagnostic(Diagnostic::new(ReturnOutsideFunction, stmt.range()));
-    }
-}

crates/ruff_python_parser/resources/inline/err/return_outside_function.py

@@ -0,0 +1 @@
+return 1

crates/ruff_python_parser/resources/inline/ok/return_inside_function.py

@@ -0,0 +1 @@
+def f(): return 1

crates/ruff_python_parser/src/semantic_errors.rs

@@ -119,11 +119,20 @@ impl SemanticSyntaxChecker {
                 }
             }
             Stmt::Return(ast::StmtReturn {
-                value: Some(value), ..
+                value: Some(value),
+                range,
             }) => {
                 // test_err single_star_return
                 // def f(): return *x
                 Self::invalid_star_expression(value, ctx);
+                if !self.in_function_scope {
+                    // test_ok return_inside_function
+                    // def f(): return 1
+
+                    // test_err return_outside_function
+                    // return 1
+                    Self::add_error(ctx, SemanticSyntaxErrorKind::ReturnOutsideFunction, *range);
+                }
             }
             Stmt::For(ast::StmtFor { target, iter, .. }) => {
                 // test_err single_star_for
@@ -877,6 +886,9 @@ impl Display for SemanticSyntaxError {
             SemanticSyntaxErrorKind::YieldOutsideFunction(kind) => {
                 write!(f, "`{kind}` statement outside of a function")
             }
+            SemanticSyntaxErrorKind::ReturnOutsideFunction => {
+                f.write_str("`return` statement outside of a function")
+            }
         }
     }
 }
@@ -1098,6 +1110,9 @@ pub enum SemanticSyntaxErrorKind {
 
     /// Represents the use of `yield`, `yield from`, or `await` outside of a function scope.
     YieldOutsideFunction(YieldOutsideFunctionKind),
+
+    /// Represents the use of `return` outside of a function scope.
+    ReturnOutsideFunction,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

crates/ruff_python_parser/tests/snapshots/invalid_syntax@return_outside_function.py.snap

@@ -0,0 +1,36 @@
+---
+source: crates/ruff_python_parser/tests/fixtures.rs
+input_file: crates/ruff_python_parser/resources/inline/err/return_outside_function.py
+---
+## AST
+
+```
+Module(
+    ModModule {
+        range: 0..9,
+        body: [
+            Return(
+                StmtReturn {
+                    range: 0..8,
+                    value: Some(
+                        NumberLiteral(
+                            ExprNumberLiteral {
+                                range: 7..8,
+                                value: Int(
+                                    1,
+                                ),
+                            },
+                        ),
+                    ),
+                },
+            ),
+        ],
+    },
+)
+```
+## Semantic Syntax Errors
+
+  |
+1 | return 1
+  | ^^^^^^^^ Syntax Error: `return` statement outside of a function
+  |

crates/ruff_python_parser/tests/snapshots/valid_syntax@return_inside_function.py.snap

@@ -0,0 +1,53 @@
+---
+source: crates/ruff_python_parser/tests/fixtures.rs
+input_file: crates/ruff_python_parser/resources/inline/ok/return_inside_function.py
+---
+## AST
+
+```
+Module(
+    ModModule {
+        range: 0..18,
+        body: [
+            FunctionDef(
+                StmtFunctionDef {
+                    range: 0..17,
+                    is_async: false,
+                    decorator_list: [],
+                    name: Identifier {
+                        id: Name("f"),
+                        range: 4..5,
+                    },
+                    type_params: None,
+                    parameters: Parameters {
+                        range: 5..7,
+                        posonlyargs: [],
+                        args: [],
+                        vararg: None,
+                        kwonlyargs: [],
+                        kwarg: None,
+                    },
+                    returns: None,
+                    body: [
+                        Return(
+                            StmtReturn {
+                                range: 9..17,
+                                value: Some(
+                                    NumberLiteral(
+                                        ExprNumberLiteral {
+                                            range: 16..17,
+                                            value: Int(
+                                                1,
+                                            ),
+                                        },
+                                    ),
+                                ),
+                            },
+                        ),
+                    ],
+                },
+            ),
+        ],
+    },
+)
+```