wip

update

Author: aladdin-add

lib/rules/fixer-return.js

@@ -5,50 +5,96 @@
 
 'use strict';
 
-const utils = require('../utils');
+// ------------------------------------------------------------------------------
+// Requirements
+// ------------------------------------------------------------------------------
 
+// const utils = require('../utils');
+const astUtils = require('../ast-utils.js');
 // ------------------------------------------------------------------------------
 // Rule Definition
 // ------------------------------------------------------------------------------
 
 module.exports = {
   meta: {
     docs: {
-      description: 'enforces fixer function always return a value',
-      category: 'Rules',
+      description: 'Expected fixer function to always return a value.',
+      category: 'Possible Errors',
       recommended: false,
     },
-    fixable: null,  // or "code" or "whitespace"
-    schema: [],
+    fixable: null,
   },
 
   create (context) {
-    // ----------------------------------------------------------------------
-    // Public
-    // ----------------------------------------------------------------------
-    const message = 'fixer function is expected to return a value.';
-    const sourceCode = context.getSourceCode();
+    const message = 'Expected fixer function to always return a value.';
+    let funcInfo = {
+      upper: null,
+      codePath: null,
+      hasReturn: false,
+      shouldCheck: false,
+      node: null,
+    };
+
+    /**
+     * Checks whether or not the last code path segment is reachable.
+     * Then reports this function if the segment is reachable.
+     *
+     * If the last code path segment is reachable, there are paths which are not
+     * returned or thrown.
+     *
+     * @param {ASTNode} node - A node to check.
+     * @returns {void}
+     */
+    function checkLastSegment (node) {
+      if (funcInfo.shouldCheck && funcInfo.codePath.currentSegments.some(segment => segment.reachable)) {
+        context.report({
+          node,
+          loc: (node.id || node).loc.start,
+          message,
+        });
+      }
+    }
 
     return {
-      Program (ast) {
-        utils.getTestInfo(context, ast).forEach(testRun => {
-          [testRun.valid, testRun.invalid].forEach(tests => {
-            const cache = Object.create(null);
-            // to avoid tests being null
-            (tests || []).forEach(test => {
-              const testCode = sourceCode.getText(test);
-              if (cache[testCode]) {
-                context.report({
-                  node: test,
-                  message,
-                });
-              } else {
-                cache[testCode] = true;
-              }
+
+      // Stacks this function's information.
+      onCodePathStart (codePath, node) {
+        const parent = node.parent;
+
+        funcInfo = {
+          upper: funcInfo,
+          codePath,
+          hasReturn: false,
+          shouldCheck:
+            node.type === 'FunctionExpression' &&
+            node.body.type === 'BlockStatement' &&
+            // check if it is naming fix
+            astUtils.getStaticPropertyName(parent) === 'fix',
+          node,
+        };
+      },
+
+      // Pops this function's information.
+      onCodePathEnd () {
+        funcInfo = funcInfo.upper;
+      },
+
+      // Checks the return statement is valid.
+      ReturnStatement (node) {
+        if (funcInfo.shouldCheck) {
+          funcInfo.hasReturn = true;
+
+          if (!node.argument) {
+            context.report({
+              node,
+              message,
             });
-          });
-        });
+          }
+        }
       },
+
+      // Reports a given function if the last path is reachable.
+      'FunctionExpression:exit': checkLastSegment,
     };
   },
 };

tests/lib/rules/fixer-return.js

@@ -12,20 +12,19 @@
 const rule = require('../../../lib/rules/fixer-return');
 const RuleTester = require('eslint').RuleTester;
 
-const ERROR = { message: 'fixer function is expected to return a value.' };
+const ERROR = { message: 'Expected fixer function to always return a value.' };
 
 // ------------------------------------------------------------------------------
 // Tests
 // ------------------------------------------------------------------------------
 
-const ruleTester = new RuleTester();
+const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
 ruleTester.run('fixer-return', rule, {
   valid: [
     `
     module.exports = {
         create: function(context) {
             context.report( {
-                node,
                 fix: function(fixer) {
                     return fixer.foo();
                 }
@@ -37,7 +36,6 @@ ruleTester.run('fixer-return', rule, {
     module.exports = {
         create: function(context) {
             context.report({
-                node,
                 fix: fixer => fixer.foo()
             });
         }
@@ -51,7 +49,6 @@ ruleTester.run('fixer-return', rule, {
       module.exports = {
           create: function(context) {
               context.report({
-                  node,
                   fix(fixer) {
                       fixer.foo();
                   }