fix(indent): correct handling of return type annotations (#853)

Author: controversial

packages/eslint-plugin/rules/indent/indent._ts_.test.ts

@@ -845,6 +845,64 @@ const map2 = Object.keys(map)
       `,
       options: [2, { VariableDeclarator: { using: 'first' } }],
     },
+    {
+      code: $`
+        async function foo(bar: number): Promise<
+          number
+        > {
+          return 2;
+        }
+      `,
+      options: [2],
+    },
+    {
+      code: $`
+        async function foo(
+          bar: number,
+        ): Promise<
+          number
+        > {
+          return 2;
+        }
+      `,
+      options: [2],
+    },
+    {
+      code: $`
+        function foo(bar: number): (
+          number
+        ) {
+          return 2;
+        }
+      `,
+      options: [2],
+    },
+    {
+      code: $`
+        function foo(
+          bar: number,
+        ): (
+          number
+        ) {
+          return 2;
+        }
+      `,
+      options: [2],
+    },
+    {
+      code: $`
+        const a = (
+          param: 2 | 3,
+        ): Promise<
+          (
+            2 | 3
+          )
+        > => {
+          return Promise.resolve(param)
+        }
+      `,
+      options: [2],
+    },
   ],
   invalid: [
     ...individualNodeTests.invalid!,

packages/eslint-plugin/rules/indent/indent.ts

@@ -1372,7 +1372,10 @@ export default createRule<RuleOptions, MessageIds>({
 
         if (isOpeningParenToken(maybeOpeningParen)) {
           const openingParen = maybeOpeningParen
-          const closingParen = sourceCode.getTokenBefore(node.body, isClosingParenToken)!
+          const closingParen = sourceCode.getTokenBefore(
+            node.returnType ?? node.body,
+            { filter: isClosingParenToken },
+          )!
 
           parameterParens.add(openingParen)
           parameterParens.add(closingParen)
@@ -1497,20 +1500,25 @@ export default createRule<RuleOptions, MessageIds>({
       },
 
       'FunctionDeclaration, FunctionExpression': function (node: Tree.FunctionDeclaration | Tree.FunctionExpression) {
-        const closingParen = sourceCode.getTokenBefore(node.body)!
-        const openingParen = sourceCode.getTokenBefore(
+        const paramsClosingParen = sourceCode.getTokenBefore(
+          node.returnType ?? node.body,
+          { filter: isClosingParenToken },
+        )
+        if (!paramsClosingParen)
+          throw new Error('Expected to find a closing parenthesis for function parameters.')
+
+        const paramsOpeningParen = sourceCode.getTokenBefore(
           node.params.length
-            ? node.params[0].decorators?.length
-              ? node.params[0].decorators[0]
-              : node.params[0] : closingParen,
-          {
-            filter: isOpeningParenToken,
-          },
-        )!
+            ? (node.params[0].decorators?.[0] ?? node.params[0])
+            : paramsClosingParen,
+          { filter: isOpeningParenToken },
+        )
+        if (!paramsOpeningParen)
+          throw new Error('Expected to find an opening parenthesis for function parameters.')
 
-        parameterParens.add(openingParen)
-        parameterParens.add(closingParen)
-        addElementListIndent(node.params, openingParen, closingParen, options[node.type].parameters)
+        parameterParens.add(paramsOpeningParen)
+        parameterParens.add(paramsClosingParen)
+        addElementListIndent(node.params, paramsOpeningParen, paramsClosingParen, options[node.type].parameters)
       },
 
       IfStatement(node) {