From b76cb416dac0de8712c0236aa2832a824df5b1d5 Mon Sep 17 00:00:00 2001
From: kaykdm <34934746+kaykdm@users.noreply.github.com>
Date: Sat, 21 Sep 2024 05:37:29 +0900
Subject: [PATCH] feat(linter): implement useExplicitFunctionReturnType (#3990)

---
 .../migrate/eslint_any_rule_to_biome.rs       |  10 +
 .../top_level_all_down_level_not_all.snap     |  21 +-
 ..._level_all_true_group_level_all_false.snap |  21 +-
 .../src/analyzer/linter/rules.rs              |  42 ++-
 .../src/categories.rs                         |   1 +
 crates/biome_js_analyze/src/lint/nursery.rs   |   2 +
 .../use_explicit_function_return_type.rs      | 178 ++++++++++++
 crates/biome_js_analyze/src/options.rs        |   1 +
 .../useExplicitFunctionReturnType/invalid.ts  |  40 +++
 .../invalid.ts.snap                           | 256 ++++++++++++++++++
 .../useExplicitFunctionReturnType/valid.ts    |  34 +++
 .../valid.ts.snap                             |  42 +++
 .../@biomejs/backend-jsonrpc/src/workspace.ts |   5 +
 .../@biomejs/biome/configuration_schema.json  |   7 +
 14 files changed, 647 insertions(+), 13 deletions(-)
 create mode 100644 crates/biome_js_analyze/src/lint/nursery/use_explicit_function_return_type.rs
 create mode 100644 crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/invalid.ts
 create mode 100644 crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/invalid.ts.snap
 create mode 100644 crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/valid.ts
 create mode 100644 crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/valid.ts.snap

diff --git a/crates/biome_cli/src/execute/migrate/eslint_any_rule_to_biome.rs b/crates/biome_cli/src/execute/migrate/eslint_any_rule_to_biome.rs
index c6b73733a964..9a39b95c073b 100644
--- a/crates/biome_cli/src/execute/migrate/eslint_any_rule_to_biome.rs
+++ b/crates/biome_cli/src/execute/migrate/eslint_any_rule_to_biome.rs
@@ -73,6 +73,16 @@ pub(crate) fn migrate_eslint_any_rule(
             let rule = group.use_literal_keys.get_or_insert(Default::default());
             rule.set_level(rule_severity.into());
         }
+        "@typescript-eslint/explicit-function-return-type" => {
+            if !options.include_nursery {
+                return false;
+            }
+            let group = rules.nursery.get_or_insert_with(Default::default);
+            let rule = group
+                .use_explicit_function_return_type
+                .get_or_insert(Default::default());
+            rule.set_level(rule_severity.into());
+        }
         "@typescript-eslint/explicit-member-accessibility" => {
             if !options.include_nursery {
                 return false;
diff --git a/crates/biome_cli/tests/snapshots/main_commands_check/top_level_all_down_level_not_all.snap b/crates/biome_cli/tests/snapshots/main_commands_check/top_level_all_down_level_not_all.snap
index 8319f49f84cf..eb7ace276198 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_check/top_level_all_down_level_not_all.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_check/top_level_all_down_level_not_all.snap
@@ -40,6 +40,25 @@ check ━━━━━━━━━━━━━━━━━━━━━━━━
 
 # Emitted Messages
 
+```block
+fix.js:1:1 lint/nursery/useExplicitFunctionReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Missing return type on function.
+  
+  > 1 │ 
+      │ 
+  > 2 │     function f() {arguments;}
+      │     ^^^^^^^^^^
+    3 │     const FOO = "FOO";
+    4 │     var x, y;
+  
+  i Declaring the return type makes the code self-documenting and can speed up TypeScript type checking.
+  
+  i Add a return type annotation.
+  
+
+```
+
 ```block
 fix.js:2:14 lint/correctness/noUnusedVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
@@ -151,5 +170,5 @@ fix.js format ━━━━━━━━━━━━━━━━━━━━━━
 ```block
 Checked 1 file in <TIME>. No fixes applied.
 Found 1 error.
-Found 4 warnings.
+Found 5 warnings.
 ```
diff --git a/crates/biome_cli/tests/snapshots/main_commands_lint/top_level_all_true_group_level_all_false.snap b/crates/biome_cli/tests/snapshots/main_commands_lint/top_level_all_true_group_level_all_false.snap
index 10a21820cf14..2edc2966fa79 100644
--- a/crates/biome_cli/tests/snapshots/main_commands_lint/top_level_all_true_group_level_all_false.snap
+++ b/crates/biome_cli/tests/snapshots/main_commands_lint/top_level_all_true_group_level_all_false.snap
@@ -29,6 +29,25 @@ expression: content
 
 # Emitted Messages
 
+```block
+fix.js:1:1 lint/nursery/useExplicitFunctionReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Missing return type on function.
+  
+  > 1 │ 
+      │ 
+  > 2 │     function f() {arguments;}
+      │     ^^^^^^^^^^
+    3 │     const FOO = "FOO";
+    4 │     var x, y;
+  
+  i Declaring the return type makes the code self-documenting and can speed up TypeScript type checking.
+  
+  i Add a return type annotation.
+  
+
+```
+
 ```block
 fix.js:2:14 lint/correctness/noUnusedVariables ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
@@ -119,5 +138,5 @@ fix.js:4:12 lint/correctness/noUnusedVariables  FIXABLE  ━━━━━━━
 
 ```block
 Checked 1 file in <TIME>. No fixes applied.
-Found 4 warnings.
+Found 5 warnings.
 ```
diff --git a/crates/biome_configuration/src/analyzer/linter/rules.rs b/crates/biome_configuration/src/analyzer/linter/rules.rs
index 3fde273337fa..b1f533029a55 100644
--- a/crates/biome_configuration/src/analyzer/linter/rules.rs
+++ b/crates/biome_configuration/src/analyzer/linter/rules.rs
@@ -3368,6 +3368,10 @@ pub struct Nursery {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub use_deprecated_reason:
         Option<RuleConfiguration<biome_graphql_analyze::options::UseDeprecatedReason>>,
+    #[doc = "Require explicit return types on functions and class methods."]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub use_explicit_function_return_type:
+        Option<RuleConfiguration<biome_js_analyze::options::UseExplicitFunctionReturnType>>,
     #[doc = "Disallows package private imports."]
     #[serde(skip_serializing_if = "Option::is_none")]
     pub use_import_restrictions:
@@ -3431,6 +3435,7 @@ impl Nursery {
         "useConsistentCurlyBraces",
         "useConsistentMemberAccessibility",
         "useDeprecatedReason",
+        "useExplicitFunctionReturnType",
         "useImportRestrictions",
         "useSortedClasses",
         "useStrictMode",
@@ -3461,7 +3466,7 @@ impl Nursery {
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[21]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[24]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[25]),
-        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[28]),
+        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[29]),
     ];
     const ALL_RULES_AS_FILTERS: &'static [RuleFilter<'static>] = &[
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[0]),
@@ -3495,6 +3500,7 @@ impl Nursery {
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[28]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[29]),
         RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[30]),
