fix(linter/consistent-function-scoping): allow functions in TS modules/namespaces (#11681)

DonIsaac · camc314 · web-flow · commit 6c2b41cb8ed1 · 2025-06-14T00:25:26.000+01:00
## What This PR Does
Fixes a false positive in `unicorn/consistent-function-scoping` on
non-exported functions in TypeScript `module` and `namespace` nodes.

TypeScript modules and namespaces are valid ways to encapsulate code.
```ts
export namespace Foo {
  // public-facing API
  export function doThing() {
     let x = privateUtility();
     return x + 2;
  }

  // private function only available to functions within this namespace.
  // this used to be reported.
  function privateUtility() {
     return 1;
  }
}
```

---------

Co-authored-by: Cameron Clark &lt;cameron.clark@hey.com&gt;
diff --git a/crates/oxc_linter/src/rules/unicorn/consistent_function_scoping.rs b/crates/oxc_linter/src/rules/unicorn/consistent_function_scoping.rs
@@ -161,7 +161,10 @@ impl Rule for ConsistentFunctionScoping {
                         // The bar function scope id is 1. In order to ignore this rule,
                         // its parent's scope id (in this case `foo`'s scope id is 0 and is equal to root scope id)
                         // should be considered.
-                        if parent_scope_id == ctx.scoping().root_scope_id() {
+                        //
+                        // We also allow functions declared in TS module/namespace blocks.
+                        let flags = ctx.scoping().scope_flags(parent_scope_id);
+                        if flags.intersects(ScopeFlags::Top | ScopeFlags::TsModuleBlock) {
                             return;
                         }
                     }
@@ -195,9 +198,10 @@ impl Rule for ConsistentFunctionScoping {
                 _ => return,
             };
 
-        // if the function is declared at the root scope, we don't need to check anything
-        if ctx.scoping().symbol_scope_id(function_declaration_symbol_id)
-            == ctx.scoping().root_scope_id()
+        // if the function is declared at the root scope or in a TS
+        // module/namespace block, we don't need to check anything
+        let scope = ctx.scoping().symbol_scope_id(function_declaration_symbol_id);
+        if ctx.scoping().scope_flags(scope).intersects(ScopeFlags::Top | ScopeFlags::TsModuleBlock)
         {
             return;
         }
@@ -584,6 +588,51 @@ fn test() {
             None,
         ),
         ("if(f) function f(){}", None),
+        (
+            "
+            export namespace Foo {
+                export function somePublicFn() {
+                    return somePrivateFn();
+                }
+                function somePrivateFn() {
+                    return 'private';
+                }
+            }
+        ",
+            None,
+        ),
+        (
+            "
+            export namespace Foo {
+                export function somePublicFn() {
+                    return private1() + private2();
+                }
+                const private1 = function private1() {
+                    return 'private1';
+                }
+                const private2 = () => {
+                    return 'private2';
+                }
+            }
+        ",
+            None,
+        ),
+        (
+            "
+            declare namespace Foo {
+                function foo(): void;
+            }
+            ",
+            None,
+        ),
+        (
+            "
+            declare module 'some-package' {
+                function foo(): void;
+            }
+            ",
+            None,
+        ),
     ];
 
     let fail = vec![
@@ -824,6 +873,10 @@ fn test() {
         ("function foo() { const bar = async () => {} }", None),
         ("function doFoo() { const doBar = function(bar) { return bar; }; }", None),
         ("function outer() { const inner = function inner() {}; }", None),
+        (
+            "export namespace Foo { export function outer() { const inner = function inner() {}; } }",
+            None,
+        ),
     ];
 
     Tester::new(ConsistentFunctionScoping::NAME, ConsistentFunctionScoping::PLUGIN, pass, fail)
diff --git a/crates/oxc_linter/src/snapshots/unicorn_consistent_function_scoping.snap b/crates/oxc_linter/src/snapshots/unicorn_consistent_function_scoping.snap
@@ -410,3 +410,10 @@ source: crates/oxc_linter/src/tester.rs
    ·                                           ─────
    ╰────
   help: Move this function to the outer scope.
+
+  ⚠ eslint-plugin-unicorn(consistent-function-scoping): Function does not capture any variables from the outer scope.
+   ╭─[consistent_function_scoping.tsx:1:73]
+ 1 │ export namespace Foo { export function outer() { const inner = function inner() {}; } }
+   ·                                                                         ─────
+   ╰────
+  help: Move this function to the outer scope.
