Repository: eslint/eslint (js)

Issue:
no-undef-init incorrectly autofixes some `var` declarations
<!--
    ESLint adheres to the [JS Foundation Code of Conduct](https://js.foundation/community/code-of-conduct).

    This template is for bug reports. If you are reporting a bug, please continue on. If you are here for another reason, please see below:

    1. To propose a new rule: http://eslint.org/docs/developer-guide/contributing/new-rules
    2. To request a change: http://eslint.org/docs/developer-guide/contributing/changes
    3. If you have any questions, please stop by our chatroom: https://gitter.im/eslint/eslint

    Note that leaving sections blank will make it difficult for us to troubleshoot and we may have to close the issue.
-->

**Tell us about your environment**

* **ESLint Version:** 4.6.1
* **Node Version:** 6.9.1
* **npm Version:** 3.9.3

**What parser (default, Babel-ESLint, etc.) are you using?**
default

**Please show your full configuration:**

<details>
<summary>Configuration</summary>

<!-- Paste your configuration below: -->
```js
{
  "env": {
    "browser": true,
    "node": true,
    "amd": true,
    "mocha": true
  },

  "rules": {
    //Possible Errors
    //The following rules point out areas where you might have made mistakes.

    "comma-dangle": [2, "always-multiline"], //disallow or enforce trailing commas (recommended)
    "no-cond-assign": [2], //disallow assignment in conditional expressions (recommended)
    "no-console": [2], //disallow use of console in the node environment (recommended)
    "no-constant-condition": [2], //disallow use of constant expressions in conditions (recommended)
    "no-control-regex": [2], //disallow control characters in regular expressions (recommended)
    "no-debugger": [2], //disallow use of debugger (recommended)
    "no-dupe-args": [2], //disallow duplicate arguments in functions (recommended)
    "no-dupe-keys": [2], //disallow duplicate keys when creating object literals (recommended)
    "no-duplicate-case": [2], //disallow a duplicate case label. (recommended)
    "no-empty-character-class": [2], //disallow the use of empty character classes in regular expressions (recommended)
    "no-empty": [2], //disallow empty statements (recommended)
    "no-ex-assign": [2], //disallow assigning to the exception in a catch block (recommended)
    "no-extra-boolean-cast": [2], //disallow double-negation boolean casts in a boolean context (recommended)
    "no-extra-parens": [2, "all", { "nestedBinaryExpressions": false }], //disallow unnecessary parentheses
    "no-extra-semi": [2], //disallow unnecessary semicolons (recommended)
    "no-func-assign": [2], //disallow overwriting functions written as function declarations (recommended)
    "no-inner-declarations": [2, "functions"], //disallow function or variable declarations in nested blocks (recommended)
    "no-invalid-regexp": [2], //disallow invalid regular expression strings in the RegExp constructor (recommended)
    "no-irregular-whitespace": [2], //disallow irregular whitespace outside of strings and comments (recommended)
    "no-negated-in-lhs": [2], //disallow negation of the left operand of an in expression (recommended)
    "no-obj-calls": [2], //disallow the use of object properties of the global object (Math and JSON) as functions (recommended)
    "no-prototype-builtins": [0], //Disallow use of Object.prototypes builtins directly
    "no-regex-spaces": [2], //disallow multiple spaces in a regular expression literal (recommended)
    "no-sparse-arrays": [2], //disallow sparse arrays (recommended)
    "no-unexpected-multiline": [2], //Avoid code that looks like two expressions but is actually one
    "no-unreachable": [2], //disallow unreachable statements after a return, throw, continue, or break statement (recommended)
    "no-unsafe-finally": [2], //disallow control flow statements in finally blocks
    "use-isnan": [2], //disallow comparisons with the value NaN (recommended)
    "valid-jsdoc": [2], //Ensure JSDoc comments are valid
    "valid-typeof": [2], //Ensure that the results of typeof are compared against a valid string (recommended)

    //Best Practices
    //These are rules designed to prevent you from making mistakes. They either prescribe a better way of doing something or help you avoid footguns.

    "accessor-pairs": [0], //Enforces getter/setter pairs in objects
    "array-callback-return": [0], //Enforces return statements in callbacks of array's methods
    "block-scoped-var": [2], //treat var statements as if they were block scoped
    "complexity": [0], //specify the maximum cyclomatic complexity allowed in a program
    "consistent-return": [2], //require return statements to either always or never specify values
    "curly": [2], //specify curly brace conventions for all control statements
    "default-case": [2], //require default case in switch statements
    "dot-notation": [2], //encourages use of dot notation whenever possible
    "dot-location": [2, "property"], //enforces consistent newlines before or after dots
    "eqeqeq": [2, "smart"], //require the use of === and !== (fixable)
    "guard-for-in": [0], //make sure for-in loops have an if statement
    "no-alert": [2], //disallow the use of alert, confirm, and prompt
    "no-caller": [2], //disallow use of arguments.caller or arguments.callee
    "no-case-declarations": [2], //disallow lexical declarations in case clauses
    "no-div-regex": [2], //disallow division operators explicitly at beginning of regular expression
    "no-else-return": [0], //disallow else after a return in an if
    "no-empty-function": [2], //disallow use of empty functions
    "no-empty-pattern": [2], //disallow use of empty destructuring patterns
    "no-eq-null": [0], //disallow comparisons to null without a type-checking operator
    "no-eval": [2], //disallow use of eval()
    "no-extend-native": [2], //disallow adding to native types
    "no-extra-bind": [2], //disallow unnecessary function binding
    "no-extra-label": [2], //disallow unnecessary labels
    "no-fallthrough": [2], //disallow fallthrough of case statements (recommended)
    "no-floating-decimal": [2], //disallow the use of leading or trailing decimal points in numeric literals
    "no-implicit-coercion": [0], //disallow the type conversions with shorter notations
    "no-implicit-globals": [2], //disallow var and named functions in global scope
    "no-implied-eval": [2], //disallow use of eval()-like methods
    "no-invalid-this": [2], //disallow this keywords outside of classes or class-like objects
    "no-iterator": [2], //disallow usage of __iterator__ property
    "no-labels": [2], //disallow use of labeled statements
    "no-lone-blocks": [2], //disallow unnecessary nested blocks
    "no-loop-func": [2], //disallow creation of functions within loops
    "no-magic-numbers": [0], //disallow the use of magic numbers
    "no-multi-spaces": [0], //disallow use of multiple spaces
    "no-multi-str": [2], //disallow use of multiline strings
    "no-native-reassign": [0], //disallow reassignments of native objects
    "no-new": [0], //disallow use of the new operator when not part of an assignment or comparison
    "no-new-func": [2], //disallow use of new operator for Function object
    "no-new-wrappers": [2], //disallows creating new instances of String,Number, and Boolean
    "no-octal": [2], //disallow use of octal literals (recommended)
    "no-octal-escape": [2], //disallow use of octal escape sequences in string literals, such as var foo = "Copyright \251";
    "no-param-reassign": [2], //disallow reassignment of function parameters
    "no-proto": [2], //disallow usage of __proto__ property
    "no-redeclare": [2], //disallow declaring the same variable more than once (recommended)
    "no-return-assign": [2], //disallow use of assignment in return statement
    "no-script-url": [2], //disallow use of javascript urls.
    "no-self-assign": [2], //disallow assignments where both sides are exactly the same
    "no-self-compare": [1], //disallow comparisons where both sides are exactly the same
    "no-sequences": [2], //disallow use of the comma operator
    "no-throw-literal": [2], //restrict what can be thrown as an exception
    "no-unmodified-loop-condition": [2], //disallow unmodified conditions of loops
    "no-unused-expressions": [2], //disallow usage of expressions in statement position
    "no-unused-labels": [2], //disallow unused labels
    "no-useless-call": [2], //disallow unnecessary .call() and .apply()
    "no-useless-concat": [2], //disallow unnecessary concatenation of literals or template literals
    "no-useless-escape": [2], //disallow unnecessary escape characters
    "no-void": [0], //disallow use of the void operator
    "no-warning-comments": [0], //disallow usage of configurable warning terms in comments //e.g. TODO or FIXME
    "no-with": [0], //disallow use of the with statement
    "radix": [0], //require use of the second argument for parseInt()
    "vars-on-top": [0], //require declaration of all vars at the top of their containing scope
    "wrap-iife": [2, "inside"], //require immediate function invocation to be wrapped in parentheses
    "yoda": [2], //require or disallow Yoda conditions

    //Strict Mode
    //These rules relate to using strict mode.

    "strict": [0], //controls location of Use Strict Directives

    //Variables
    //These rules have to do with variable declarations.

    "init-declarations": [0], //enforce or disallow variable initializations at definition
    "no-catch-shadow": [2], //disallow the catch clause parameter name being the same as a variable in the outer scope
    "no-delete-var": [2], //disallow deletion of variables (recommended)
    "no-label-var": [2], //disallow labels that share a name with a variable
    "no-restricted-globals": [0], //disallow specified global variables
    "no-shadow": [2], //disallow declaration of variables already declared in the outer scope
    "no-shadow-restricted-names": [2], //disallow shadowing of names such as arguments
    "no-undef": [2], //disallow use of undeclared variables unless mentioned in a /*global */ block (recommended)
    "no-undef-init": [2], //disallow use of undefined when initializing variables
    "no-undefined": [0], //disallow use of undefined variable
    "no-unused-vars": [2], //disallow declaration of variables that are not used in the code (recommended)
    "no-use-before-define": [2], //disallow use of variables before they are defined

    //Node.js and CommonJS
    //These rules are specific to JavaScript running on Node.js or using CommonJS in the browser.

    "callback-return": [1], //enforce return after a callback
    "global-require": [1], //disallow require() outside of the top-level module scope
    "handle-callback-err": [1], //enforce error handling in callbacks
    "no-mixed-requires": [1], //disallow mixing regular variable and require declarations
    "no-new-require": [1], //disallow use of new operator with the require function
    "no-path-concat": [1], //disallow string concatenation with __dirname and __filename
    "no-process-env": [2], //disallow use of process.env
    "no-process-exit": [1], //disallow process.exit()
    "no-restricted-modules": [1], //restrict usage of specified node modules
    "no-sync": [1], //disallow use of synchronous methods

    //Stylistic Issues
    //These rules are purely matters of style and are quite subjective.

    "array-bracket-spacing": [2, "never"], //enforce spacing inside array brackets
    "block-spacing": [2, "always"], //disallow or enforce spaces inside of single line blocks
    "brace-style": [2], //enforce one true brace style
    "camelcase": [2], //require camel case names
    "comma-spacing": [2], //enforce spacing before and after comma
    "comma-style": [2], //enforce one true comma style
    "computed-property-spacing": [2], //require or disallow padding inside computed properties
    "consistent-this": [2, "self"], //enforce consistent naming when capturing the current execution context
    "eol-last": [2], //enforce newline at the end of file, with no multiple empty lines
    "func-names": [0], //require function expressions to have a name
    "func-style": [0], //enforce use of function declarations or expressions
    "id-blacklist": [2], //blacklist certain identifiers to prevent them being used
    "id-length": [0], //this option enforces minimum and maximum identifier lengths (variable names, property names etc.)
    "id-match": [0], //require identifiers to match the provided regular expression
    "indent": [2, 2], //specify tab or space width for your code
    "jsx-quotes": [2, "prefer-double"], //specify whether double or single quotes should be used in JSX attributes
    "key-spacing": [2], //enforce spacing between keys and values in object literal properties
    "keyword-spacing": [2], //enforce spacing before and after keywords
    "linebreak-style": [0], //disallow mixed 'LF' and 'CRLF' as linebreaks
    "lines-around-comment": [0], //enforce empty lines around comments
    "max-depth": [0], //enforce a maximum depth that blocks can be nested
    "max-len": [0], //enforce a maximum line length
    "max-lines": [0], //enforce a maximum depth that callbacks can be nested
    "max-nested-callbacks": [0], //enforce a maximum depth that callbacks can be nested
    "max-params": [0], //enforce a maximum number of parameters in function definitions
    "max-statements": [0], //enforce a maximum number of statements allowed in function blocks
    "max-statements-per-line": [0, {
      "max": 2
    }], //enforce a maximum number of statements allowed per line
    "new-cap": [2], //require a capital letter for constructors
    "new-parens": [2], //disallow the omission of parentheses when invoking a constructor with no arguments
    "newline-after-var": [2], //require or disallow an empty newline after variable declarations
    "newline-before-return": [0], //require an empty line before return statements
    "newline-per-chained-call": [0], //enforce newline after each call when chaining the calls
    "no-array-constructor": [2], //disallow use of the Array constructor
    "no-bitwise": [2], //disallow bitwise operators
    "no-continue": [2], //disallow use of the continue statement
    "no-inline-comments": [0], //disallow comments inline after code
    "no-lonely-if": [2], //disallow if as the only statement in an else block
    "no-mixed-operators": [2], //disallow mixes of different operators
    "no-mixed-spaces-and-tabs": [2], //disallow mixed spaces and tabs for indentation (recommended)
    "no-multiple-empty-lines": [2], //disallow multiple empty lines
    "no-nested-ternary": [2], //disallow nested ternary expressions
    "no-negated-condition": [2], //disallow negated conditions
    "no-new-object": [2], //disallow the use of the Object constructor
    "no-plusplus": [0], //disallow the unary operators ++ and --
    "no-restricted-syntax": [2], //disallow use of certain syntax in code
    "no-spaced-func": [2], //disallow space between function identifier and application
    "no-ternary": [0], //disallow the use of ternary operators
    "no-trailing-spaces": [2], //disallow trailing whitespace at the end of lines
    "no-underscore-dangle": [0], //disallow dangling underscores in identifiers
    "no-unneeded-ternary": [2], //disallow the use of ternary operators when a simpler alternative exists
    "no-whitespace-before-property": [2], //disallow whitespace before properties
    "object-curly-newline": [0], //require or disallow line breaks inside braces
    "object-curly-spacing": [0], //require or disallow padding inside curly braces
    "object-property-newline": [2, {
      "allowMultiplePropertiesPerLine": true
    }], //enforce placing object properties on separate lines
    "one-var": [0], //require or disallow one variable declaration per function
    "one-var-declaration-per-line": [2, "always"], //require or disallow an newline around variable declarations
    "operator-assignment": [0], //require assignment operator shorthand where possible or prohibit it entirely
    "operator-linebreak": [2, "after"], //enforce operators to be placed before or after line breaks
    "padded-blocks": [0], //enforce padding within blocks
    "quote-props": [0], //require quotes around object literal property names
    "quotes": [2, "single"], //specify whether backticks, double or single quotes should be used (fixable)
    "require-jsdoc": [0], //Require JSDoc comment
    "semi-spacing": [2], //enforce spacing before and after semicolons
    "sort-imports": [0], //sort import declarations within module
    "semi": [2, "always"], //require or disallow use of semicolons instead of ASI (fixable)
    "sort-vars": [0], //sort variables within the same declaration block
    "space-before-blocks": [2], //require or disallow a space before blocks
    "space-before-function-paren": [0], //require or disallow a space before function opening parenthesis
    "space-in-parens": [0], //require or disallow spaces inside parentheses
    "space-infix-ops": [2], //require spaces around operators
    "space-unary-ops": [2], //require or disallow spaces before/after unary operators
    "spaced-comment": [0], //require or disallow a space immediately following the // or /* in a comment
    "wrap-regex": [2], //require regex literals to be wrapped in parentheses

  }

}



```

</details>

**What did you do? Please include the actual source code causing the issue.**
Auto fix `no-undef-init` which changes behavior of code

<!-- Paste the source code below: -->
```js
function fun() {
  for (var p in [0, 1, 2]) {
    var selected = undefined; // auto fix will remove `= undefined`

    for (var i in [0, 1, 2]) {
      if (!selected) {
        console.log('selected');
      }
      selected = i;
    }
  }
}

fun();

```

**What did you expect to happen?**
Auto fix should not fix this part as it changes behavior of code.

**What actually happened? Please include the actual, raw output from ESLint.**
Before fix, the code logs 3 times `'selected'`; after fix, the code only logs 1 time.


Pull request description:
Fix: remove autofix for var undef inits (fixes #9231)

**What is the purpose of this pull request? (put an "X" next to item)**

[X ] Other, please explain: Remove autofixing to no-undef-init rule, particularly for var declarations


**What changes did you make? (Give an overview)**


**Is there anything you'd like reviewers to focus on?**
1. To the point in #9231 about not using let: Using let looks like it still works, so I want to make sure I understand.
```
function fun() {
  for (var p in [0, 1, 2]) {
    let selected = undefined;// auto fix will remove `= undefined`

    for (var i in [0, 1, 2]) {
      if (!selected) {
        console.log('selected');
      }
      selected = i;
    }
  }
}

fun();
```
2. Is it okay to keep as separate if? I didn't include in the same if as line 50 since the inner comment wouldn't make sense.
3. I am checking node.parent.kind because it looks to distinguish between var and let

Patch:
diff --git a/docs/rules/id-length.md b/docs/rules/id-length.md
index b63a88b08..a28407fec 100644
--- a/docs/rules/id-length.md
+++ b/docs/rules/id-length.md
@@ -192,7 +192,7 @@ data["y"] = 3;  // excused because of calculated property access
 Examples of **incorrect** code for this rule with the `{ "max": 10 }` option:
 
 ```js
-/*eslint id-length: ["error", { "max": "10" }]*/
+/*eslint id-length: ["error", { "max": 10 }]*/
 /*eslint-env es6*/
 
 var reallyLongVarName = 5;
@@ -210,7 +210,7 @@ try {
 Examples of **correct** code for this rule with the `{ "max": 10 }` option:
 
 ```js
-/*eslint id-length: ["error", { "max": "10" }]*/
+/*eslint id-length: ["error", { "max": 10 }]*/
 /*eslint-env es6*/
 
 var varName = 5;
diff --git a/docs/rules/no-restricted-globals.md b/docs/rules/no-restricted-globals.md
index c9df9d339..e3d612412 100644
--- a/docs/rules/no-restricted-globals.md
+++ b/docs/rules/no-restricted-globals.md
@@ -77,7 +77,7 @@ Examples of **incorrect** code for a sample `"event"` global variable name, alon
 
 ```js
 /*global event*/
-/* eslint no-restricted-globals: [{ name: "error", message: "Use local parameter instead." }] */
+/* eslint no-restricted-globals: ["error", { name: "error", message: "Use local parameter instead." }] */
 
 function onClick() {
     console.log(event);    // Unexpected global variable 'event'. Use local parameter instead.
diff --git a/lib/rules/newline-per-chained-call.js b/lib/rules/newline-per-chained-call.js
index 613429d13..356c4baf3 100644
--- a/lib/rules/newline-per-chained-call.js
+++ b/lib/rules/newline-per-chained-call.js
@@ -19,7 +19,7 @@ module.exports = {
             category: "Stylistic Issues",
             recommended: false
         },
-
+        fixable: "whitespace",
         schema: [{
             type: "object",
             properties: {
@@ -40,6 +40,18 @@ module.exports = {
 
         const sourceCode = context.getSourceCode();
 
+        /**
+         * Get the prefix of a given MemberExpression node.
+         * If the MemberExpression node is a computed value it returns a
+         * left bracket. If not it returns a period.
+         *
+         * @param  {ASTNode} node - A MemberExpression node to get
+         * @returns {string} The prefix of the node.
+         */
+        function getPrefix(node) {
+            return node.computed ? "[" : ".";
+        }
+
         /**
          * Gets the property text of a given MemberExpression node.
          * If the text is multiline, this returns only the first line.
@@ -48,7 +60,7 @@ module.exports = {
          * @returns {string} The property text of the node.
          */
         function getPropertyText(node) {
-            const prefix = node.computed ? "[" : ".";
+            const prefix = getPrefix(node);
             const lines = sourceCode.getText(node.property).split(astUtils.LINEBREAK_MATCHER);
             const suffix = node.computed && lines.length === 1 ? "]" : "";
 
@@ -70,13 +82,18 @@ module.exports = {
                     parent = parent.callee.object;
                 }
 
-                if (depth > ignoreChainWithDepth && callee.property.loc.start.line === callee.object.loc.end.line) {
+                if (depth > ignoreChainWithDepth && astUtils.isTokenOnSameLine(callee.object, callee.property)) {
                     context.report({
                         node: callee.property,
                         loc: callee.property.loc.start,
                         message: "Expected line break before `{{callee}}`.",
                         data: {
                             callee: getPropertyText(callee)
+                        },
+                        fix(fixer) {
+                            const firstTokenAfterObject = sourceCode.getTokenAfter(callee.object, astUtils.isNotClosingParenToken);
+
+                            return fixer.insertTextBefore(firstTokenAfterObject, "\n");
                         }
                     });
                 }
diff --git a/lib/rules/no-undef-init.js b/lib/rules/no-undef-init.js
index 9df40e9ce..7e58f55a6 100644
--- a/lib/rules/no-undef-init.js
+++ b/lib/rules/no-undef-init.js
@@ -43,6 +43,10 @@ module.exports = {
                         message: "It's not necessary to initialize '{{name}}' to undefined.",
                         data: { name },
                         fix(fixer) {
+                            if (node.parent.kind === "var") {
+                                return null;
+                            }
+
                             if (node.id.type === "ArrayPattern" || node.id.type === "ObjectPattern") {
 
                                 // Don't fix destructuring assignment to `undefined`.


Test patch:
diff --git a/tests/lib/rules/newline-per-chained-call.js b/tests/lib/rules/newline-per-chained-call.js
index 232aafed6..ada18a70b 100644
--- a/tests/lib/rules/newline-per-chained-call.js
+++ b/tests/lib/rules/newline-per-chained-call.js
@@ -28,6 +28,7 @@ ruleTester.run("newline-per-chained-call", rule, {
     }],
     invalid: [{
         code: "_\n.chain({}).map(foo).filter(bar).value();",
+        output: "_\n.chain({}).map(foo)\n.filter(bar)\n.value();",
         errors: [{
             message: "Expected line break before `.filter`."
         }, {
@@ -35,26 +36,31 @@ ruleTester.run("newline-per-chained-call", rule, {
         }]
     }, {
         code: "_\n.chain({})\n.map(foo)\n.filter(bar).value();",
+        output: "_\n.chain({})\n.map(foo)\n.filter(bar)\n.value();",
         errors: [{
             message: "Expected line break before `.value`."
         }]
     }, {
         code: "a().b().c().e.d()",
+        output: "a().b()\n.c().e.d()",
         errors: [{
             message: "Expected line break before `.c`."
         }]
     }, {
         code: "a.b.c().e().d()",
+        output: "a.b.c().e()\n.d()",
         errors: [{
             message: "Expected line break before `.d`."
         }]
     }, {
         code: "_.chain({}).map(a).value(); ",
+        output: "_.chain({}).map(a)\n.value(); ",
         errors: [{
             message: "Expected line break before `.value`."
         }]
     }, {
         code: "var a = m1.m2();\n var b = m1.m2().m3().m4().m5();",
+        output: "var a = m1.m2();\n var b = m1.m2().m3()\n.m4()\n.m5();",
         errors: [{
             message: "Expected line break before `.m4`."
         }, {
@@ -62,11 +68,13 @@ ruleTester.run("newline-per-chained-call", rule, {
         }]
     }, {
         code: "var a = m1.m2();\n var b = m1.m2().m3()\n.m4().m5();",
+        output: "var a = m1.m2();\n var b = m1.m2().m3()\n.m4()\n.m5();",
         errors: [{
             message: "Expected line break before `.m5`."
         }]
     }, {
         code: "var a = m1().m2\n.m3().m4().m5().m6().m7();",
+        output: "var a = m1().m2\n.m3().m4().m5()\n.m6()\n.m7();",
         options: [{
             ignoreChainWithDepth: 3
         }],
@@ -105,6 +113,37 @@ ruleTester.run("newline-per-chained-call", rule, {
             "    // Do something with error.",
             "}).end();"
         ].join("\n"),
+        output: [
+            "http.request({",
+            "    // Param",
+            "    // Param",
+            "    // Param",
+            "}).on('response', function(response) {",
+            "    // Do something with response.",
+            "    // Do something with response.",
+            "    // Do something with response.",
+            "    // Do something with response.",
+            "    // Do something with response.",
+            "    // Do something with response.",
+            "    // Do something with response.",
+            "    // Do something with response.",
+            "    // Do something with response.",
+            "    // Do something with response.",
+            "})",
+            ".on('error', function(error) {",
+            "    // Do something with error.",
+            "    // Do something with error.",
+            "    // Do something with error.",
+            "    // Do something with error.",
+            "    // Do something with error.",
+            "    // Do something with error.",
+            "    // Do something with error.",
+            "    // Do something with error.",
+            "    // Do something with error.",
+            "    // Do something with error.",
+            "})",
+            ".end();"
+        ].join("\n"),
         errors: [{
             message: "Expected line break before `.on`."
         }, {
@@ -116,6 +155,13 @@ ruleTester.run("newline-per-chained-call", rule, {
             "    'method3' :",
             "    'method4']()"
         ].join("\n"),
+        output: [
+            "anObject.method1().method2()",
+            "['method' + n]()",
+            "[aCondition ?",
+            "    'method3' :",
+            "    'method4']()"
+        ].join("\n"),
         errors: [{
             message: "Expected line break before `['method' + n]`."
         }, {
@@ -123,8 +169,28 @@ ruleTester.run("newline-per-chained-call", rule, {
         }]
     }, {
         code: "foo.bar()['foo' + \u2029 + 'bar']()",
+        output: "foo.bar()\n['foo' + \u2029 + 'bar']()",
         options: [{ ignoreChainWithDepth: 1 }],
         errors: [{ message: "Expected line break before `['foo' + `." }]
+    }, {
+        code: "foo.bar()[(biz)]()",
+        output: "foo.bar()\n[(biz)]()",
+        options: [{ ignoreChainWithDepth: 1 }],
+        errors: [{ message: "Expected line break before `[biz]`." }]
+    }, {
+        code: "(foo).bar().biz()",
+        output: "(foo).bar()\n.biz()",
+        options: [{ ignoreChainWithDepth: 1 }],
+        errors: [{ message: "Expected line break before `.biz`." }]
+    }, {
+        code: "foo.bar(). /* comment */ biz()",
+        output: "foo.bar()\n. /* comment */ biz()",
+        options: [{ ignoreChainWithDepth: 1 }],
+        errors: [{ message: "Expected line break before `.biz`." }]
+    }, {
+        code: "foo.bar() /* comment */ .biz()",
+        output: "foo.bar() /* comment */ \n.biz()",
+        options: [{ ignoreChainWithDepth: 1 }],
+        errors: [{ message: "Expected line break before `.biz`." }]
     }]
-
 });
diff --git a/tests/lib/rules/no-undef-init.js b/tests/lib/rules/no-undef-init.js
index 2d44e1656..dfd45e008 100644
--- a/tests/lib/rules/no-undef-init.js
+++ b/tests/lib/rules/no-undef-init.js
@@ -27,17 +27,17 @@ ruleTester.run("no-undef-init", rule, {
     invalid: [
         {
             code: "var a = undefined;",
-            output: "var a;",
+            output: null,
             errors: [{ message: "It's not necessary to initialize 'a' to undefined.", type: "VariableDeclarator" }]
         },
         {
             code: "var a = undefined, b = 1;",
-            output: "var a, b = 1;",
+            output: null,
             errors: [{ message: "It's not necessary to initialize 'a' to undefined.", type: "VariableDeclarator" }]
         },
         {
             code: "var a = 1, b = undefined, c = 5;",
-            output: "var a = 1, b, c = 5;",
+            output: null,
             errors: [{ message: "It's not necessary to initialize 'b' to undefined.", type: "VariableDeclarator" }]
         },
         {
@@ -51,6 +51,47 @@ ruleTester.run("no-undef-init", rule, {
             output: null,
             parserOptions: { ecmaVersion: 6 },
             errors: [{ message: "It's not necessary to initialize '{a}' to undefined.", type: "VariableDeclarator" }]
+        },
+        {
+            code: "for(var i in [1,2,3]){var a = undefined; for(var j in [1,2,3]){}}",
+            output: null,
+            errors: [{ message: "It's not necessary to initialize 'a' to undefined.", type: "VariableDeclarator" }]
+        },
+        {
+            code: "let a = undefined;",
+            output: "let a;",
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{ message: "It's not necessary to initialize 'a' to undefined.", type: "VariableDeclarator" }]
+        },
+        {
+            code: "let a = undefined, b = 1;",
+            output: "let a, b = 1;",
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{ message: "It's not necessary to initialize 'a' to undefined.", type: "VariableDeclarator" }]
+        },
+        {
+            code: "let a = 1, b = undefined, c = 5;",
+            output: "let a = 1, b, c = 5;",
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{ message: "It's not necessary to initialize 'b' to undefined.", type: "VariableDeclarator" }]
+        },
+        {
+            code: "let [a] = undefined;",
+            output: null,
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{ message: "It's not necessary to initialize '[a]' to undefined.", type: "VariableDeclarator" }]
+        },
+        {
+            code: "let {a} = undefined;",
+            output: null,
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{ message: "It's not necessary to initialize '{a}' to undefined.", type: "VariableDeclarator" }]
+        },
+        {
+            code: "for(var i in [1,2,3]){let a = undefined; for(var j in [1,2,3]){}}",
+            output: "for(var i in [1,2,3]){let a; for(var j in [1,2,3]){}}",
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{ message: "It's not necessary to initialize 'a' to undefined.", type: "VariableDeclarator" }]
         }
     ]
 });