+        RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[31]),
     ];
     #[doc = r" Retrieves the recommended rules"]
     pub(crate) fn is_recommended_true(&self) -> bool {
@@ -3641,31 +3647,36 @@ impl Nursery {
                 index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[25]));
             }
         }
-        if let Some(rule) = self.use_import_restrictions.as_ref() {
+        if let Some(rule) = self.use_explicit_function_return_type.as_ref() {
             if rule.is_enabled() {
                 index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[26]));
             }
         }
-        if let Some(rule) = self.use_sorted_classes.as_ref() {
+        if let Some(rule) = self.use_import_restrictions.as_ref() {
             if rule.is_enabled() {
                 index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[27]));
             }
         }
-        if let Some(rule) = self.use_strict_mode.as_ref() {
+        if let Some(rule) = self.use_sorted_classes.as_ref() {
             if rule.is_enabled() {
                 index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[28]));
             }
         }
-        if let Some(rule) = self.use_trim_start_end.as_ref() {
+        if let Some(rule) = self.use_strict_mode.as_ref() {
             if rule.is_enabled() {
                 index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[29]));
             }
         }
-        if let Some(rule) = self.use_valid_autocomplete.as_ref() {
+        if let Some(rule) = self.use_trim_start_end.as_ref() {
             if rule.is_enabled() {
                 index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[30]));
             }
         }
