eslint 0.22.0 → 0.24.1

package/lib/rules/no-unreachable.js

@@ -1,98 +1,98 @@
-/**
- * @fileoverview Checks for unreachable code due to return, throws, break, and continue.
- * @author Joel Feenstra
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-
-function report(context, node, unreachableType) {
-    var keyword;
-    switch (unreachableType) {
-        case "BreakStatement":
-            keyword = "break";
-            break;
-        case "ContinueStatement":
-            keyword = "continue";
-            break;
-        case "ReturnStatement":
-            keyword = "return";
-            break;
-        case "ThrowStatement":
-            keyword = "throw";
-            break;
-        default:
-            return;
-    }
-    context.report(node, "Found unexpected statement after a {{type}}.", { type: keyword });
-}
-
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    /**
-     * Checks if a node is an exception for no-unreachable because of variable/function hoisting
-     * @param {ASTNode} node The AST node to check.
-     * @returns {boolean} if the node doesn't trigger unreachable
-     * @private
-     */
-    function isUnreachableAllowed(node) {
-        return node.type === "FunctionDeclaration" ||
-            node.type === "VariableDeclaration" &&
-            node.declarations.every(function(declaration) {
-                return declaration.type === "VariableDeclarator" && declaration.init === null;
-            });
-    }
-
-    /*
-     * Verifies that the given node is the last node or followed exclusively by
-     * hoisted declarations
-     * @param {ASTNode} node Node that should be the last node
-     * @returns {void}
-     * @private
-     */
-    function checkNode(node) {
-        var parent = context.getAncestors().pop();
-        var field, i, sibling;
-
-        switch (parent.type) {
-            case "SwitchCase":
-                field = "consequent";
-                break;
-            case "Program":
-            case "BlockStatement":
-                field = "body";
-                break;
-            default:
-                return;
-        }
-
-        for (i = parent[field].length - 1; i >= 0; i--) {
-            sibling = parent[field][i];
-            if (sibling === node) {
-                return; // Found the last reachable statement, all done
-            }
-
-            if (!isUnreachableAllowed(sibling)) {
-                report(context, sibling, node.type);
-            }
-        }
-    }
-
-    return {
-        "ReturnStatement": checkNode,
-        "ThrowStatement": checkNode,
-        "ContinueStatement": checkNode,
-        "BreakStatement": checkNode
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Checks for unreachable code due to return, throws, break, and continue.
+ * @author Joel Feenstra
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+
+function report(context, node, unreachableType) {
+    var keyword;
+    switch (unreachableType) {
+        case "BreakStatement":
+            keyword = "break";
+            break;
+        case "ContinueStatement":
+            keyword = "continue";
+            break;
+        case "ReturnStatement":
+            keyword = "return";
+            break;
+        case "ThrowStatement":
+            keyword = "throw";
+            break;
+        default:
+            return;
+    }
+    context.report(node, "Found unexpected statement after a {{type}}.", { type: keyword });
+}
+
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * Checks if a node is an exception for no-unreachable because of variable/function hoisting
+     * @param {ASTNode} node The AST node to check.
+     * @returns {boolean} if the node doesn't trigger unreachable
+     * @private
+     */
+    function isUnreachableAllowed(node) {
+        return node.type === "FunctionDeclaration" ||
+            node.type === "VariableDeclaration" &&
+            node.declarations.every(function(declaration) {
+                return declaration.type === "VariableDeclarator" && declaration.init === null;
+            });
+    }
+
+    /*
+     * Verifies that the given node is the last node or followed exclusively by
+     * hoisted declarations
+     * @param {ASTNode} node Node that should be the last node
+     * @returns {void}
+     * @private
+     */
+    function checkNode(node) {
+        var parent = context.getAncestors().pop();
+        var field, i, sibling;
+
+        switch (parent.type) {
+            case "SwitchCase":
+                field = "consequent";
+                break;
+            case "Program":
+            case "BlockStatement":
+                field = "body";
+                break;
+            default:
+                return;
+        }
+
+        for (i = parent[field].length - 1; i >= 0; i--) {
+            sibling = parent[field][i];
+            if (sibling === node) {
+                return; // Found the last reachable statement, all done
+            }
+
+            if (!isUnreachableAllowed(sibling)) {
+                report(context, sibling, node.type);
+            }
+        }
+    }
+
+    return {
+        "ReturnStatement": checkNode,
+        "ThrowStatement": checkNode,
+        "ContinueStatement": checkNode,
+        "BreakStatement": checkNode
+    };
+
+};
+
+module.exports.schema = [];

package/lib/rules/no-unused-expressions.js

