New: provide parser, parserName on RuleContext (fixes eslint#3670)

lib/eslint.js

@@ -502,12 +502,10 @@ module.exports = (function() {
         sourceCode = null;
 
     /**
-     * Parses text into an AST. Moved out here because the try-catch prevents
-     * optimization of functions, so it's best to keep the try-catch as isolated
-     * as possible
-     * @param {string} text The text to parse.
-     * @param {Object} config The ESLint configuration object.
-     * @returns {ASTNode} The AST if successful or null if not.
+     * Parses text into an AST, but does not catch exceptions.
+     * @param  {string} text The text to parse.
+     * @param  {Object} config The ESLint configuration object.
+     * @returns {ASTNode} The AST.
      * @private
      */
     function parse(text, config) {
@@ -522,33 +520,34 @@ module.exports = (function() {
                 attachComment: true
             };
 
-        try {
-            parser = require(config.parser);
-        } catch (ex) {
-            messages.push({
-                fatal: true,
-                severity: 2,
-                message: ex.message,
-                line: 0,
-                column: 0
-            });
-
-            return null;
-        }
+        parser = require(config.parser);
 
         // merge in any additional parser options
         if (config.parserOptions) {
             parserOptions = assign({}, config.parserOptions, parserOptions);
         }
 
+        return parser.parse(text, parserOptions);
+    }
+
+    /**
+     * Parses text into an AST. Moved out here because the try-catch prevents
+     * optimization of functions, so it's best to keep the try-catch as isolated
+     * as possible
+     * @param {string} text The text to parse.
+     * @param {Object} config The ESLint configuration object.
+     * @returns {ASTNode} The AST if successful or null if not.
+     * @private
+     */
+    function tryParse(text, config) {
         /*
          * Check for parsing errors first. If there's a parsing error, nothing
          * else can happen. However, a parsing error does not throw an error
          * from this method - it's just considered a fatal error message, a
          * problem that ESLint identified just like any other.
          */
         try {
-            return parser.parse(text, parserOptions);
+            return parse(text, config);
         } catch (ex) {
 
             // If the message includes a leading line number, strip it:
@@ -674,7 +673,7 @@ module.exports = (function() {
                 return messages;
             }
 
-            ast = parse(text.replace(/^#!([^\r\n]+)/, function(match, captured) {
+            ast = tryParse(text.replace(/^#!([^\r\n]+)/, function(match, captured) {
                 shebang = captured;
                 return "//" + captured;
             }), config);
@@ -703,7 +702,8 @@ module.exports = (function() {
                 var ruleCreator,
                     severity,
                     options,
-                    rule;
+                    rule,
+                    ruleParse;
 
                 ruleCreator = rules.get(key);
                 if (!ruleCreator) {
@@ -718,11 +718,16 @@ module.exports = (function() {
 
                 severity = getRuleSeverity(config.rules[key]);
                 options = getRuleOptions(config.rules[key]);
+                // close over config to simplify for rules
+                ruleParse = function(t) {
+                    return parse(t, config);
+                };
 
                 try {
                     rule = ruleCreator(new RuleContext(
                         key, api, severity, options,
-                        config.settings, config.parserOptions
+                        config.settings, config.parserOptions,
+                        ruleParse
                     ));
 
                     // add all the node types as listeners

lib/rule-context.js

@@ -70,14 +70,17 @@ var PASSTHROUGHS = [
  * @param {array} options The configuration information to be added to the rule.
  * @param {object} settings The configuration settings passed from the config file.
  * @param {object} parserOptions The parserOptions settings passed from the config file.
+ * @param {function} parse The 'parse' function from ESLint, closed over the config object.
  */
-function RuleContext(ruleId, eslint, severity, options, settings, parserOptions) {
+function RuleContext(ruleId, eslint, severity, options, settings, parserOptions, parse) {
     // public.
     this.id = ruleId;
     this.options = options;
     this.settings = settings;
     this.parserOptions = parserOptions;
 
+    this.parse = parse;
+
     // private.
     this.eslint = eslint;
     this.severity = severity;

tests/lib/eslint.js

@@ -3193,7 +3193,7 @@ describe("eslint", function() {
                 var messages = eslint.verify(code, { parser: "esprima-fbxyz" }, "filename");
                 assert.equal(messages.length, 1);
                 assert.equal(messages[0].severity, 2);
-                assert.equal(messages[0].message, "Cannot find module 'esprima-fbxyz'");
+                assert.equal(messages[0].message, "Parsing error: Cannot find module 'esprima-fbxyz'");
             });
 
             it("should strip leading line: prefix from parser error", function() {

tests/lib/rule-context.js

@@ -9,7 +9,8 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-var sinon = require("sinon"),
+var assert = require("chai").assert,
+    sinon = require("sinon"),
     leche = require("leche"),
     realESLint = require("../../lib/eslint"),
     RuleContext = require("../../lib/rule-context");
@@ -19,15 +20,15 @@ var sinon = require("sinon"),
 //------------------------------------------------------------------------------
 
 describe("RuleContext", function() {
-    var sandbox = sinon.sandbox.create();
+    var sandbox = sinon.sandbox.create(),
+        ruleContext, eslint;
 
-    describe("report()", function() {
-        var ruleContext, eslint;
+    beforeEach(function() {
+        eslint = leche.fake(realESLint);
+        ruleContext = new RuleContext("fake-rule", eslint, 2, {}, {}, {}, require("espree").parse);
+    });
 
-        beforeEach(function() {
-            eslint = leche.fake(realESLint);
-            ruleContext = new RuleContext("fake-rule", eslint, 2, {}, {}, {});
-        });
+    describe("report()", function() {
 
         describe("old-style call with location", function() {
             it("should call eslint.report() with rule ID and severity prepended", function() {
@@ -93,6 +94,16 @@ describe("RuleContext", function() {
                 mockESLint.verify();
             });
         });
+
+    });
+
+    describe("parse()", function() {
+        it("is present", function() {
+            assert.isFunction(ruleContext.parse);
+        });
+        it("works", function() {
+            assert.isObject(ruleContext.parse("function answer() { return 42; }"));
+        });
     });
 
 });