+        if let Some(rule) = self.use_valid_autocomplete.as_ref() {
+            if rule.is_enabled() {
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[31]));
+            }
+        }
         index_set
     }
     pub(crate) fn get_disabled_rules(&self) -> FxHashSet<RuleFilter<'static>> {
@@ -3800,31 +3811,36 @@ impl Nursery {
                 index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[25]));
             }
         }
-        if let Some(rule) = self.use_import_restrictions.as_ref() {
+        if let Some(rule) = self.use_explicit_function_return_type.as_ref() {
             if rule.is_disabled() {
                 index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[26]));
             }
         }
-        if let Some(rule) = self.use_sorted_classes.as_ref() {
+        if let Some(rule) = self.use_import_restrictions.as_ref() {
             if rule.is_disabled() {
                 index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[27]));
             }
         }
-        if let Some(rule) = self.use_strict_mode.as_ref() {
+        if let Some(rule) = self.use_sorted_classes.as_ref() {
             if rule.is_disabled() {
                 index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[28]));
             }
         }
-        if let Some(rule) = self.use_trim_start_end.as_ref() {
+        if let Some(rule) = self.use_strict_mode.as_ref() {
             if rule.is_disabled() {
                 index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[29]));
             }
         }
-        if let Some(rule) = self.use_valid_autocomplete.as_ref() {
+        if let Some(rule) = self.use_trim_start_end.as_ref() {
             if rule.is_disabled() {
                 index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[30]));
             }
         }
+        if let Some(rule) = self.use_valid_autocomplete.as_ref() {
+            if rule.is_disabled() {
+                index_set.insert(RuleFilter::Rule(Self::GROUP_NAME, Self::GROUP_RULES[31]));
+            }
+        }
         index_set
     }
     #[doc = r" Checks if, given a rule name, matches one of the rules contained in this category"]
