tools: update ESLint to 4.2.0

ESLint 4.2.0 contains a fix for a bug that is blocking us from moving to the non-legacy stricter indentation linting. Update to 4.2.0 to remove the blocking issue. PR-URL: #14155 Ref: eslint/eslint#8882 Ref: eslint/eslint#8885 Reviewed-By: Colin Ihrig <[email protected]> Reviewed-By: Michaël Zasso <[email protected]> Reviewed-By: Gibson Fahnestock <[email protected]> Reviewed-By: Refael Ackermann <[email protected]>

Author: Trott

tools/eslint/conf/eslint-recommended.js

@@ -48,6 +48,7 @@ module.exports ={
 "func-names": "off",
 "func-style": "off",
 "generator-star-spacing": "off",
+"getter-return": "off",
 "global-require": "off",
 "guard-for-in": "off",
 "handle-callback-err": "off",

tools/eslint/lib/cli-engine.js

@@ -45,7 +45,7 @@ const debug = require("debug")("eslint:cli-engine");
  * @property{string} cwd The value to use for the current working directory.
  * @property{string[]} envs An array of environments to load.
  * @property{string[]} extensions An array of file extensions to check.
- * @property{boolean} fix Execute in autofix mode.
+ * @property{boolean|Function} fix Execute in autofix mode. If a function, should return a boolean.
  * @property{string[]} globals An array of global variables to declare.
  * @property{boolean} ignore False disables use of .eslintignore.
  * @property{string} ignorePath The ignore file to use instead of .eslintignore.
@@ -135,7 +135,7 @@ function calculateStatsPerRun(results){
  * @param{string} text The source code to check.
  * @param{Object} configHelper The configuration options for ESLint.
  * @param{string} filename An optional string representing the texts filename.
- * @param{boolean} fix Indicates if fixes should be processed.
+ * @param{boolean|Function} fix Indicates if fixes should be processed.
  * @param{boolean} allowInlineConfig Allow/ignore comments that change config.
  * @param{Linter} linter Linter context
  * @returns{LintResult} The results for linting on this text.
@@ -195,7 +195,8 @@ function processText(text, configHelper, filename, fix, allowInlineConfig, linte
 if(fix){
 fixedResult=linter.verifyAndFix(text,config,{
  filename,
- allowInlineConfig
+ allowInlineConfig,
+ fix
 });
 messages=fixedResult.messages;
 }else{

tools/eslint/lib/cli.js

@@ -28,6 +28,17 @@ const debug = require("debug")("eslint:cli");
 // Helpers
 //------------------------------------------------------------------------------
 
+/**
+ * Predicate function for whether or not to apply fixes in quiet mode.
+ * If a message is a warning, do not apply a fix.
+ * @param{LintResult} lintResult The lint result.
+ * @returns{boolean} True if the lint message is an error (and thus should be
+ * autofixed), false otherwise.
+ */
+functionquietFixPredicate(lintResult){
+returnlintResult.severity===2;
+}
+
 /**
  * Translates the CLI options into the options expected by the CLIEngine.
  * @param{Object} cliOptions The CLI options to translate.
@@ -52,7 +63,7 @@ function translateOptions(cliOptions){
 cache: cliOptions.cache,
 cacheFile: cliOptions.cacheFile,
 cacheLocation: cliOptions.cacheLocation,
-fix: cliOptions.fix,
+fix: cliOptions.fix&&(cliOptions.quiet ? quietFixPredicate : true),
 allowInlineConfig: cliOptions.inlineConfig
 };
 }

tools/eslint/lib/config/config-validator.js

@@ -9,7 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-constschemaValidator=require("is-my-json-valid"),
+constajv=require("../util/ajv"),
 configSchema=require("../../conf/config-schema.js"),
 util=require("util");
 
@@ -20,6 +20,7 @@ const validators ={
 //------------------------------------------------------------------------------
 // Private
 //------------------------------------------------------------------------------
+letvalidateSchema;
 
 /**
  * Gets a complete options schema for a rule.
@@ -79,15 +80,15 @@ function validateRuleSchema(id, localOptions, rulesContext){
 constschema=getRuleOptionsSchema(id,rulesContext);
 
 if(!validators.rules[id]&&schema){
-validators.rules[id]=schemaValidator(schema,{verbose: true});
+validators.rules[id]=ajv.compile(schema);
 }
 
 constvalidateRule=validators.rules[id];
 
 if(validateRule){
 validateRule(localOptions);
 if(validateRule.errors){
-thrownewError(validateRule.errors.map(error=>`\tValue "${error.value}" ${error.message}.\n`).join(""));
+thrownewError(validateRule.errors.map(error=>`\tValue "${error.data}" ${error.message}.\n`).join(""));
 }
 }
 }
@@ -158,19 +159,23 @@ function validateRules(rulesConfig, source, rulesContext){
  * @returns{string} Formatted error message
  */
 functionformatErrors(errors){
-
 returnerrors.map(error=>{
-if(error.message==="has additional properties"){
-return`Unexpected top-level property "${error.value.replace(/^data\./,"")}"`;
+if(error.keyword==="additionalProperties"){
+constformattedPropertyPath=error.dataPath.length ? `${error.dataPath.slice(1)}.${error.params.additionalProperty}` : error.params.additionalProperty;
+
+return`Unexpected top-level property "${formattedPropertyPath}"`;
 }
-if(error.message==="is the wrong type"){
-constformattedField=error.field.replace(/^data\./,"");
-constformattedExpectedType=typeoferror.type==="string"? error.type : error.type.join("/");
-constformattedValue=JSON.stringify(error.value);
+if(error.keyword==="type"){
+constformattedField=error.dataPath.slice(1);
+constformattedExpectedType=Array.isArray(error.schema)? error.schema.join("/") : error.schema;
+constformattedValue=JSON.stringify(error.data);
 
 return`Property "${formattedField}" is the wrong type (expected ${formattedExpectedType} but got \`${formattedValue}\`)`;
 }
-return`"${error.field.replace(/^(data\.)/,"")}" ${error.message}. Value: ${JSON.stringify(error.value)}`;
+
+constfield=error.dataPath[0]==="." ? error.dataPath.slice(1) : error.dataPath;
+
+return`"${field}" ${error.message}. Value: ${JSON.stringify(error.data)}`;
 }).map(message=>`\t- ${message}.\n`).join("");
 }
 
@@ -181,10 +186,10 @@ function formatErrors(errors){
  * @returns{void}
  */
 functionvalidateConfigSchema(config,source){
-constvalidator=schemaValidator(configSchema,{verbose: true});
+validateSchema=validateSchema||ajv.compile(configSchema);
 
-if(!validator(config)){
-thrownewError(`${source}:\n\tESLint configuration is invalid:\n${formatErrors(validator.errors)}`);
+if(!validateSchema(config)){
+thrownewError(`${source}:\n\tESLint configuration is invalid:\n${formatErrors(validateSchema.errors)}`);
 }
 }
 

tools/eslint/lib/linter.js

@@ -1197,6 +1197,7 @@ class Linter extends EventEmitter{
  * @param{string} options.filename The filename from which the text was read.
  * @param{boolean} options.allowInlineConfig Flag indicating if inline comments
  * should be allowed.
+ * @param{boolean|Function} options.fix Determines whether fixes should be applied
  * @returns{Object} The result of the fix operation as returned from the
  * SourceCodeFixer.
  */
@@ -1205,6 +1206,8 @@ class Linter extends EventEmitter{
 fixedResult,
 fixed=false,
 passNumber=0;
+constdebugTextDescription=options&&options.filename||`${text.slice(0,10)}...`;
+constshouldFix=options&&options.fix||true;
 
 /**
  * This loop continues until one of the following is true:
@@ -1218,11 +1221,11 @@ class Linter extends EventEmitter{
 do{
 passNumber++;
 
-debug(`Linting code for ${options.filename} (pass ${passNumber})`);
+debug(`Linting code for ${debugTextDescription} (pass ${passNumber})`);
 messages=this.verify(text,config,options);
 
-debug(`Generating fixed text for ${options.filename} (pass ${passNumber})`);
-fixedResult=SourceCodeFixer.applyFixes(this.getSourceCode(),messages);
+debug(`Generating fixed text for ${debugTextDescription} (pass ${passNumber})`);
+fixedResult=SourceCodeFixer.applyFixes(this.getSourceCode(),messages,shouldFix);
 
 // stop if there are any syntax errors.
 // 'fixedResult.output' is a empty string.

tools/eslint/lib/rules/arrow-parens.js

@@ -66,7 +66,10 @@ module.exports ={
  */
 functionfixParamsWithParenthesis(fixer){
 constparamToken=sourceCode.getTokenAfter(firstTokenOfParam);
-constclosingParenToken=sourceCode.getTokenAfter(paramToken);
+
+// ES8 allows Trailing commas in function parameter lists and calls
+// https://github.com/eslint/eslint/issues/8834
+constclosingParenToken=sourceCode.getTokenAfter(paramToken,astUtils.isClosingParenToken);
 constasyncToken=isAsync ? sourceCode.getTokenBefore(firstTokenOfParam) : null;
 constshouldAddSpaceForAsync=asyncToken&&(asyncToken.end===firstTokenOfParam.start);
 

tools/eslint/lib/rules/comma-dangle.js

@@ -81,49 +81,49 @@ module.exports ={
 category: "Stylistic Issues",
 recommended: false
 },
-
 fixable: "code",
-
-schema: [
-{
-defs: {
-value: {
-enum: [
-"always",
-"always-multiline",
-"only-multiline",
-"never"
-]
-},
-valueWithIgnore: {
-anyOf: [
-{
-$ref: "#/defs/value"
-},
-{
-enum: ["ignore"]
-}
-]
-}
+schema: {
+definitions: {
+value: {
+enum: [
+"always-multiline",
+"always",
+"never",
+"only-multiline"
+]
 },
-anyOf: [
-{
-$ref: "#/defs/value"
-},
-{
-type: "object",
-properties: {
-arrays: {$refs: "#/defs/valueWithIgnore"},
-objects: {$refs: "#/defs/valueWithIgnore"},
-imports: {$refs: "#/defs/valueWithIgnore"},
-exports: {$refs: "#/defs/valueWithIgnore"},
-functions: {$refs: "#/defs/valueWithIgnore"}
+valueWithIgnore: {
+enum: [
+"always-multiline",
+"always",
+"ignore",
+"never",
+"only-multiline"
+]
+}
+},
+type: "array",
+items: [
+{
+oneOf: [
+{
+$ref: "#/definitions/value"
 },
-additionalProperties: false
-}
-]
-}
-]
+{
+type: "object",
+properties: {
+arrays: {$ref: "#/definitions/valueWithIgnore"},
+objects: {$ref: "#/definitions/valueWithIgnore"},
+imports: {$ref: "#/definitions/valueWithIgnore"},
+exports: {$ref: "#/definitions/valueWithIgnore"},
+functions: {$ref: "#/definitions/valueWithIgnore"}
+},
+additionalProperties: false
+}
+]
+}
+]
+}
 },
 
 create(context){

tools/eslint/lib/rules/dot-notation.js

@@ -116,6 +116,15 @@ module.exports ={
 returnnull;
 }
 
+if(node.object.type==="Identifier"&&node.object.name==="let"){
+
+/*
+ * A statement that starts with `let[` is parsed as a destructuring variable declaration, not
+ * a MemberExpression.
+ */
+returnnull;
+}
+
 returnfixer.replaceTextRange(
 [dot.range[0],node.property.range[1]],
 `[${textAfterDot}"${node.property.name}"]`