Add implicit return (#57)

* refactor function args functions

* add implicit return lint

rules/no-implicit-any/function-args/index.ts

@@ -84,7 +84,7 @@ function lintArg(
   }
 }
 
-export const lintFunctionDeclaration = (
+export const lintArgsOfFunctionDeclaration = (
   context: Readonly<TSESLint.RuleContext<'missingAnyType', any[]>>,
   node: TSESTree.FunctionDeclaration
 ) => {
@@ -93,7 +93,7 @@ export const lintFunctionDeclaration = (
   });
 };
 
-export const lintTSFunctionType = (
+export const lintArgsOfTSFunctionType = (
   context: Readonly<TSESLint.RuleContext<'missingAnyType', any[]>>,
   node: TSESTree.TSFunctionType
 ) => {
@@ -102,7 +102,7 @@ export const lintTSFunctionType = (
   });
 };
 
-export const lintFunctionExpression = (
+export const lintArgsOfFunctionExpression = (
   context: Readonly<TSESLint.RuleContext<'missingAnyType', any[]>>,
   node: TSESTree.FunctionExpression
 ) => {
@@ -140,7 +140,7 @@ export const lintFunctionExpression = (
   });
 };
 
-export const lintArrowFunctionExpression = (
+export const lintArgsOfArrowFunctionExpression = (
   context: Readonly<TSESLint.RuleContext<'missingAnyType', any[]>>,
   node: TSESTree.ArrowFunctionExpression
 ) => {

rules/no-implicit-any/implicit-return/index.spec.ts

@@ -0,0 +1,45 @@
+import { ruleTester } from '../../testUtil';
+import { rule } from '../../no-implicit-any';
+
+ruleTester.run('implicit-return', rule, {
+  valid: [
+    { code: 'const foo = () => { return 1 }' },
+    { code: 'const foo = () => 1' },
+    { code: 'const foo = () => null as null' },
+    { code: 'const foo = () => (null as null)' },
+    { code: 'const foo = () => (null) as null' },
+    { code: 'const foo = (): null => null' },
+  ],
+  invalid: [
+    {
+      code: 'const foo = () => null',
+      output: 'const foo = () => null as null',
+      errors: [{ messageId: 'missingAnyType' }],
+    },
+    {
+      code: 'const foo = () => (null)',
+      output: 'const foo = () => (null as null)',
+      errors: [{ messageId: 'missingAnyType' }],
+    },
+    {
+      code: 'const foo = () => undefined',
+      output: 'const foo = () => undefined as undefined',
+      errors: [{ messageId: 'missingAnyType' }],
+    },
+    {
+      code: 'const foo = () => (undefined)',
+      output: 'const foo = () => (undefined as undefined)',
+      errors: [{ messageId: 'missingAnyType' }],
+    },
+    {
+      code: 'const foo = () => []',
+      output: 'const foo = () => [] as any[]',
+      errors: [{ messageId: 'missingAnyType' }],
+    },
+    {
+      code: 'const foo = () => ([])',
+      output: 'const foo = () => ([] as any[])',
+      errors: [{ messageId: 'missingAnyType' }],
+    },
+  ],
+});

rules/no-implicit-any/implicit-return/index.ts

@@ -0,0 +1,45 @@
+import { ESLintUtils, type TSESLint } from '@typescript-eslint/utils';
+import { type TSESTree, AST_NODE_TYPES } from '@typescript-eslint/types';
+import { isNull, isUndefined, enabledStrictNullChecks } from '../../helper';
+
+export const lintImplicitReturn = (
+  context: Readonly<TSESLint.RuleContext<'missingAnyType', any[]>>,
+  node: TSESTree.ArrowFunctionExpression
+) => {
+  const bodyNode = node.body;
+  const bodyType = bodyNode.type;
+  const parserServices = ESLintUtils.getParserServices(context);
+  if (
+    bodyType === AST_NODE_TYPES.BlockStatement ||
+    bodyType === AST_NODE_TYPES.TSAsExpression ||
+    node.returnType ||
+    enabledStrictNullChecks(parserServices.program.getCompilerOptions())
+  )
+    return;
+
+  if (isNull(bodyNode)) {
+    context.report({
+      node: bodyNode,
+      messageId: 'missingAnyType',
+      fix(fixer) {
+        return fixer.insertTextAfter(bodyNode, ' as null');
+      },
+    });
+  } else if (isUndefined(bodyNode)) {
+    context.report({
+      node: bodyNode,
+      messageId: 'missingAnyType',
+      fix(fixer) {
+        return fixer.insertTextAfter(bodyNode, ' as undefined');
+      },
+    });
+  } else if (bodyNode.type === AST_NODE_TYPES.ArrayExpression && bodyNode.elements.length === 0) {
+    context.report({
+      node: bodyNode,
+      messageId: 'missingAnyType',
+      fix(fixer) {
+        return fixer.insertTextAfter(bodyNode, ' as any[]');
+      },
+    });
+  }
+};

rules/no-implicit-any/index.ts

@@ -1,14 +1,15 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
 
 import {
-  lintFunctionDeclaration,
-  lintFunctionExpression,
-  lintArrowFunctionExpression,
-  lintTSFunctionType,
+  lintArgsOfFunctionDeclaration,
+  lintArgsOfFunctionExpression,
+  lintArgsOfArrowFunctionExpression,
+  lintArgsOfTSFunctionType,
 } from './function-args';
 import { lintMemberExpression } from './member-expression';
 import { lintVariableDeclarator } from './variable-declarator';
 import { lintReturnStatement } from './return-statement';
+import { lintImplicitReturn } from './implicit-return';
 import { lintObjectExpression } from './object-expression';
 
 function hasJSExtension(filePath: string) {
@@ -36,16 +37,17 @@ export const rule = createRule({
 
     return {
       FunctionDeclaration(node) {
-        lintFunctionDeclaration(context, node);
+        lintArgsOfFunctionDeclaration(context, node);
       },
       FunctionExpression(node) {
-        lintFunctionExpression(context, node);
+        lintArgsOfFunctionExpression(context, node);
       },
       ArrowFunctionExpression(node) {
-        lintArrowFunctionExpression(context, node);
+        lintArgsOfArrowFunctionExpression(context, node);
+        lintImplicitReturn(context, node);
       },
       TSFunctionType(node) {
-        lintTSFunctionType(context, node);
+        lintArgsOfTSFunctionType(context, node);
       },
       VariableDeclarator(node) {
         lintVariableDeclarator(context, node);