@typescript-eslint/scope-manager 8.53.2-alpha.1 → 8.53.2-alpha.10

package/dist/ScopeManager.d.ts

@@ -48,6 +48,12 @@ export declare class ScopeManager {
      *                If `inner` is `true` then this returns the innermost scope.
      */
     acquire(node: TSESTree.Node, inner?: boolean): Scope | null;
+    /**
+     * Adds dynamically created globals to the global scope and resolve their references.
+     * This method is called by ESLint.
+     * @param names Names of the globals to create
+     */
+    addGlobals(names: string[]): void;
     nestBlockScope(node: BlockScope['block']): BlockScope;
     nestCatchScope(node: CatchScope['block']): CatchScope;
     nestClassFieldInitializerScope(node: ClassFieldInitializerScope['block']): ClassFieldInitializerScope;

package/dist/ScopeManager.js

@@ -98,6 +98,14 @@ class ScopeManager {
         }
         return scopes.find(predicate) ?? null;
     }
+    /**
+     * Adds dynamically created globals to the global scope and resolve their references.
+     * This method is called by ESLint.
+     * @param names Names of the globals to create
+     */
+    addGlobals(names) {
+        this.globalScope?.addVariables(names);
+    }
     nestBlockScope(node) {
         (0, assert_1.assert)(this.currentScope);
         return this.nestScope(new scope_1.BlockScope(this, this.currentScope, node));

package/dist/definition/CatchClauseDefinition.d.ts

@@ -1,8 +1,8 @@
 import type { TSESTree } from '@typescript-eslint/types';
 import { DefinitionBase } from './DefinitionBase';
 import { DefinitionType } from './DefinitionType';
-export declare class CatchClauseDefinition extends DefinitionBase<DefinitionType.CatchClause, TSESTree.CatchClause, null, TSESTree.BindingName> {
+export declare class CatchClauseDefinition extends DefinitionBase<DefinitionType.CatchClause, TSESTree.CatchClause, null, TSESTree.Identifier> {
     readonly isTypeDefinition = false;
     readonly isVariableDefinition = true;
-    constructor(name: TSESTree.BindingName, node: CatchClauseDefinition['node']);
+    constructor(name: TSESTree.Identifier, node: CatchClauseDefinition['node']);
 }

package/dist/referencer/Referencer.js

@@ -265,9 +265,8 @@ class Referencer extends Visitor_1.Visitor {
     CatchClause(node) {
         this.scopeManager.nestCatchScope(node);
         if (node.param) {
-            const param = node.param;
-            this.visitPattern(param, (pattern, info) => {
-                this.currentScope().defineIdentifier(pattern, new definition_1.CatchClauseDefinition(param, node));
+            this.visitPattern(node.param, (pattern, info) => {
+                this.currentScope().defineIdentifier(pattern, new definition_1.CatchClauseDefinition(pattern, node));
                 this.referencingDefaultValue(pattern, info.assignments, null, true);
             }, { processRightHandNodes: true });
         }

package/dist/scope/GlobalScope.d.ts

@@ -11,6 +11,7 @@ export declare class GlobalScope extends ScopeBase<ScopeType.global, TSESTree.Pr
 null> {
     private readonly implicit;
     constructor(scopeManager: ScopeManager, block: GlobalScope['block']);
+    addVariables(names: string[]): void;
     close(scopeManager: ScopeManager): Scope | null;
     defineImplicitVariable(name: string, options: ImplicitLibVariableOptions): void;
 }

package/dist/scope/GlobalScope.js

@@ -18,6 +18,24 @@ class GlobalScope extends ScopeBase_1.ScopeBase {
             variables: [],
         };
     }
+    addVariables(names) {
+        for (const name of names) {
+            this.defineVariable(name, this.set, this.variables, null, null);
+            this.implicit.set.delete(name);
+        }
+        const nameSet = new Set(names);
+        for (const reference of this.through) {
+            if (nameSet.has(reference.identifier.name)) {
+                const variable = this.set.get(reference.identifier.name);
+                (0, assert_1.assert)(variable, `Expected variable with name "${reference.identifier.name}" to be specified.`);
+                reference.resolved = variable;
+                variable.references.push(reference);
+            }
+        }
+        this.through = this.through.filter(reference => !nameSet.has(reference.identifier.name));
+        this.implicit.variables = this.implicit.variables.filter(variable => !nameSet.has(variable.name));
+        this.implicit.leftToBeResolved = this.implicit.leftToBeResolved.filter(reference => !nameSet.has(reference.identifier.name));
+    }
     close(scopeManager) {
         (0, assert_1.assert)(this.leftToResolve);
         for (const ref of this.leftToResolve) {
@@ -31,7 +49,9 @@ class GlobalScope extends ScopeBase_1.ScopeBase {
             }
         }
         this.implicit.leftToBeResolved = this.leftToResolve;
-        return super.close(scopeManager);
+        super.close(scopeManager);
+        this.implicit.leftToBeResolved = [...this.through];
+        return null;
     }
     defineImplicitVariable(name, options) {
         this.defineVariable(new variable_1.ImplicitLibVariable(this, name, options), this.set, this.variables, null, null);

package/dist/scope/ScopeBase.d.ts

@@ -59,7 +59,7 @@ export declare abstract class ScopeBase<Type extends ScopeType, Block extends TS
      * The {@link Reference}s that are not resolved with this scope.
      * @public
      */
-    readonly through: Reference[];
+    through: Reference[];
     readonly type: Type;
     /**
      * Reference to the parent {@link Scope}.
@@ -77,8 +77,7 @@ export declare abstract class ScopeBase<Type extends ScopeType, Block extends TS
     readonly variableScope: VariableScope;
     constructor(scopeManager: ScopeManager, type: Type, upperScope: Upper, block: Block, isMethodDefinition: boolean);
     private isVariableScope;
-    private shouldStaticallyCloseForGlobal;
-    close(scopeManager: ScopeManager): Scope | null;
+    close(_scopeManager: ScopeManager): Scope | null;
     shouldStaticallyClose(): boolean;
     /**
      * To override by function scopes.

package/dist/scope/ScopeBase.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScopeBase = void 0;
 const types_1 = require("@typescript-eslint/types");
 const assert_1 = require("../assert");
-const definition_1 = require("../definition");
 const ID_1 = require("../ID");
 const Reference_1 = require("../referencer/Reference");
 const variable_1 = require("../variable");
@@ -60,22 +59,13 @@ function isStrictScope(scope, block, isMethodDefinition) {
     }
     // Search 'use strict' directive.
     for (const stmt of body.body) {
-        if (stmt.type !== types_1.AST_NODE_TYPES.ExpressionStatement) {
+        if (stmt.type !== types_1.AST_NODE_TYPES.ExpressionStatement ||
+            stmt.directive == null) {
             break;
         }
         if (stmt.directive === 'use strict') {
             return true;
         }
-        const expr = stmt.expression;
-        if (expr.type !== types_1.AST_NODE_TYPES.Literal) {
-            break;
-        }
-        if (expr.raw === '"use strict"' || expr.raw === "'use strict'") {
-            return true;
-        }
-        if (expr.value === 'use strict') {
-            return true;
-        }
     }
     return false;
 }
@@ -187,16 +177,6 @@ class ScopeBase {
             /* eslint-enable @typescript-eslint/no-non-null-assertion */
         } while (current);
     };
-    #globalCloseRef = (ref, scopeManager) => {
-        // let/const/class declarations should be resolved statically.
-        // others should be resolved dynamically.
-        if (this.shouldStaticallyCloseForGlobal(ref, scopeManager)) {
-            this.#staticCloseRef(ref);
-        }
-        else {
-            this.#dynamicCloseRef(ref);
-        }
-    };
     #staticCloseRef = (ref) => {
         const resolve = () => {
             const name = ref.identifier.name;
@@ -246,50 +226,18 @@ class ScopeBase {
     isVariableScope() {
         return VARIABLE_SCOPE_TYPES.has(this.type);
     }
-    shouldStaticallyCloseForGlobal(ref, scopeManager) {
-        // On global scope, let/const/class declarations should be resolved statically.
-        const name = ref.identifier.name;
-        const variable = this.set.get(name);
-        if (!variable) {
-            return false;
-        }
-        // variable exists on the scope
-        // in module mode, we can statically resolve everything, regardless of its decl type
-        if (scopeManager.isModule()) {
-            return true;
-        }
-        // in script mode, only certain cases should be statically resolved
-        // Example:
-        // a `var` decl is ignored by the runtime if it clashes with a global name
-        // this means that we should not resolve the reference to the variable
-        const defs = variable.defs;
-        return (defs.length > 0 &&
-            defs.every(def => {
-                if (def.type === definition_1.DefinitionType.Variable && def.parent.kind === 'var') {
-                    return false;
-                }
-                return true;
-            }));
-    }
-    close(scopeManager) {
-        let closeRef;
-        if (this.shouldStaticallyClose()) {
-            closeRef = this.#staticCloseRef;
-        }
-        else if (this.type !== 'global') {
-            closeRef = this.#dynamicCloseRef;
-        }
-        else {
-            closeRef = this.#globalCloseRef;
-        }
+    close(_scopeManager) {
+        const closeRef = this.shouldStaticallyClose()
+            ? this.#staticCloseRef
+            : this.#dynamicCloseRef;
         // Try Resolving all references in this scope.
         (0, assert_1.assert)(this.leftToResolve);
-        this.leftToResolve.forEach(ref => closeRef(ref, scopeManager));
+        this.leftToResolve.forEach(ref => closeRef(ref));
         this.leftToResolve = null;
         return this.upper;
     }
     shouldStaticallyClose() {
-        return !this.#dynamic;
+        return !this.#dynamic || this.type === 'global';
     }
     /**
      * To override by function scopes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/scope-manager",
-  "version": "8.53.2-alpha.1",
+  "version": "8.53.2-alpha.10",
   "description": "TypeScript scope analyser for ESLint",
   "files": [
     "dist",
@@ -47,11 +47,11 @@
     "typecheck": "yarn run -BT nx typecheck"
   },
   "dependencies": {
-    "@typescript-eslint/types": "8.53.2-alpha.1",
-    "@typescript-eslint/visitor-keys": "8.53.2-alpha.1"
+    "@typescript-eslint/types": "8.53.2-alpha.10",
+    "@typescript-eslint/visitor-keys": "8.53.2-alpha.10"
   },
   "devDependencies": {
-    "@typescript-eslint/typescript-estree": "8.53.2-alpha.1",
+    "@typescript-eslint/typescript-estree": "8.53.2-alpha.10",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/pretty-format": "^3.2.4",
     "eslint": "*",