fix(eslint-plugin): [no-shadow] ignore ordering of type declarations (#10593)

* initial implementation

* add relevant tests

* add docs

* snapshots

* match original implementation

Author: ronami

packages/eslint-plugin/docs/rules/no-shadow.mdx

@@ -17,18 +17,52 @@ It adds support for TypeScript's `this` parameters and global augmentation, and
 This rule adds the following options:
 
 ```ts
+type AdditionalHoistOptionEntries = 'types' | 'functions-and-types';
+
+type HoistOptionEntries =
+  | BaseNoShadowHoistOptionEntries
+  | AdditionalHoistOptionEntries;
+
 interface Options extends BaseNoShadowOptions {
+  hoist?: HoistOptionEntries;
   ignoreTypeValueShadow?: boolean;
   ignoreFunctionTypeParameterNameValueShadow?: boolean;
 }
 
 const defaultOptions: Options = {
   ...baseNoShadowDefaultOptions,
+  hoist: 'functions-and-types',
   ignoreTypeValueShadow: true,
   ignoreFunctionTypeParameterNameValueShadow: true,
 };
 ```
 
+### hoist: `types`
+
+Examples of incorrect code for the `{ "hoist": "types" }` option:
+
+```ts option='{ "hoist": "types" }' showPlaygroundButton
+type Bar<Foo> = 1;
+type Foo = 1;
+```
+
+### hoist: `functions-and-types`
+
+Examples of incorrect code for the `{ "hoist": "functions-and-types" }` option:
+
+```ts option='{ "hoist": "functions-and-types" }' showPlaygroundButton
+// types
+type Bar<Foo> = 1;
+type Foo = 1;
+
+// functions
+if (true) {
+  let b = 6;
+}
+
+function b() {}
+```
+
 ### `ignoreTypeValueShadow`
 
 {/* insert option description */}

packages/eslint-plugin/src/rules/no-shadow.ts

@@ -11,7 +11,7 @@ export type Options = [
   {
     allow?: string[];
     builtinGlobals?: boolean;
-    hoist?: 'all' | 'functions' | 'never';
+    hoist?: 'all' | 'functions' | 'functions-and-types' | 'never' | 'types';
     ignoreFunctionTypeParameterNameValueShadow?: boolean;
     ignoreOnInitialization?: boolean;
     ignoreTypeValueShadow?: boolean;
@@ -28,6 +28,13 @@ const allowedFunctionVariableDefTypes = new Set([
   AST_NODE_TYPES.TSConstructorType,
 ]);
 
+const functionsHoistedNodes = new Set([AST_NODE_TYPES.FunctionDeclaration]);
+
+const typesHoistedNodes = new Set([
+  AST_NODE_TYPES.TSInterfaceDeclaration,
+  AST_NODE_TYPES.TSTypeAliasDeclaration,
+]);
+
 export default createRule<Options, MessageIds>({
   name: 'no-shadow',
   meta: {
@@ -63,7 +70,7 @@ export default createRule<Options, MessageIds>({
             type: 'string',
             description:
               'Whether to report shadowing before outer functions or variables are defined.',
-            enum: ['all', 'functions', 'never'],
+            enum: ['all', 'functions', 'functions-and-types', 'never', 'types'],
           },
           ignoreFunctionTypeParameterNameValueShadow: {
             type: 'boolean',
@@ -88,7 +95,7 @@ export default createRule<Options, MessageIds>({
     {
       allow: [],
       builtinGlobals: false,
-      hoist: 'functions',
+      hoist: 'functions-and-types',
       ignoreFunctionTypeParameterNameValueShadow: true,
       ignoreOnInitialization: false,
       ignoreTypeValueShadow: true,
@@ -513,15 +520,30 @@ export default createRule<Options, MessageIds>({
       const inner = getNameRange(variable);
       const outer = getNameRange(scopeVar);
 
-      return !!(
-        inner &&
-        outer &&
-        inner[1] < outer[0] &&
-        // Excepts FunctionDeclaration if is {"hoist":"function"}.
-        (options.hoist !== 'functions' ||
-          !outerDef ||
-          outerDef.node.type !== AST_NODE_TYPES.FunctionDeclaration)
-      );
+      if (!inner || !outer || inner[1] >= outer[0]) {
+        return false;
+      }
+
+      if (!outerDef) {
+        return true;
+      }
+
+      if (options.hoist === 'functions') {
+        return !functionsHoistedNodes.has(outerDef.node.type);
+      }
+
+      if (options.hoist === 'types') {
+        return !typesHoistedNodes.has(outerDef.node.type);
+      }
+
+      if (options.hoist === 'functions-and-types') {
+        return (
+          !functionsHoistedNodes.has(outerDef.node.type) &&
+          !typesHoistedNodes.has(outerDef.node.type)
+        );
+      }
+
+      return true;
     }
 
     /**