Avoid adding return types to stub methods (#9277)

We should avoid adding `-> None` to stubs in `.pyi` files, along with a
few other cases. (We already ignore abstract methods.)

Closes https://github.com/astral-sh/ruff/issues/9270.

crates/ruff_linter/resources/test/fixtures/flake8_annotations/auto_return_type.py

@@ -212,3 +212,20 @@ def func(x: int):
         raise ValueError
     else:
         return 1
+
+
+from typing import overload
+
+
+@overload
+def overloaded(i: int) -> "int":
+    ...
+
+
+@overload
+def overloaded(i: "str") -> "str":
+    ...
+
+
+def overloaded(i):
+    return i

crates/ruff_linter/src/rules/flake8_annotations/rules/definition.rs

@@ -482,7 +482,6 @@ impl Violation for AnyType {
         format!("Dynamically typed expressions (typing.Any) are disallowed in `{name}`")
     }
 }
-
 fn is_none_returning(body: &[Stmt]) -> bool {
     let mut visitor = ReturnStatementVisitor::default();
     visitor.visit_body(body);
@@ -537,8 +536,11 @@ fn check_dynamically_typed<F>(
     }
 }
 
-fn is_empty_body(body: &[Stmt]) -> bool {
+/// Return `true` if a function appears to be a stub.
-    body.iter().all(|stmt| match stmt {
+fn is_stub_function(function_def: &ast::StmtFunctionDef, checker: &Checker) -> bool {
+    /// Returns `true` if a function has an empty body.
+    fn is_empty_body(function_def: &ast::StmtFunctionDef) -> bool {
+        function_def.body.iter().all(|stmt| match stmt {
             Stmt::Pass(_) => true,
             Stmt::Expr(ast::StmtExpr { value, range: _ }) => {
                 matches!(
@@ -548,6 +550,27 @@ fn is_empty_body(body: &[Stmt]) -> bool {
             }
             _ => false,
         })
+    }
+
+    // Ignore functions with empty bodies in...
+    if is_empty_body(function_def) {
+        // Stub definitions (.pyi files)...
+        if checker.source_type.is_stub() {
+            return true;
+        }
+
+        // Abstract methods...
+        if visibility::is_abstract(&function_def.decorator_list, checker.semantic()) {
+            return true;
+        }
+
+        // Overload definitions...
+        if visibility::is_overload(&function_def.decorator_list, checker.semantic()) {
+            return true;
+        }
+    }
+
+    false
 }
 
 /// Generate flake8-annotation checks for a given `Definition`.
@@ -738,9 +761,7 @@ pub(crate) fn definition(
     ) {
         if is_method && visibility::is_classmethod(decorator_list, checker.semantic()) {
             if checker.enabled(Rule::MissingReturnTypeClassMethod) {
-                let return_type = if visibility::is_abstract(decorator_list, checker.semantic())
+                let return_type = if is_stub_function(function, checker) {
-                    && is_empty_body(body)
-                {
                     None
                 } else {
                     auto_return_type(function)
@@ -771,9 +792,7 @@ pub(crate) fn definition(
             }
         } else if is_method && visibility::is_staticmethod(decorator_list, checker.semantic()) {
             if checker.enabled(Rule::MissingReturnTypeStaticMethod) {
-                let return_type = if visibility::is_abstract(decorator_list, checker.semantic())
+                let return_type = if is_stub_function(function, checker) {
-                    && is_empty_body(body)
-                {
                     None
                 } else {
                     auto_return_type(function)
@@ -843,10 +862,7 @@ pub(crate) fn definition(
             match visibility {
                 visibility::Visibility::Public => {
                     if checker.enabled(Rule::MissingReturnTypeUndocumentedPublicFunction) {
-                        let return_type =
+                        let return_type = if is_stub_function(function, checker) {
-                            if visibility::is_abstract(decorator_list, checker.semantic())
-                                && is_empty_body(body)
-                            {
                             None
                         } else {
                             auto_return_type(function)
@@ -885,10 +901,7 @@ pub(crate) fn definition(
                 }
                 visibility::Visibility::Private => {
                     if checker.enabled(Rule::MissingReturnTypePrivateFunction) {
-                        let return_type =
+                        let return_type = if is_stub_function(function, checker) {
-                            if visibility::is_abstract(decorator_list, checker.semantic())
-                                && is_empty_body(body)
-                            {
                             None
                         } else {
                             auto_return_type(function)