diff --git a/lib/source-code/source-code.js b/lib/source-code/source-code.js
index c7df1aff508..b46fd9ba34d 100644
--- a/lib/source-code/source-code.js
+++ b/lib/source-code/source-code.js
@@ -420,9 +420,10 @@ class SourceCode extends TokenStore {
      * @public
      */
     isSpaceBetweenTokens(first, second) {
+        const finalToken = (this.getFirstToken(second) || second);
         let currentToken = this.getLastToken(first) || first;
 
-        while (currentToken !== (this.getFirstToken(second) || second)) {
+        while (currentToken !== finalToken) {
             const nextToken = this.getTokenAfter(currentToken, { includeComments: true });
 
             if (/\s/u.test(this.text.slice(currentToken.range[1], nextToken.range[0]))) {
diff --git a/tests/lib/source-code/source-code.js b/tests/lib/source-code/source-code.js
index ef9198c81bb..c7d67c70557 100644
--- a/tests/lib/source-code/source-code.js
+++ b/tests/lib/source-code/source-code.js
@@ -1790,193 +1790,201 @@ describe("SourceCode", () => {
     });
 
     describe("isSpaceBetweenTokens()", () => {
-        leche.withData([
-            ["let foo", true],
-            ["let  foo", true],
-            ["let /**/ foo", true],
-            ["let/**/foo", false],
-            ["let/*\n*/foo", false]
-        ], (code, expected) => {
-            it("should return true when there is at least one whitespace character between two tokens", () => {
-                const ast = espree.parse(code, DEFAULT_CONFIG),
-                    sourceCode = new SourceCode(code, ast);
-
-                assert.strictEqual(
-                    sourceCode.isSpaceBetweenTokens(
-                        sourceCode.ast.tokens[0], sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1]
-                    ),
-                    expected
-                );
+        describe("should return true when there is at least one whitespace character between two tokens", () => {
+            leche.withData([
+                ["let foo", true],
+                ["let  foo", true],
+                ["let /**/ foo", true],
+                ["let/**/foo", false],
+                ["let/*\n*/foo", false]
+            ], (code, expected) => {
+                it(code, () => {
+                    const ast = espree.parse(code, DEFAULT_CONFIG),
+                        sourceCode = new SourceCode(code, ast);
+
+                    assert.strictEqual(
+                        sourceCode.isSpaceBetweenTokens(
+                            sourceCode.ast.tokens[0], sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1]
+                        ),
+                        expected
+                    );
+                });
             });
-        });
-
-        leche.withData([
-            ["a+b", false],
-            ["a +b", true],
-            ["a/**/+b", false],
-            ["a/* */+b", false],
-            ["a/**/ +b", true],
-            ["a/**/ /**/+b", true],
-            ["a/* */ /* */+b", true],
-            ["a/**/\n/**/+b", true],
-            ["a/* */\n/* */+b", true],
-            ["a/**/+b/**/+c", false],
-            ["a/* */+b/* */+c", false],
-            ["a/**/+b /**/+c", true],
-            ["a/* */+b /* */+c", true],
-            ["a/**/ +b/**/+c", true],
-            ["a/* */ +b/* */+c", true],
-            ["a/**/+b\t/**/+c", true],
-            ["a/* */+b\t/* */+c", true],
-            ["a/**/\t+b/**/+c", true],
-            ["a/* */\t+b/* */+c", true],
-            ["a/**/+b\n/**/+c", true],
-            ["a/* */+b\n/* */+c", true],
-            ["a/**/\n+b/**/+c", true],
-            ["a/* */\n+b/* */+c", true],
-            ["a/* */+' /**/ '/* */+c", false],
-            ["a/* */+ ' /**/ '/* */+c", true],
-            ["a/* */+' /**/ ' /* */+c", true],
-            ["a/* */+ ' /**/ ' /* */+c", true],
-            ["a/* */+` /*\n*/ `/* */+c", false],
-            ["a/* */+ ` /*\n*/ `/* */+c", true],
-            ["a/* */+` /*\n*/ ` /* */+c", true],
-            ["a/* */+ ` /*\n*/ ` /* */+c", true]
-        ], (code, expected) => {
-            it("should return true when there is at least one whitespace character between two tokens", () => {
-                const ast = espree.parse(code, DEFAULT_CONFIG),
-                    sourceCode = new SourceCode(code, ast);
 
-                assert.strictEqual(
-                    sourceCode.isSpaceBetweenTokens(
-                        sourceCode.ast.tokens[0], sourceCode.ast.tokens[sourceCode.ast.tokens.length - 2]
-                    ),
-                    expected
-                );
+            leche.withData([
+                ["a+b", false],
+                ["a +b", true],
+                ["a/**/+b", false],
+                ["a/* */+b", false],
+                ["a/**/ +b", true],
+                ["a/**/ /**/+b", true],
+                ["a/* */ /* */+b", true],
+                ["a/**/\n/**/+b", true],
+                ["a/* */\n/* */+b", true],
+                ["a/**/+b/**/+c", false],
+                ["a/* */+b/* */+c", false],
+                ["a/**/+b /**/+c", true],
+                ["a/* */+b /* */+c", true],
+                ["a/**/ +b/**/+c", true],
+                ["a/* */ +b/* */+c", true],
+                ["a/**/+b\t/**/+c", true],
+                ["a/* */+b\t/* */+c", true],
+                ["a/**/\t+b/**/+c", true],
+                ["a/* */\t+b/* */+c", true],
+                ["a/**/+b\n/**/+c", true],
+                ["a/* */+b\n/* */+c", true],
+                ["a/**/\n+b/**/+c", true],
+                ["a/* */\n+b/* */+c", true],
+                ["a/* */+' /**/ '/* */+c", false],
+                ["a/* */+ ' /**/ '/* */+c", true],
+                ["a/* */+' /**/ ' /* */+c", true],
+                ["a/* */+ ' /**/ ' /* */+c", true],
+                ["a/* */+` /*\n*/ `/* */+c", false],
+                ["a/* */+ ` /*\n*/ `/* */+c", true],
+                ["a/* */+` /*\n*/ ` /* */+c", true],
+                ["a/* */+ ` /*\n*/ ` /* */+c", true]
+            ], (code, expected) => {
+                it(code, () => {
+                    const ast = espree.parse(code, DEFAULT_CONFIG),
+                        sourceCode = new SourceCode(code, ast);
+
+                    assert.strictEqual(
+                        sourceCode.isSpaceBetweenTokens(
+                            sourceCode.ast.tokens[0], sourceCode.ast.tokens[sourceCode.ast.tokens.length - 2]
+                        ),
+                        expected
+                    );
+                });
             });
         });
 
-        leche.withData([
-            [";let foo = bar", false],
-            [";/**/let foo = bar", false],
-            [";/* */let foo = bar", false],
-            ["; let foo = bar", true],
-            ["; let foo = bar", true],
-            ["; /**/let foo = bar", true],
-            ["; /* */let foo = bar", true],
-            [";/**/ let foo = bar", true],
-            [";/* */ let foo = bar", true],
-            ["; /**/ let foo = bar", true],
-            ["; /* */ let foo = bar", true],
-            [";\tlet foo = bar", true],
-            [";\tlet foo = bar", true],
-            [";\t/**/let foo = bar", true],
-            [";\t/* */let foo = bar", true],
-            [";/**/\tlet foo = bar", true],
-            [";/* */\tlet foo = bar", true],
-            [";\t/**/\tlet foo = bar", true],
-            [";\t/* */\tlet foo = bar", true],
-            [";\nlet foo = bar", true],
-            [";\nlet foo = bar", true],
-            [";\n/**/let foo = bar", true],
-            [";\n/* */let foo = bar", true],
-            [";/**/\nlet foo = bar", true],
-            [";/* */\nlet foo = bar", true],
-            [";\n/**/\nlet foo = bar", true],
-            [";\n/* */\nlet foo = bar", true]
-        ], (code, expected) => {
-            it("should return true when there is at least one whitespace character between a token and a node", () => {
-                const ast = espree.parse(code, DEFAULT_CONFIG),
-                    sourceCode = new SourceCode(code, ast);
-
-                assert.strictEqual(
-                    sourceCode.isSpaceBetweenTokens(
-                        sourceCode.ast.tokens[0], sourceCode.ast.body[sourceCode.ast.body.length - 1]
-                    ),
-                    expected
-                );
+        describe("should return true when there is at least one whitespace character between a token and a node", () => {
+            leche.withData([
+                [";let foo = bar", false],
+                [";/**/let foo = bar", false],
+                [";/* */let foo = bar", false],
+                ["; let foo = bar", true],
+                ["; let foo = bar", true],
+                ["; /**/let foo = bar", true],
+                ["; /* */let foo = bar", true],
+                [";/**/ let foo = bar", true],
+                [";/* */ let foo = bar", true],
+                ["; /**/ let foo = bar", true],
+                ["; /* */ let foo = bar", true],
+                [";\tlet foo = bar", true],
+                [";\tlet foo = bar", true],
+                [";\t/**/let foo = bar", true],
+                [";\t/* */let foo = bar", true],
+                [";/**/\tlet foo = bar", true],
+                [";/* */\tlet foo = bar", true],
+                [";\t/**/\tlet foo = bar", true],
+                [";\t/* */\tlet foo = bar", true],
+                [";\nlet foo = bar", true],
+                [";\nlet foo = bar", true],
+                [";\n/**/let foo = bar", true],
+                [";\n/* */let foo = bar", true],
+                [";/**/\nlet foo = bar", true],
+                [";/* */\nlet foo = bar", true],
+                [";\n/**/\nlet foo = bar", true],
+                [";\n/* */\nlet foo = bar", true]
+            ], (code, expected) => {
+                it(code, () => {
+                    const ast = espree.parse(code, DEFAULT_CONFIG),
+                        sourceCode = new SourceCode(code, ast);
+
+                    assert.strictEqual(
+                        sourceCode.isSpaceBetweenTokens(
+                            sourceCode.ast.tokens[0], sourceCode.ast.body[sourceCode.ast.body.length - 1]
+                        ),
+                        expected
+                    );
+                });
             });
         });
 
-        leche.withData([
-            ["let foo = bar;;", false],
-            ["let foo = bar;;;", false],
-            ["let foo = 1; let bar = 2;;", true],
-            ["let foo = bar;/**/;", false],
-            ["let foo = bar;/* */;", false],
-            ["let foo = bar;;;", false],
-            ["let foo = bar; ;", true],
-            ["let foo = bar; /**/;", true],
-            ["let foo = bar; /* */;", true],
-            ["let foo = bar;/**/ ;", true],
-            ["let foo = bar;/* */ ;", true],
-            ["let foo = bar; /**/ ;", true],
-            ["let foo = bar; /* */ ;", true],
-            ["let foo = bar;\t;", true],
-            ["let foo = bar;\t/**/;", true],
-            ["let foo = bar;\t/* */;", true],
-            ["let foo = bar;/**/\t;", true],
-            ["let foo = bar;/* */\t;", true],
-            ["let foo = bar;\t/**/\t;", true],
-            ["let foo = bar;\t/* */\t;", true],
-            ["let foo = bar;\n;", true],
-            ["let foo = bar;\n/**/;", true],
-            ["let foo = bar;\n/* */;", true],
-            ["let foo = bar;/**/\n;", true],
-            ["let foo = bar;/* */\n;", true],
-            ["let foo = bar;\n/**/\n;", true],
-            ["let foo = bar;\n/* */\n;", true]
-        ], (code, expected) => {
-            it("should return true when there is at least one whitespace character between a node and a token", () => {
-                const ast = espree.parse(code, DEFAULT_CONFIG),
-                    sourceCode = new SourceCode(code, ast);
-
-                assert.strictEqual(
-                    sourceCode.isSpaceBetweenTokens(
-                        sourceCode.ast.body[0], sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1]
-                    ),
-                    expected
-                );
+        describe("should return true when there is at least one whitespace character between a node and a token", () => {
+            leche.withData([
+                ["let foo = bar;;", false],
+                ["let foo = bar;;;", false],
+                ["let foo = 1; let bar = 2;;", true],
+                ["let foo = bar;/**/;", false],
+                ["let foo = bar;/* */;", false],
+                ["let foo = bar;;;", false],
+                ["let foo = bar; ;", true],
+                ["let foo = bar; /**/;", true],
+                ["let foo = bar; /* */;", true],
+                ["let foo = bar;/**/ ;", true],
+                ["let foo = bar;/* */ ;", true],
+                ["let foo = bar; /**/ ;", true],
+                ["let foo = bar; /* */ ;", true],
+                ["let foo = bar;\t;", true],
+                ["let foo = bar;\t/**/;", true],
+                ["let foo = bar;\t/* */;", true],
+                ["let foo = bar;/**/\t;", true],
+                ["let foo = bar;/* */\t;", true],
+                ["let foo = bar;\t/**/\t;", true],
+                ["let foo = bar;\t/* */\t;", true],
+                ["let foo = bar;\n;", true],
+                ["let foo = bar;\n/**/;", true],
+                ["let foo = bar;\n/* */;", true],
+                ["let foo = bar;/**/\n;", true],
+                ["let foo = bar;/* */\n;", true],
+                ["let foo = bar;\n/**/\n;", true],
+                ["let foo = bar;\n/* */\n;", true]
+            ], (code, expected) => {
+                it(code, () => {
+                    const ast = espree.parse(code, DEFAULT_CONFIG),
+                        sourceCode = new SourceCode(code, ast);
+
+                    assert.strictEqual(
+                        sourceCode.isSpaceBetweenTokens(
+                            sourceCode.ast.body[0], sourceCode.ast.tokens[sourceCode.ast.tokens.length - 1]
+                        ),
+                        expected
+                    );
+                });
             });
         });
 
-        leche.withData([
-            ["let foo = bar;let baz = qux;", false],
-            ["let foo = bar;/**/let baz = qux;", false],
-            ["let foo = bar;/* */let baz = qux;", false],
-            ["let foo = bar; let baz = qux;", true],
-            ["let foo = bar; /**/let baz = qux;", true],
-            ["let foo = bar; /* */let baz = qux;", true],
-            ["let foo = bar;/**/ let baz = qux;", true],
-            ["let foo = bar;/* */ let baz = qux;", true],
-            ["let foo = bar; /**/ let baz = qux;", true],
-            ["let foo = bar; /* */ let baz = qux;", true],
-            ["let foo = bar;\tlet baz = qux;", true],
-            ["let foo = bar;\t/**/let baz = qux;", true],
-            ["let foo = bar;\t/* */let baz = qux;", true],
-            ["let foo = bar;/**/\tlet baz = qux;", true],
-            ["let foo = bar;/* */\tlet baz = qux;", true],
-            ["let foo = bar;\t/**/\tlet baz = qux;", true],
-            ["let foo = bar;\t/* */\tlet baz = qux;", true],
-            ["let foo = bar;\nlet baz = qux;", true],
-            ["let foo = bar;\n/**/let baz = qux;", true],
-            ["let foo = bar;\n/* */let baz = qux;", true],
-            ["let foo = bar;/**/\nlet baz = qux;", true],
-            ["let foo = bar;/* */\nlet baz = qux;", true],
-            ["let foo = bar;\n/**/\nlet baz = qux;", true],
-            ["let foo = bar;\n/* */\nlet baz = qux;", true],
-            ["let foo = 1;let foo2 = 2; let foo3 = 3;", true]
-        ], (code, expected) => {
-            it("should return true when there is at least one whitespace character between two nodes", () => {
-                const ast = espree.parse(code, DEFAULT_CONFIG),
-                    sourceCode = new SourceCode(code, ast);
-
-                assert.strictEqual(
-                    sourceCode.isSpaceBetweenTokens(
-                        sourceCode.ast.body[0], sourceCode.ast.body[sourceCode.ast.body.length - 1]
-                    ),
-                    expected
-                );
+        describe("should return true when there is at least one whitespace character between two nodes", () => {
+            leche.withData([
+                ["let foo = bar;let baz = qux;", false],
+                ["let foo = bar;/**/let baz = qux;", false],
+                ["let foo = bar;/* */let baz = qux;", false],
+                ["let foo = bar; let baz = qux;", true],
+                ["let foo = bar; /**/let baz = qux;", true],
+                ["let foo = bar; /* */let baz = qux;", true],
+                ["let foo = bar;/**/ let baz = qux;", true],
+                ["let foo = bar;/* */ let baz = qux;", true],
+                ["let foo = bar; /**/ let baz = qux;", true],
+                ["let foo = bar; /* */ let baz = qux;", true],
+                ["let foo = bar;\tlet baz = qux;", true],
+                ["let foo = bar;\t/**/let baz = qux;", true],
+                ["let foo = bar;\t/* */let baz = qux;", true],
+                ["let foo = bar;/**/\tlet baz = qux;", true],
+                ["let foo = bar;/* */\tlet baz = qux;", true],
+                ["let foo = bar;\t/**/\tlet baz = qux;", true],
+                ["let foo = bar;\t/* */\tlet baz = qux;", true],
+                ["let foo = bar;\nlet baz = qux;", true],
+                ["let foo = bar;\n/**/let baz = qux;", true],
+                ["let foo = bar;\n/* */let baz = qux;", true],
+                ["let foo = bar;/**/\nlet baz = qux;", true],
+                ["let foo = bar;/* */\nlet baz = qux;", true],
+                ["let foo = bar;\n/**/\nlet baz = qux;", true],
+                ["let foo = bar;\n/* */\nlet baz = qux;", true],
+                ["let foo = 1;let foo2 = 2; let foo3 = 3;", true]
+            ], (code, expected) => {
+                it(code, () => {
+                    const ast = espree.parse(code, DEFAULT_CONFIG),
+                        sourceCode = new SourceCode(code, ast);
+
+                    assert.strictEqual(
+                        sourceCode.isSpaceBetweenTokens(
+                            sourceCode.ast.body[0], sourceCode.ast.body[sourceCode.ast.body.length - 1]
+                        ),
+                        expected
+                    );
+                });
             });
         });
     });