feat(eslint-plugin): add support for object props in CallExpressions

packages/eslint-plugin/docs/rules/explicit-function-return-type.md

@@ -141,6 +141,13 @@ let objectPropCast = <ObjectType>{
 
 declare functionWithArg(arg: () => number);
 functionWithArg(() => 1);
+
+declare functionWithObjectArg(arg: { meth: () => number });
+functionWithObjectArg({
+  meth() {
+    return 1;
+  },
+});
 ```
 
 ### allowHigherOrderFunctions

packages/eslint-plugin/src/rules/explicit-function-return-type.ts

@@ -9,7 +9,7 @@ type Options = [
     allowExpressions?: boolean;
     allowTypedFunctionExpressions?: boolean;
     allowHigherOrderFunctions?: boolean;
-  }
+  },
 ];
 type MessageIds = 'missingReturnType';
 
@@ -118,28 +118,29 @@ export default util.createRule<Options, MessageIds>({
      * `const x = <Foo>{ prop: () => {} }`
      */
     function isPropertyOfObjectWithType(
-      parent: TSESTree.Node | undefined,
+      property: TSESTree.Node | undefined,
     ): boolean {
-      if (!parent || parent.type !== AST_NODE_TYPES.Property) {
+      if (!property || property.type !== AST_NODE_TYPES.Property) {
         return false;
       }
-      parent = parent.parent; // this shouldn't happen, checking just in case
+      const objectExpr = property.parent; // this shouldn't happen, checking just in case
       /* istanbul ignore if */ if (
-        !parent ||
-        parent.type !== AST_NODE_TYPES.ObjectExpression
+        !objectExpr ||
+        objectExpr.type !== AST_NODE_TYPES.ObjectExpression
       ) {
         return false;
       }
 
-      parent = parent.parent; // this shouldn't happen, checking just in case
+      const parent = objectExpr.parent; // this shouldn't happen, checking just in case
       /* istanbul ignore if */ if (!parent) {
         return false;
       }
 
       return (
         isTypeCast(parent) ||
         isClassPropertyWithTypeAnnotation(parent) ||
-        isVariableDeclaratorWithTypeAnnotation(parent)
+        isVariableDeclaratorWithTypeAnnotation(parent) ||
+        isFunctionArgument(parent)
       );
     }
 
@@ -193,12 +194,12 @@ export default util.createRule<Options, MessageIds>({
      */
     function isFunctionArgument(
       parent: TSESTree.Node,
-      child: TSESTree.Node,
+      callee?: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression,
     ): boolean {
       return (
         parent.type === AST_NODE_TYPES.CallExpression &&
         // make sure this isn't an IIFE
-        parent.callee !== child
+        parent.callee !== callee
       );
     }
 

packages/eslint-plugin/tests/rules/explicit-function-return-type.test.ts

@@ -281,6 +281,32 @@ new Accumulator().accumulate(() => 1);
         },
       ],
     },
+    {
+      filename: 'test.ts',
+      code: `
+declare function foo(arg: { meth: () => number }): void
+foo({
+  meth() {
+    return 1;
+  },
+})
+foo({
+  meth: function () {
+    return 1;
+  },
+})
+foo({
+  meth: () => {
+    return 1;
+  },
+})
+      `,
+      options: [
+        {
+          allowTypedFunctionExpressions: true,
+        },
+      ],
+    },
   ],
   invalid: [
     {
@@ -289,7 +315,7 @@ new Accumulator().accumulate(() => 1);
 function test() {
     return;
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'missingReturnType',
@@ -304,7 +330,7 @@ function test() {
 var fn = function() {
     return 1;
 };
-            `,
+      `,
       errors: [
         {
           messageId: 'missingReturnType',
@@ -317,7 +343,7 @@ var fn = function() {
       filename: 'test.ts',
       code: `
 var arrowFn = () => 'test';
-            `,
+      `,
       errors: [
         {
           messageId: 'missingReturnType',
@@ -340,7 +366,7 @@ class Test {
   }
   arrow = () => 'arrow';
 }
-            `,
+      `,
       errors: [
         {
           messageId: 'missingReturnType',
@@ -361,21 +387,23 @@ class Test {
     },
     {
       filename: 'test.ts',
-      code: `function test() {
-        return;
-      }`,
+      code: `
+function test() {
+  return;
+}
+      `,
       options: [{ allowExpressions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 1,
+          line: 2,
           column: 1,
         },
       ],
     },
     {
       filename: 'test.ts',
-      code: `const foo = () => {};`,
+      code: 'const foo = () => {};',
       options: [{ allowExpressions: true }],
       errors: [
         {
@@ -387,7 +415,7 @@ class Test {
     },
     {
       filename: 'test.ts',
-      code: `const foo = function() {};`,
+      code: 'const foo = function() {};',
       options: [{ allowExpressions: true }],
       errors: [
         {
@@ -399,7 +427,7 @@ class Test {
     },
     {
       filename: 'test.ts',
-      code: `var arrowFn = () => 'test';`,
+      code: "var arrowFn = () => 'test';",
       options: [{ allowTypedFunctionExpressions: true }],
       errors: [
         {
@@ -411,7 +439,7 @@ class Test {
     },
     {
       filename: 'test.ts',
-      code: `var funcExpr = function() { return 'test'; };`,
+      code: "var funcExpr = function() { return 'test'; };",
       options: [{ allowTypedFunctionExpressions: true }],
       errors: [
         {
@@ -424,7 +452,7 @@ class Test {
 
     {
       filename: 'test.ts',
-      code: `const x = (() => {}) as Foo`,
+      code: 'const x = (() => {}) as Foo',
       options: [{ allowTypedFunctionExpressions: false }],
       errors: [
         {
@@ -467,84 +495,72 @@ const x: Foo = {
     },
     {
       filename: 'test.ts',
-      code: `
-() => () => {};
-            `,
+      code: '() => () => {};',
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 2,
+          line: 1,
           column: 7,
         },
       ],
     },
     {
       filename: 'test.ts',
-      code: `
-() => function () {};
-            `,
+      code: '() => function () {};',
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 2,
+          line: 1,
           column: 7,
         },
       ],
     },
     {
       filename: 'test.ts',
-      code: `
-() => { return () => {} };
-            `,
+      code: '() => { return () => {} };',
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 2,
+          line: 1,
           column: 16,
         },
       ],
     },
     {
       filename: 'test.ts',
-      code: `
-() => { return function () {} };
-            `,
+      code: '() => { return function () {} };',
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 2,
+          line: 1,
           column: 16,
         },
       ],
     },
     {
       filename: 'test.ts',
-      code: `
-function fn() { return () => {} };
-            `,
+      code: 'function fn() { return () => {} };',
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 2,
+          line: 1,
           column: 24,
         },
       ],
     },
     {
       filename: 'test.ts',
-      code: `
-function fn() { return function () {} };
-            `,
+      code: 'function fn() { return function () {} };',
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 2,
+          line: 1,
           column: 24,
         },
       ],
@@ -574,14 +590,12 @@ function FunctionDeclaration() {
     },
     {
       filename: 'test.ts',
-      code: `
-() => () => { return () => { return; } };
-            `,
+      code: '() => () => { return () => { return; } };',
       options: [{ allowHigherOrderFunctions: true }],
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 2,
+          line: 1,
           column: 22,
         },
       ],
@@ -651,10 +665,41 @@ new Accumulator().accumulate(() => 1);
         },
       ],
     },
+    {
+      filename: 'test.ts',
+      code: '(() => true)()',
+      options: [
+        {
+          allowTypedFunctionExpressions: false,
+        },
+      ],
+      errors: [
+        {
+          messageId: 'missingReturnType',
+          line: 1,
+          column: 2,
+        },
+      ],
+    },
     {
       filename: 'test.ts',
       code: `
-(() => true)()
+declare function foo(arg: { meth: () => number }): void
+foo({
+  meth() {
+    return 1;
+  },
+})
+foo({
+  meth: function () {
+    return 1;
+  },
+})
+foo({
+  meth: () => {
+    return 1;
+  },
+})
       `,
       options: [
         {
@@ -664,8 +709,18 @@ new Accumulator().accumulate(() => 1);
       errors: [
         {
           messageId: 'missingReturnType',
-          line: 2,
-          column: 2,
+          line: 4,
+          column: 7,
+        },
+        {
+          messageId: 'missingReturnType',
+          line: 9,
+          column: 9,
+        },
+        {
+          messageId: 'missingReturnType',
+          line: 14,
+          column: 9,
         },
       ],
     },