@@ -3965,6 +3981,10 @@ impl Nursery {
                 .use_deprecated_reason
                 .as_ref()
                 .map(|conf| (conf.level(), conf.get_options())),
+            "useExplicitFunctionReturnType" => self
+                .use_explicit_function_return_type
+                .as_ref()
+                .map(|conf| (conf.level(), conf.get_options())),
             "useImportRestrictions" => self
                 .use_import_restrictions
                 .as_ref()
diff --git a/crates/biome_diagnostics_categories/src/categories.rs b/crates/biome_diagnostics_categories/src/categories.rs
index c883d856791f..718d5ac6a418 100644
--- a/crates/biome_diagnostics_categories/src/categories.rs
+++ b/crates/biome_diagnostics_categories/src/categories.rs
@@ -180,6 +180,7 @@ define_categories! {
     "lint/nursery/useConsistentCurlyBraces": "https://biomejs.dev/linter/rules/use-consistent-curly-braces",
     "lint/nursery/useConsistentMemberAccessibility": "https://biomejs.dev/linter/rules/use-consistent-member-accessibility",
     "lint/nursery/useDeprecatedReason": "https://biomejs.dev/linter/rules/use-deprecated-reason",
+    "lint/nursery/useExplicitFunctionReturnType": "https://biomejs.dev/linter/rules/use-explicit-function-return-type",
     "lint/nursery/useImportRestrictions": "https://biomejs.dev/linter/rules/use-import-restrictions",
     "lint/nursery/useJsxCurlyBraceConvention": "https://biomejs.dev/linter/rules/use-jsx-curly-brace-convention",
     "lint/nursery/useSortedClasses": "https://biomejs.dev/linter/rules/use-sorted-classes",
diff --git a/crates/biome_js_analyze/src/lint/nursery.rs b/crates/biome_js_analyze/src/lint/nursery.rs
index b26d91f6910f..e643f3d051ee 100644
--- a/crates/biome_js_analyze/src/lint/nursery.rs
+++ b/crates/biome_js_analyze/src/lint/nursery.rs
@@ -21,6 +21,7 @@ pub mod use_aria_props_supported_by_role;
 pub mod use_component_export_only_modules;
 pub mod use_consistent_curly_braces;
 pub mod use_consistent_member_accessibility;
+pub mod use_explicit_function_return_type;
 pub mod use_import_restrictions;
 pub mod use_sorted_classes;
 pub mod use_strict_mode;
@@ -50,6 +51,7 @@ declare_lint_group! {
             self :: use_component_export_only_modules :: UseComponentExportOnlyModules ,
             self :: use_consistent_curly_braces :: UseConsistentCurlyBraces ,
             self :: use_consistent_member_accessibility :: UseConsistentMemberAccessibility ,
+            self :: use_explicit_function_return_type :: UseExplicitFunctionReturnType ,
             self :: use_import_restrictions :: UseImportRestrictions ,
             self :: use_sorted_classes :: UseSortedClasses ,
             self :: use_strict_mode :: UseStrictMode ,
diff --git a/crates/biome_js_analyze/src/lint/nursery/use_explicit_function_return_type.rs b/crates/biome_js_analyze/src/lint/nursery/use_explicit_function_return_type.rs
new file mode 100644
index 000000000000..200f71fa2720
--- /dev/null
+++ b/crates/biome_js_analyze/src/lint/nursery/use_explicit_function_return_type.rs
@@ -0,0 +1,178 @@
+use biome_analyze::{
+    context::RuleContext, declare_lint_rule, Ast, Rule, RuleDiagnostic, RuleSource,
+};
+use biome_console::markup;
+use biome_js_semantic::HasClosureAstNode;
+use biome_js_syntax::AnyJsBinding;
+use biome_js_syntax::{
+    AnyJsFunction, JsGetterClassMember, JsGetterObjectMember, JsMethodClassMember,
+    JsMethodObjectMember,
+};
+use biome_rowan::{declare_node_union, AstNode, TextRange};
+
+declare_lint_rule! {
+    /// Require explicit return types on functions and class methods.
+    ///
+    /// Functions in TypeScript often don't need to be given an explicit return type annotation.
+    /// Leaving off the return type is less code to read or write and allows the compiler to infer it from the contents of the function.
+    ///
+    /// However, explicit return types do make it visually more clear what type is returned by a function.
+    /// They can also speed up TypeScript type checking performance in large codebases with many large functions.
+    /// Explicit return types also reduce the chance of bugs by asserting the return type, and it avoids surprising "action at a distance," where changing the body of one function may cause failures inside another function.
+    ///
+    /// This rule enforces that functions do have an explicit return type annotation.
+    ///
+    /// ## Examples
+    ///
+    /// ### Invalid
+    ///
+    /// ```ts,expect_diagnostic
+    /// // Should indicate that no value is returned (void)
+    /// function test() {
+    ///   return;
+    /// }
+    /// ```
+    ///
+    /// ```ts,expect_diagnostic
+    /// // Should indicate that a number is returned
+    /// var fn = function () {
+    ///    return 1;
+    /// };
+    /// ```
+    ///
+    /// ```ts,expect_diagnostic
+    /// // Should indicate that a string is returned
+    /// var arrowFn = () => 'test';
+    /// ```
+    ///
+    /// ```ts,expect_diagnostic
+    /// class Test {
+    ///   // Should indicate that no value is returned (void)
+    ///   method() {
+    ///     return;
+    ///   }
+    /// }
+    /// ```
+    ///
+    /// ```ts,expect_diagnostic
+    /// // Should indicate that no value is returned (void)
+    /// function test(a: number) {
+    ///   a += 1;
+    /// }
+    /// ```
+    ///
+    /// ### Valid
+    /// ```ts
+    /// // No return value should be expected (void)
+    /// function test(): void {
+    ///   return;
+    /// }
+    /// ```
+    ///
+    /// ```ts
+    /// // A return value of type number
+    /// var fn = function (): number {
+    ///   return 1;
+    /// }
+    /// ```
+    ///
+    /// ```ts
+    /// // A return value of type string
+    /// var arrowFn = (): string => 'test';
+    /// ```
+    ///
+    /// ```ts
+    /// class Test {
+    ///   // No return value should be expected (void)
+    ///   method(): void {
+    ///     return;
+    ///   }
+    /// }
+    /// ```
+    ///
+    pub UseExplicitFunctionReturnType {
+        version: "next",
+        name: "useExplicitFunctionReturnType",
+        language: "ts",
+        recommended: false,
+        sources: &[RuleSource::EslintTypeScript("explicit-function-return-type")],
+    }
+}
+
+declare_node_union! {
+    pub AnyJsFunctionWithReturnType = AnyJsFunction | JsMethodClassMember | JsMethodObjectMember | JsGetterClassMember | JsGetterObjectMember
+}
+
+impl Rule for UseExplicitFunctionReturnType {
+    type Query = Ast<AnyJsFunctionWithReturnType>;
+    type State = TextRange;
+    type Signals = Option<Self::State>;
+    type Options = ();
+
+    fn run(ctx: &RuleContext<Self>) -> Self::Signals {
+        let node = ctx.query();
+        match node {
+            AnyJsFunctionWithReturnType::AnyJsFunction(func) => {
+                if func.return_type_annotation().is_some() {
+                    return None;
+                }
+
+                let func_range = func.syntax().text_range();
+                if let Ok(Some(AnyJsBinding::JsIdentifierBinding(id))) = func.id() {
+                    return Some(TextRange::new(
+                        func_range.start(),
+                        id.syntax().text_range().end(),
+                    ));
+                }
+
+                Some(func_range)
+            }
+            AnyJsFunctionWithReturnType::JsMethodClassMember(method) => {
+                if method.return_type_annotation().is_some() {
+                    return None;
+                }
+
+                Some(method.node_text_range())
+            }
+            AnyJsFunctionWithReturnType::JsGetterClassMember(getter) => {
+                if getter.return_type().is_some() {
+                    return None;
+                }
+
+                Some(getter.node_text_range())
+            }
+            AnyJsFunctionWithReturnType::JsMethodObjectMember(method) => {
+                if method.return_type_annotation().is_some() {
+                    return None;
+                }
+
+                Some(method.node_text_range())
+            }
+            AnyJsFunctionWithReturnType::JsGetterObjectMember(getter) => {
+                if getter.return_type().is_some() {
+                    return None;
+                }
+
+                Some(getter.node_text_range())
+            }
+        }
+    }
+
+    fn diagnostic(_: &RuleContext<Self>, state: &Self::State) -> Option<RuleDiagnostic> {
+        Some(
+            RuleDiagnostic::new(
+                rule_category!(),
+                state,
+                markup! {
+                    "Missing return type on function."
+                },
+            )
+            .note(markup! {
+                "Declaring the return type makes the code self-documenting and can speed up TypeScript type checking."
+            })
+            .note(markup! {
+                "Add a return type annotation."
+            }),
+        )
+    }
+}
diff --git a/crates/biome_js_analyze/src/options.rs b/crates/biome_js_analyze/src/options.rs
index 9503db94f433..c1d4ab6d04fb 100644
--- a/crates/biome_js_analyze/src/options.rs
+++ b/crates/biome_js_analyze/src/options.rs
@@ -303,6 +303,7 @@ pub type UseEnumInitializers =
 pub type UseErrorMessage =
     <lint::suspicious::use_error_message::UseErrorMessage as biome_analyze::Rule>::Options;
 pub type UseExhaustiveDependencies = < lint :: correctness :: use_exhaustive_dependencies :: UseExhaustiveDependencies as biome_analyze :: Rule > :: Options ;
+pub type UseExplicitFunctionReturnType = < lint :: nursery :: use_explicit_function_return_type :: UseExplicitFunctionReturnType as biome_analyze :: Rule > :: Options ;
 pub type UseExplicitLengthCheck = < lint :: style :: use_explicit_length_check :: UseExplicitLengthCheck as biome_analyze :: Rule > :: Options ;
 pub type UseExponentiationOperator = < lint :: style :: use_exponentiation_operator :: UseExponentiationOperator as biome_analyze :: Rule > :: Options ;
 pub type UseExportType =
diff --git a/crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/invalid.ts b/crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/invalid.ts
new file mode 100644
index 000000000000..15fd9103d5ae
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/invalid.ts
@@ -0,0 +1,40 @@
+function test(a: number, b: number) {
+	return;
+}
+
+function test() {
+	return;
+}
+
+var fn = function () {
+	return 1;
+};
+
+var arrowFn = () => "test";
+
+class Test {
+	constructor() {}
+	get prop() {
+		return 1;
+	}
+	set prop() {}
+	method() {
+		return;
+	}
+	arrow = () => "arrow";
+	private method() {
+		return;
+	}
+}
+
+const obj = {
+	method() {
+		return "test"
+	}
+}
+
+const obj = {
+  get method() {
+    return "test"
+  },
+};
diff --git a/crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/invalid.ts.snap b/crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/invalid.ts.snap
new file mode 100644
index 000000000000..bfb06d5c1c0f
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/invalid.ts.snap
@@ -0,0 +1,256 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: invalid.ts
+---
+# Input
+```ts
+function test(a: number, b: number) {
+	return;
+}
+
+function test() {
+	return;
+}
+
+var fn = function () {
+	return 1;
+};
+
+var arrowFn = () => "test";
+
+class Test {
+	constructor() {}
+	get prop() {
+		return 1;
+	}
+	set prop() {}
+	method() {
+		return;
+	}
+	arrow = () => "arrow";
+	private method() {
+		return;
+	}
+}
+
+const obj = {
+	method() {
+		return "test"
+	}
+}
+
+const obj = {
+  get method() {
+    return "test"
+  },
+};
+
+```
+
+# Diagnostics
+```
+invalid.ts:1:1 lint/nursery/useExplicitFunctionReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Missing return type on function.
+  
+  > 1 │ function test(a: number, b: number) {
+      │ ^^^^^^^^^^^^^
+    2 │ 	return;
+    3 │ }
+  
+  i Declaring the return type makes the code self-documenting and can speed up TypeScript type checking.
+  
+  i Add a return type annotation.
+  
+
+```
+
+```
+invalid.ts:3:2 lint/nursery/useExplicitFunctionReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Missing return type on function.
+  
+    1 │ function test(a: number, b: number) {
+    2 │ 	return;
+  > 3 │ }
+      │  
+  > 4 │ 
+  > 5 │ function test() {
+      │ ^^^^^^^^^^^^^
+    6 │ 	return;
+    7 │ }
+  
+  i Declaring the return type makes the code self-documenting and can speed up TypeScript type checking.
+  
+  i Add a return type annotation.
+  
+
+```
+
+```
+invalid.ts:9:10 lint/nursery/useExplicitFunctionReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Missing return type on function.
+  
+     7 │ }
+     8 │ 
+   > 9 │ var fn = function () {
+       │          ^^^^^^^^^^^^^
+  > 10 │ 	return 1;
+  > 11 │ };
+       │ ^
+    12 │ 
+    13 │ var arrowFn = () => "test";
+  
+  i Declaring the return type makes the code self-documenting and can speed up TypeScript type checking.
+  
+  i Add a return type annotation.
+  
+
+```
+
+```
+invalid.ts:13:15 lint/nursery/useExplicitFunctionReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Missing return type on function.
+  
+    11 │ };
+    12 │ 
+  > 13 │ var arrowFn = () => "test";
+       │               ^^^^^^^^^^^^
+    14 │ 
+    15 │ class Test {
+  
+  i Declaring the return type makes the code self-documenting and can speed up TypeScript type checking.
+  
+  i Add a return type annotation.
+  
+
+```
+
+```
+invalid.ts:17:2 lint/nursery/useExplicitFunctionReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Missing return type on function.
+  
+    15 │ class Test {
+    16 │ 	constructor() {}
+  > 17 │ 	get prop() {
+       │ 	^^^^^^^^^^^^
+  > 18 │ 		return 1;
+  > 19 │ 	}
+       │ 	^
+    20 │ 	set prop() {}
+    21 │ 	method() {
+  
+  i Declaring the return type makes the code self-documenting and can speed up TypeScript type checking.
+  
+  i Add a return type annotation.
+  
+
+```
+
+```
+invalid.ts:21:2 lint/nursery/useExplicitFunctionReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Missing return type on function.
+  
+    19 │ 	}
+    20 │ 	set prop() {}
+  > 21 │ 	method() {
+       │ 	^^^^^^^^^^
+  > 22 │ 		return;
+  > 23 │ 	}
+       │ 	^
+    24 │ 	arrow = () => "arrow";
+    25 │ 	private method() {
+  
+  i Declaring the return type makes the code self-documenting and can speed up TypeScript type checking.
+  
+  i Add a return type annotation.
+  
+
+```
+
+```
+invalid.ts:24:10 lint/nursery/useExplicitFunctionReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Missing return type on function.
+  
+    22 │ 		return;
+    23 │ 	}
+  > 24 │ 	arrow = () => "arrow";
+       │ 	        ^^^^^^^^^^^^^
+    25 │ 	private method() {
+    26 │ 		return;
+  
+  i Declaring the return type makes the code self-documenting and can speed up TypeScript type checking.
+  
+  i Add a return type annotation.
+  
+
+```
+
+```
+invalid.ts:25:2 lint/nursery/useExplicitFunctionReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Missing return type on function.
+  
+    23 │ 	}
+    24 │ 	arrow = () => "arrow";
+  > 25 │ 	private method() {
+       │ 	^^^^^^^^^^^^^^^^^^
+  > 26 │ 		return;
+  > 27 │ 	}
+       │ 	^
+    28 │ }
+    29 │ 
+  
+  i Declaring the return type makes the code self-documenting and can speed up TypeScript type checking.
+  
+  i Add a return type annotation.
+  
+
+```
+
+```
+invalid.ts:31:2 lint/nursery/useExplicitFunctionReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Missing return type on function.
+  
+    30 │ const obj = {
+  > 31 │ 	method() {
+       │ 	^^^^^^^^^^
+  > 32 │ 		return "test"
+  > 33 │ 	}
+       │ 	^
+    34 │ }
+    35 │ 
+  
+  i Declaring the return type makes the code self-documenting and can speed up TypeScript type checking.
+  
+  i Add a return type annotation.
+  
+
+```
+
+```
+invalid.ts:37:3 lint/nursery/useExplicitFunctionReturnType ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! Missing return type on function.
+  
+    36 │ const obj = {
+  > 37 │   get method() {
+       │   ^^^^^^^^^^^^^^
+  > 38 │     return "test"
+  > 39 │   },
+       │   ^
+    40 │ };
+    41 │ 
+  
+  i Declaring the return type makes the code self-documenting and can speed up TypeScript type checking.
+  
+  i Add a return type annotation.
+  
+
+```
diff --git a/crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/valid.ts b/crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/valid.ts
new file mode 100644
index 000000000000..49dc78973cae
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/valid.ts
@@ -0,0 +1,34 @@
+/* should not generate diagnostics */
+function test(): void {
+  return;
+}
+
+var fn = function (): number {
+  return 1;
+};
+
+var arrowFn = (): string => 'test';
+
+class Test {
+  constructor() {}
+  get prop(): number {
+    return 1;
+  }
+  set prop() {}
+  method(): void {
+    return;
+  }
+  arrow = (): string => 'arrow';
+}
+
+const obj = {
+	method(): string {
+		return "test"
+	}
+}
+
+const obj = {
+  get method(): string {
+    return "test"
+  },
+};
diff --git a/crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/valid.ts.snap b/crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/valid.ts.snap
new file mode 100644
index 000000000000..26ec2032b613
--- /dev/null
+++ b/crates/biome_js_analyze/tests/specs/nursery/useExplicitFunctionReturnType/valid.ts.snap
@@ -0,0 +1,42 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+expression: valid.ts
+---
+# Input
+```ts
+/* should not generate diagnostics */
+function test(): void {
+  return;
+}
+
+var fn = function (): number {
+  return 1;
+};
+
+var arrowFn = (): string => 'test';
+
+class Test {
+  constructor() {}
+  get prop(): number {
+    return 1;
+  }
+  set prop() {}
+  method(): void {
+    return;
+  }
+  arrow = (): string => 'arrow';
+}
+
+const obj = {
+	method(): string {
+		return "test"
+	}
+}
+
+const obj = {
+  get method(): string {
+    return "test"
+  },
+};
+
+```
diff --git a/packages/@biomejs/backend-jsonrpc/src/workspace.ts b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
index 7e015cf3f492..88cad0f8c634 100644
--- a/packages/@biomejs/backend-jsonrpc/src/workspace.ts
+++ b/packages/@biomejs/backend-jsonrpc/src/workspace.ts
@@ -1326,6 +1326,10 @@ export interface Nursery {
 	 * Require specifying the reason argument when using @deprecated directive
 	 */
 	useDeprecatedReason?: RuleConfiguration_for_Null;
+	/**
+	 * Require explicit return types on functions and class methods.
+	 */
+	useExplicitFunctionReturnType?: RuleConfiguration_for_Null;
 	/**
 	 * Disallows package private imports.
 	 */
@@ -2860,6 +2864,7 @@ export type Category =
 	| "lint/nursery/useConsistentCurlyBraces"
 	| "lint/nursery/useConsistentMemberAccessibility"
 	| "lint/nursery/useDeprecatedReason"
+	| "lint/nursery/useExplicitFunctionReturnType"
 	| "lint/nursery/useImportRestrictions"
 	| "lint/nursery/useJsxCurlyBraceConvention"
 	| "lint/nursery/useSortedClasses"
diff --git a/packages/@biomejs/biome/configuration_schema.json b/packages/@biomejs/biome/configuration_schema.json
index 7e9555908ae2..7c01d4457c7d 100644
--- a/packages/@biomejs/biome/configuration_schema.json
+++ b/packages/@biomejs/biome/configuration_schema.json
@@ -2266,6 +2266,13 @@
 						{ "type": "null" }
 					]
 				},
+				"useExplicitFunctionReturnType": {
+					"description": "Require explicit return types on functions and class methods.",
+					"anyOf": [
+						{ "$ref": "#/definitions/RuleConfiguration" },
+						{ "type": "null" }
+					]
+				},
 				"useImportRestrictions": {
 					"description": "Disallows package private imports.",
 					"anyOf": [