@@ -1,76 +1,76 @@
-/**
- * @fileoverview Flag expressions in statement position that do not side effect
- * @author Michael Ficarra
- * @copyright 2013 Michael Ficarra. All rights reserved.
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-module.exports = function(context) {
-
-    /**
-     * @param {ASTNode} node - any node
-     * @returns {Boolean} whether the given node structurally represents a directive
-     */
-    function looksLikeDirective(node) {
-        return node.type === "ExpressionStatement" &&
-            node.expression.type === "Literal" && typeof node.expression.value === "string";
-    }
-
-    /**
-     * @param {Function} predicate - ([a] -> Boolean) the function used to make the determination
-     * @param {a[]} list - the input list
-     * @returns {a[]} the leading sequence of members in the given list that pass the given predicate
-     */
-    function takeWhile(predicate, list) {
-        for (var i = 0, l = list.length; i < l; ++i) {
-            if (!predicate(list[i])) {
-                break;
-            }
-        }
-        return [].slice.call(list, 0, i);
-    }
-
-    /**
-     * @param {ASTNode} node - a Program or BlockStatement node
-     * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body
-     */
-    function directives(node) {
-        return takeWhile(looksLikeDirective, node.body);
-    }
-
-    /**
-     * @param {ASTNode} node - any node
-     * @param {ASTNode[]} ancestors - the given node's ancestors
-     * @returns {Boolean} whether the given node is considered a directive in its current position
-     */
-    function isDirective(node, ancestors) {
-        var parent = ancestors[ancestors.length - 1],
-            grandparent = ancestors[ancestors.length - 2];
-        return (parent.type === "Program" || parent.type === "BlockStatement" &&
-                (/Function/.test(grandparent.type))) &&
-                directives(parent).indexOf(node) >= 0;
-    }
-
-    return {
-        "ExpressionStatement": function(node) {
-
-            var type = node.expression.type,
-                ancestors = context.getAncestors();
-
-            if (
-                !/^(?:Assignment|Call|New|Update|Yield)Expression$/.test(type) &&
-                (type !== "UnaryExpression" || ["delete", "void"].indexOf(node.expression.operator) < 0) &&
-                !isDirective(node, ancestors)
-            ) {
-                context.report(node, "Expected an assignment or function call and instead saw an expression.");
-            }
-        }
-    };
-
-};
-
-module.exports.schema = [];
+/**
+ * @fileoverview Flag expressions in statement position that do not side effect
+ * @author Michael Ficarra
+ * @copyright 2013 Michael Ficarra. All rights reserved.
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = function(context) {
+
+    /**
+     * @param {ASTNode} node - any node
+     * @returns {Boolean} whether the given node structurally represents a directive
+     */
+    function looksLikeDirective(node) {
+        return node.type === "ExpressionStatement" &&
+            node.expression.type === "Literal" && typeof node.expression.value === "string";
+    }
+
+    /**
+     * @param {Function} predicate - ([a] -> Boolean) the function used to make the determination
+     * @param {a[]} list - the input list
+     * @returns {a[]} the leading sequence of members in the given list that pass the given predicate
+     */
+    function takeWhile(predicate, list) {
+        for (var i = 0, l = list.length; i < l; ++i) {
+            if (!predicate(list[i])) {
+                break;
+            }
+        }
+        return [].slice.call(list, 0, i);
+    }
+
+    /**
+     * @param {ASTNode} node - a Program or BlockStatement node
+     * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body
+     */
+    function directives(node) {
+        return takeWhile(looksLikeDirective, node.body);
+    }
+
+    /**
+     * @param {ASTNode} node - any node
+     * @param {ASTNode[]} ancestors - the given node's ancestors
+     * @returns {Boolean} whether the given node is considered a directive in its current position
+     */
+    function isDirective(node, ancestors) {
+        var parent = ancestors[ancestors.length - 1],
+            grandparent = ancestors[ancestors.length - 2];
+        return (parent.type === "Program" || parent.type === "BlockStatement" &&
+                (/Function/.test(grandparent.type))) &&
+                directives(parent).indexOf(node) >= 0;
+    }
+
+    return {
+        "ExpressionStatement": function(node) {
+
+            var type = node.expression.type,
+                ancestors = context.getAncestors();
+
+            if (
+                !/^(?:Assignment|Call|New|Update|Yield)Expression$/.test(type) &&
+                (type !== "UnaryExpression" || ["delete", "void"].indexOf(node.expression.operator) < 0) &&
+                !isDirective(node, ancestors)
+            ) {
+                context.report(node, "Expected an assignment or function call and instead saw an expression.");
+            }
+        }
+    };
+
+};
+
+module.exports.schema = [];