Add a helper function for determining function-like expressions

lib/rules/display-name.js

@@ -6,6 +6,7 @@
 
 const has = require('has');
 const Components = require('../util/Components');
+const astUtil = require('../util/ast');
 const docsUrl = require('../util/docsUrl');
 
 // ------------------------------------------------------------------------------
@@ -116,7 +117,7 @@ module.exports = {
       );
 
       const namedFunctionExpression = (
-        (node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') &&
+        astUtil.isFunctionLikeExpression(node) &&
         node.parent &&
         (node.parent.type === 'VariableDeclarator' || node.parent.method === true) &&
         (!node.parent.parent || !utils.isES5Component(node.parent.parent))

lib/rules/no-array-index-key.js

@@ -5,6 +5,7 @@
 'use strict';
 
 const has = require('has');
+const astUtil = require('../util/ast');
 const docsUrl = require('../util/docsUrl');
 
 // ------------------------------------------------------------------------------
@@ -63,11 +64,7 @@ module.exports = {
         return null;
       }
 
-      const isFunction = [
-        'ArrowFunctionExpression',
-        'FunctionExpression'
-      ].indexOf(firstArg.type) !== -1;
-      if (!isFunction) {
+      if (!astUtil.isFunctionLikeExpression(firstArg)) {
         return null;
       }
 

lib/rules/no-unused-prop-types.js

@@ -11,6 +11,7 @@ const has = require('has');
 const Components = require('../util/Components');
 const variable = require('../util/variable');
 const annotations = require('../util/annotations');
+const astUtil = require('../util/ast');
 const versionUtil = require('../util/version');
 const propsUtil = require('../util/props');
 const docsUrl = require('../util/docsUrl');
@@ -835,10 +836,7 @@ module.exports = {
             types.node = value;
             declaredPropTypes.push(types);
             // Handle custom prop validators using props inside
-            if (
-              value.type === 'ArrowFunctionExpression'
-              || value.type === 'FunctionExpression'
-            ) {
+            if (astUtil.isFunctionLikeExpression(value)) {
               markPropTypesAsUsed(value);
             }
           });

lib/rules/require-render-return.js

@@ -46,7 +46,7 @@ module.exports = {
         if (astUtil.getPropertyName(properties[i]) !== 'render' || !properties[i].value) {
           continue;
         }
-        return /FunctionExpression$/.test(properties[i].value.type);
+        return astUtil.isFunctionLikeExpression(properties[i].value);
       }
       return false;
     }

lib/rules/sort-comp.js

@@ -393,13 +393,11 @@ module.exports = {
         instanceVariable: !node.static &&
           node.type === 'ClassProperty' &&
           node.value &&
-          node.value.type !== 'ArrowFunctionExpression' &&
-          node.value.type !== 'FunctionExpression',
+          !astUtil.isFunctionLikeExpression(node.value),
         instanceMethod: !node.static &&
           node.type === 'ClassProperty' &&
           node.value &&
-          (node.value.type === 'ArrowFunctionExpression' ||
-            node.value.type === 'FunctionExpression'),
+          (astUtil.isFunctionLikeExpression(node.value)),
         typeAnnotation: !!node.typeAnnotation && node.value === null
       }));
 

lib/util/ast.js

@@ -62,19 +62,18 @@ function getComponentProperties(node) {
     case 'ClassExpression':
       return node.body.body;
     case 'ObjectExpression':
-      // return node.properties;
       return node.properties;
     default:
       return [];
   }
 }
 
 /**
-     * Checks if the node is the first in its line, excluding whitespace.
-     * @param {Object} context The node to check
-     * @param {ASTNode} node The node to check
-     * @return {Boolean} true if its the first node in its line
-     */
+ * Checks if the node is the first in its line, excluding whitespace.
+ * @param {Object} context The node to check
+ * @param {ASTNode} node The node to check
+ * @return {Boolean} true if it's the first node in its line
+ */
 function isNodeFirstInLine(context, node) {
   const sourceCode = context.getSourceCode();
   let token = node;
@@ -94,11 +93,20 @@ function isNodeFirstInLine(context, node) {
   return startLine !== endLine;
 }
 
+/**
+ * Checks if the node is a function or arrow function expression.
+ * @param {Object} context The node to check
+ * @return {Boolean} true if it's a function-like expression
+ */
+function isFunctionLikeExpression(node) {
+  return node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression';
+}
 
 module.exports = {
   findReturnStatement: findReturnStatement,
   getPropertyName: getPropertyName,
   getPropertyNameNode: getPropertyNameNode,
   getComponentProperties: getComponentProperties,
-  isNodeFirstInLine: isNodeFirstInLine
+  isNodeFirstInLine: isNodeFirstInLine,
+  isFunctionLikeExpression: isFunctionLikeExpression
 };