fix: Remove configured global variables from GlobalScope#implicit (#19779)

* fix: Remove configured global variables from `GlobalScope#implicit`

Fixes #19766

* update no-implicit-globals

* add tests for optional `implicit` and `implicit.left`

* consistency

Author: mdjermanovic

docs/src/extend/scope-manager-interface.md

@@ -374,7 +374,7 @@ Those members are defined but not used in ESLint.
 | `"CatchClause"`            | `CatchClause`                                                              |
 | `"ClassName"`              | `ClassDeclaration` or `ClassExpression`                                    |
 | `"FunctionName"`           | `FunctionDeclaration` or `FunctionExpression`                              |
-| `"ImplicitGlobalVariable"` | `AssignmentExpression`                                                     |
+| `"ImplicitGlobalVariable"` | `AssignmentExpression` or `ForInStatement` or `ForOfStatement`             |
 | `"ImportBinding"`          | `ImportSpecifier`, `ImportDefaultSpecifier`, or `ImportNamespaceSpecifier` |
 | `"Parameter"`              | `FunctionDeclaration`, `FunctionExpression`, or `ArrowFunctionExpression`  |
 | `"Variable"`               | `VariableDeclarator`                                                       |

lib/languages/js/source-code/source-code.js

@@ -316,6 +316,36 @@ function addDeclaredGlobals(
 
 		return true;
 	});
+
+	/*
+	 * "implicit" contains information about implicit global variables (those created
+	 * implicitly by assigning values to undeclared variables in non-strict code).
+	 * Since we augment the global scope using configuration, we need to remove
+	 * the ones that were added by configuration, as they are either built-in
+	 * or declared elsewhere, therefore not implicit.
+	 * Since the "implicit" property was not documented, first we'll check if it exists
+	 * because it's possible that not all custom scope managers create this property.
+	 * If it exists, we assume it has properties `variables` and `set`. Property
+	 * `left` is considered optional (for example, typescript-eslint's scope manage
+	 * has this property named `leftToBeResolved`).
+	 */
+	const { implicit } = globalScope;
+	if (typeof implicit === "object" && implicit !== null) {
+		implicit.variables = implicit.variables.filter(variable => {
+			const name = variable.name;
+			if (globalScope.set.has(name)) {
+				implicit.set.delete(name);
+				return false;
+			}
+			return true;
+		});
+
+		if (implicit.left) {
+			implicit.left = implicit.left.filter(
+				reference => !globalScope.set.has(reference.identifier.name),
+			);
+		}
+	}
 }
 
 /**

lib/rules/no-implicit-globals.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+const ASSIGNMENT_NODES = new Set([
+	"AssignmentExpression",
+	"ForInStatement",
+	"ForOfStatement",
+]);
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -142,27 +148,37 @@ module.exports = {
 							}
 						}
 					});
-				});
 
-				// Undeclared assigned variables.
-				scope.implicit.variables.forEach(variable => {
-					const scopeVariable = scope.set.get(variable.name);
-					let messageId;
+					if (
+						isReadonlyEslintGlobalVariable &&
+						variable.defs.length === 0
+					) {
+						variable.references.forEach(reference => {
+							if (reference.isWrite() && !reference.isRead()) {
+								let assignmentParent =
+									reference.identifier.parent;
+
+								while (
+									assignmentParent &&
+									!ASSIGNMENT_NODES.has(assignmentParent.type)
+								) {
+									assignmentParent = assignmentParent.parent;
+								}
 
-					if (scopeVariable) {
-						// ESLint global variable
-						if (scopeVariable.writeable) {
-							return;
-						}
-						messageId = "assignmentToReadonlyGlobal";
-					} else {
-						// Reference to an unknown variable, possible global leak.
-						messageId = "globalVariableLeak";
+								report(
+									assignmentParent ?? reference.identifier,
+									"assignmentToReadonlyGlobal",
+								);
+							}
+						});
 					}
+				});
 
+				// Undeclared assigned variables.
+				scope.implicit.variables.forEach(variable => {
 					// def.node is an AssignmentExpression, ForInStatement or ForOfStatement.
 					variable.defs.forEach(def => {
-						report(def.node, messageId);
+						report(def.node, "globalVariableLeak");
 					});
 				});
 			},

tests/lib/languages/js/source-code/source-code.js

@@ -3606,4 +3606,216 @@ describe("SourceCode", () => {
 			assert.isNull(problem.ruleId);
 		});
 	});
+
+	describe("finalize()", () => {
+		it("should remove ECMAScript globals from global scope's `implicit`", () => {
+			const code = "Array = 1; Foo = 1; Promise = 1; Array; Foo; Promise";
+			const ast = espree.parse(code, DEFAULT_CONFIG);
+			const scopeManager = eslintScope.analyze(ast, {
+				ignoreEval: true,
+				ecmaVersion: 6,
+			});
+			const sourceCode = new SourceCode({
+				text: code,
+				ast,
+				scopeManager,
+			});
+
+			sourceCode.applyLanguageOptions({
+				ecmaVersion: 2015,
+			});
+
+			sourceCode.finalize();
+
+			const globalScope = sourceCode.scopeManager.scopes[0];
+			const { implicit } = globalScope;
+
+			assert.deepStrictEqual(
+				[...implicit.set].map(([name]) => name),
+				["Foo"],
+			);
+			assert.deepStrictEqual(
+				implicit.variables.map(({ name }) => name),
+				["Foo"],
+			);
+			assert.deepStrictEqual(
+				implicit.left.map(reference => reference.identifier.name),
+				["Foo", "Foo"],
+			);
+		});
+
+		it("should remove custom globals from global scope's `implicit`", () => {
+			const code = "Bar = 1; Foo = 1; Baz = 1; Bar; Foo; Baz";
+			const ast = espree.parse(code, DEFAULT_CONFIG);
+			const scopeManager = eslintScope.analyze(ast, {
+				ignoreEval: true,
+				ecmaVersion: 6,
+			});
+			const sourceCode = new SourceCode({
+				text: code,
+				ast,
+				scopeManager,
+			});
+
+			sourceCode.applyLanguageOptions({
+				ecmaVersion: 2015,
+				globals: {
+					Bar: "writable",
+					Baz: "readonly",
+				},
+			});
+
+			sourceCode.finalize();
+
+			const globalScope = sourceCode.scopeManager.scopes[0];
+			const { implicit } = globalScope;
+
+			assert.deepStrictEqual(
+				[...implicit.set].map(([name]) => name),
+				["Foo"],
+			);
+			assert.deepStrictEqual(
+				implicit.variables.map(({ name }) => name),
+				["Foo"],
+			);
+			assert.deepStrictEqual(
+				implicit.left.map(reference => reference.identifier.name),
+				["Foo", "Foo"],
+			);
+		});
+
+		it("should remove commonjs globals from global scope's `implicit`", () => {
+			const code =
+				"exports = {}; Foo = 1; require = () => {}; exports; Foo; require";
+			const ast = espree.parse(code, DEFAULT_CONFIG);
+			const scopeManager = eslintScope.analyze(ast, {
+				ignoreEval: true,
+				nodejsScope: true,
+				ecmaVersion: 6,
+			});
+			const sourceCode = new SourceCode({
+				text: code,
+				ast,
+				scopeManager,
+			});
+
+			sourceCode.applyLanguageOptions({
+				ecmaVersion: 2015,
+				sourceType: "commonjs",
+			});
+
+			sourceCode.finalize();
+
+			const globalScope = sourceCode.scopeManager.scopes[0];
+			const { implicit } = globalScope;
+
+			assert.deepStrictEqual(
+				[...implicit.set].map(([name]) => name),
+				["Foo"],
+			);
+			assert.deepStrictEqual(
+				implicit.variables.map(({ name }) => name),
+				["Foo"],
+			);
+			assert.deepStrictEqual(
+				implicit.left.map(reference => reference.identifier.name),
+				["Foo", "Foo"],
+			);
+		});
+
+		it("should remove inline globals from global scope's `implicit`", () => {
+			const code =
+				"/* globals Bar: writable, Baz: readonly */ Bar = 1; Foo = 1; Baz = 1; Bar; Foo; Baz";
+			const ast = espree.parse(code, DEFAULT_CONFIG);
+			const scopeManager = eslintScope.analyze(ast, {
+				ignoreEval: true,
+				ecmaVersion: 6,
+			});
+			const sourceCode = new SourceCode({
+				text: code,
+				ast,
+				scopeManager,
+			});
+
+			sourceCode.applyInlineConfig();
+			sourceCode.finalize();
+
+			const globalScope = sourceCode.scopeManager.scopes[0];
+			const { implicit } = globalScope;
+
+			assert.deepStrictEqual(
+				[...implicit.set].map(([name]) => name),
+				["Foo"],
+			);
+			assert.deepStrictEqual(
+				implicit.variables.map(({ name }) => name),
+				["Foo"],
+			);
+			assert.deepStrictEqual(
+				implicit.left.map(reference => reference.identifier.name),
+				["Foo", "Foo"],
+			);
+		});
+
+		it("should not crash if global scope doesn't have `implicit` property", () => {
+			const code = "Array = 1; Foo = 1; Promise = 1; Array; Foo; Promise";
+			const ast = espree.parse(code, DEFAULT_CONFIG);
+			const scopeManager = eslintScope.analyze(ast, {
+				ignoreEval: true,
+				ecmaVersion: 6,
+			});
+
+			const globalScope = scopeManager.scopes[0];
+			delete globalScope.implicit;
+
+			const sourceCode = new SourceCode({
+				text: code,
+				ast,
+				scopeManager,
+			});
+
+			sourceCode.applyLanguageOptions({
+				ecmaVersion: 2015,
+			});
+
+			// should not throw
+			sourceCode.finalize();
+		});
+
+		it("should not crash if global scope doesn't have `implicit.left` property", () => {
+			const code = "Array = 1; Foo = 1; Promise = 1; Array; Foo; Promise";
+			const ast = espree.parse(code, DEFAULT_CONFIG);
+			const scopeManager = eslintScope.analyze(ast, {
+				ignoreEval: true,
+				ecmaVersion: 6,
+			});
+
+			const globalScope = scopeManager.scopes[0];
+			delete globalScope.implicit.left;
+
+			const sourceCode = new SourceCode({
+				text: code,
+				ast,
+				scopeManager,
+			});
+
+			sourceCode.applyLanguageOptions({
+				ecmaVersion: 2015,
+			});
+
+			// should not throw
+			sourceCode.finalize();
+
+			const { implicit } = globalScope;
+
+			assert.deepStrictEqual(
+				[...implicit.set].map(([name]) => name),
+				["Foo"],
+			);
+			assert.deepStrictEqual(
+				implicit.variables.map(({ name }) => name),
+				["Foo"],
+			);
+		});
+	});
 });