@scriptc/compiler 0.4.8 → 0.4.9

package/dist/node-islands/detect.js

@@ -332,6 +332,86 @@ function isPrototypeFunctionAssignment(left, right) {
         ts.isPropertyAccessExpression(left.expression) &&
         propertyName(left.expression) === "prototype");
 }
+/** A declared name that is not a builtin module value. */
+const NOT_BUILTIN = { builtin: null, cjs: false, createRequire: false };
+function isScopeBoundary(node) {
+    return (isFunctionBoundary(node) ||
+        ts.isArrowFunction(node) ||
+        ts.isSourceFile(node) ||
+        ts.isClassStaticBlockDeclaration(node));
+}
+/** Blocks and statement heads `let`, `const` and class declarations bind
+ * in, in addition to a function or static-block scope. */
+function isBlockBoundary(node) {
+    return (ts.isBlock(node) ||
+        ts.isModuleBlock(node) ||
+        ts.isForStatement(node) ||
+        ts.isForOfStatement(node) ||
+        ts.isForInStatement(node) ||
+        ts.isCaseBlock(node));
+}
+/** The scope a declaration binds its name in. `hoisted` asks for the
+ * enclosing function's scope: `var`, parameters, and a sloppy block-level
+ * function declaration (Annex B.3.2) reach the whole function. */
+function bindingScope(decl, hoisted) {
+    // The name climbs through its binding pattern to the declaration that
+    // hosts it: the declaration kind decides where the name is visible.
+    let host = decl;
+    for (;;) {
+        const parent = host.parent;
+        if (parent === undefined)
+            break;
+        if (ts.isBindingElement(host) ||
+            ts.isObjectBindingPattern(host) ||
+            ts.isArrayBindingPattern(host) ||
+            (ts.isIdentifier(host) &&
+                (ts.isBindingElement(parent) || ts.isVariableDeclaration(parent) || ts.isParameter(parent)))) {
+            host = parent;
+            continue;
+        }
+        break;
+    }
+    // A named function or class expression binds inside itself only.
+    if (ts.isFunctionExpression(host) || ts.isClassExpression(host))
+        return host;
+    // A catch clause's parameter or declaration names a value that exists
+    // only inside the catch block; outside it the name keeps the meaning the
+    // enclosing scope gives it.
+    if (host.parent !== undefined && ts.isCatchClause(host.parent))
+        return host.parent.block;
+    const blockScoped = !hoisted &&
+        (ts.isFunctionDeclaration(host) ||
+            ts.isClassDeclaration(host) ||
+            ts.isEnumDeclaration(host) ||
+            ts.isModuleDeclaration(host) ||
+            (ts.isVariableDeclaration(host) &&
+                (ts.getCombinedNodeFlags(host) & ts.NodeFlags.BlockScoped) !== 0));
+    for (let cur = host.parent; cur !== undefined; cur = cur.parent) {
+        if (isScopeBoundary(cur))
+            return cur;
+        if (blockScoped && isBlockBoundary(cur))
+            return cur;
+    }
+    // Unreachable for a parsed file (a source file is a scope boundary);
+    // declare it at the outermost node so the binding never escapes.
+    let root = host;
+    while (root.parent !== undefined)
+        root = root.parent;
+    return root;
+}
+function scopeDepth(scope) {
+    let depth = 0;
+    for (let cur = scope; cur !== undefined; cur = cur.parent)
+        depth++;
+    return depth;
+}
+function scopeContains(scope, at) {
+    for (let cur = at; cur !== undefined; cur = cur.parent) {
+        if (cur === scope)
+            return true;
+    }
+    return false;
+}
 /** One module's pre-scan. */
 class ModuleScanner {
     sf;
@@ -343,14 +423,11 @@ class ModuleScanner {
      * variables). */
     functions = new Set();
     classes = new Set();
-    /** Local name → the builtin module (or `module.member`) it is bound to. */
-    builtinBindings = new Map();
-    /** Local names bound to a createRequire(...) result. */
-    createdRequires = new Set();
-    /** Local names bound to a builtin module's CommonJS object: require(),
-     * a createRequire'd require's result, a default import, or an alias of
-     * one. Writes through these names are patches of the module object. */
-    cjsBuiltinObjects = new Set();
+    /** Every declaration of a name the scan tracks for builtin identity, by
+     * name: a use resolves the innermost declaration whose scope contains
+     * it, so a parameter or local of the same name masks an outer alias
+     * instead of inheriting its identity. */
+    bindings = new Map();
     /** Members read through a CommonJS builtin object (H3.4). */
     cjsReads = [];
     /** Reads of names the file declares nowhere and no builtin provides: each
@@ -398,26 +475,76 @@ class ModuleScanner {
             ...(member === undefined ? {} : { member }),
         });
     }
-    bindName(name, init) {
+    /** Records that `decl` declares `name` with the identity `value` (null
+     * for a declared name that is not a builtin module value, which still
+     * masks an outer alias of the same name). */
+    recordBinding(name, decl, value, hoisted = false) {
+        const scope = bindingScope(decl, hoisted);
+        const entry = {
+            value: value ?? NOT_BUILTIN,
+            scope,
+            depth: scopeDepth(scope),
+            order: ts.tokenStartOfNode(decl),
+        };
+        const list = this.bindings.get(name);
+        if (list === undefined)
+            this.bindings.set(name, [entry]);
+        else
+            list.push(entry);
+    }
+    /** The binding `name` resolves to at `at`: the innermost declaration
+     * whose scope contains the use. */
+    bindingAt(name, at) {
+        const list = this.bindings.get(name);
+        if (list === undefined)
+            return undefined;
+        let best;
+        for (const entry of list) {
+            if (!scopeContains(entry.scope, at))
+                continue;
+            if (best === undefined ||
+                entry.depth > best.depth ||
+                (entry.depth === best.depth && entry.order > best.order))
+                best = entry;
+        }
+        return best?.value;
+    }
+    /** Whether `name` already has a declaration in the scope `decl` binds in. */
+    hasBindingInScope(name, decl, hoisted) {
+        const list = this.bindings.get(name);
+        if (list === undefined)
+            return false;
+        const scope = bindingScope(decl, hoisted);
+        return list.some((entry) => entry.scope === scope);
+    }
+    bindName(name, init, hoisted = false, identity) {
         if (name === undefined)
             return;
         if (ts.isIdentifier(name)) {
             this.declared.add(name.text);
-            if (init === undefined)
+            if (init === undefined) {
+                // `var fs;` declares the variable again without changing the value
+                // it already holds, so it keeps the identity of the declaration it
+                // shares a scope with instead of masking it as unbound.
+                if (identity === undefined && this.hasBindingInScope(name.text, name, hoisted))
+                    return;
+                this.recordBinding(name.text, name, identity ?? null, hoisted);
                 return;
+            }
             const value = stripWrappers(init);
             if (ts.isFunctionExpression(value) || ts.isArrowFunction(value))
                 this.functions.add(name.text);
             else if (ts.isClassExpression(value))
                 this.classes.add(name.text);
             const bound = this.builtinOf(value);
-            if (bound !== null) {
-                this.builtinBindings.set(name.text, bound);
-                if (!bound.includes(".") && this.isCjsObjectValue(value))
-                    this.cjsBuiltinObjects.add(name.text);
-            }
-            if (ts.isCallExpression(value) && this.isCreateRequireCallee(value.expression))
-                this.createdRequires.add(name.text);
+            const createRequire = ts.isCallExpression(value) && this.isCreateRequireCallee(value.expression);
+            this.recordBinding(name.text, name, bound === null && !createRequire
+                ? null
+                : {
+                    builtin: bound,
+                    cjs: bound !== null && !bound.includes(".") && this.isCjsObjectValue(value),
+                    createRequire,
+                }, hoisted);
             return;
         }
         if (ts.isObjectBindingPattern(name)) {
@@ -430,16 +557,21 @@ class ModuleScanner {
                 if (local !== undefined && ts.isIdentifier(local) && base !== null) {
                     const key = element.propertyName;
                     const member = key !== undefined && ts.isIdentifier(key) ? key.text : local.text;
-                    this.builtinBindings.set(local.text, `${base}.${member}`);
+                    this.bindName(local, undefined, hoisted, {
+                        builtin: `${base}.${member}`,
+                        cjs: false,
+                        createRequire: false,
+                    });
                 }
-                this.bindName(local, undefined);
+                else
+                    this.bindName(local, undefined, hoisted);
             }
             return;
         }
         if (ts.isArrayBindingPattern(name)) {
             for (const element of name.elements.nodes) {
                 if (ts.isBindingElement(element))
-                    this.bindName(element.name, undefined);
+                    this.bindName(element.name, undefined, hoisted);
             }
         }
     }
@@ -447,18 +579,20 @@ class ModuleScanner {
      * createRequire'd require's result of a builtin, or an alias of one. */
     isCjsObjectValue(value) {
         if (ts.isIdentifier(value))
-            return this.cjsBuiltinObjects.has(value.text);
+            return this.bindingAt(value.text, value)?.cjs === true;
         if (!ts.isCallExpression(value))
             return false;
         return (this.isRequireCallee(value.expression) ||
-            (ts.isIdentifier(value.expression) && this.createdRequires.has(value.expression.text)));
+            (ts.isIdentifier(value.expression) &&
+                this.bindingAt(value.expression.text, value.expression)?.createRequire === true));
     }
     /** `require("fs")`, `require("node:util").inherits` → "fs", "util.inherits". */
     builtinOf(node) {
         const value = stripWrappers(node);
         if (ts.isCallExpression(value) &&
             (this.isRequireCallee(value.expression) ||
-                (ts.isIdentifier(value.expression) && this.createdRequires.has(value.expression.text)))) {
+                (ts.isIdentifier(value.expression) &&
+                    this.bindingAt(value.expression.text, value.expression)?.createRequire === true))) {
             const spec = literalText(value.arguments.nodes[0]);
             return spec === null ? null : builtinModuleName(spec);
         }
@@ -468,7 +602,7 @@ class ModuleScanner {
             return base === null || name === null ? null : `${base}.${name}`;
         }
         if (ts.isIdentifier(value))
-            return this.builtinBindings.get(value.text) ?? null;
+            return this.bindingAt(value.text, value)?.builtin ?? null;
         return null;
     }
     isRequireCallee(node) {
@@ -477,7 +611,7 @@ class ModuleScanner {
     isCreateRequireCallee(node) {
         if (ts.isIdentifier(node)) {
             return (node.text === "createRequire" ||
-                this.builtinBindings.get(node.text) === "module.createRequire");
+                this.bindingAt(node.text, node)?.builtin === "module.createRequire");
         }
         return propertyName(node) === "createRequire";
     }
@@ -486,10 +620,12 @@ class ModuleScanner {
             if (ts.isFunctionDeclaration(node) && node.name !== undefined) {
                 this.declared.add(node.name.text);
                 this.functions.add(node.name.text);
+                this.recordBinding(node.name.text, node, null, this.isAnnexBBlockFunction(node) && !this.isStrict(node));
             }
             else if (ts.isClassDeclaration(node) && node.name !== undefined) {
                 this.declared.add(node.name.text);
                 this.classes.add(node.name.text);
+                this.recordBinding(node.name.text, node, null);
             }
             else if ((ts.isInterfaceDeclaration(node) ||
                 ts.isTypeAliasDeclaration(node) ||
@@ -497,6 +633,10 @@ class ModuleScanner {
                 ts.isModuleDeclaration(node)) &&
                 ts.isIdentifier(node.name)) {
                 this.declared.add(node.name.text);
+                // An enum or namespace name is also a value binding; an interface
+                // or type alias is not, and never shadows a value.
+                if (ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node))
+                    this.recordBinding(node.name.text, node, null);
             }
             else if (ts.isTypeParameterDeclaration(node)) {
                 this.declared.add(node.name.text);
@@ -512,6 +652,10 @@ class ModuleScanner {
             }
             else if (ts.isFunctionExpression(node) && node.name !== undefined) {
                 this.declared.add(node.name.text);
+                this.recordBinding(node.name.text, node, null);
+            }
+            else if (ts.isClassExpression(node) && node.name !== undefined) {
+                this.recordBinding(node.name.text, node, null);
             }
             else if (ts.isCatchClause(node) && node.variableDeclaration !== undefined) {
                 this.bindName(node.variableDeclaration.name, undefined);
@@ -535,18 +679,21 @@ class ModuleScanner {
                 if (clause !== undefined) {
                     if (clause.name !== undefined) {
                         this.declared.add(clause.name.text);
-                        if (module !== null) {
-                            this.builtinBindings.set(clause.name.text, module);
-                            // A default import is the CommonJS object (unlike a namespace
-                            // or named import, through which Node refuses writes).
-                            this.cjsBuiltinObjects.add(clause.name.text);
-                        }
+                        this.recordBinding(clause.name.text, clause.name, module === null
+                            ? null
+                            : {
+                                builtin: module,
+                                // A default import is the CommonJS object (unlike a
+                                // namespace or named import, through which Node refuses
+                                // writes).
+                                cjs: true,
+                                createRequire: false,
+                            });
                     }
                     const bindings = clause.namedBindings;
                     if (bindings !== undefined && ts.isNamespaceImport(bindings)) {
                         this.declared.add(bindings.name.text);
-                        if (module !== null)
-                            this.builtinBindings.set(bindings.name.text, module);
+                        this.recordBinding(bindings.name.text, bindings.name, module === null ? null : { builtin: module, cjs: false, createRequire: false });
                     }
                     else if (bindings !== undefined && ts.isNamedImports(bindings)) {
                         for (const element of bindings.elements.nodes) {
@@ -555,8 +702,9 @@ class ModuleScanner {
                             const member = imported !== undefined && ts.isIdentifier(imported)
                                 ? imported.text
                                 : element.name.text;
-                            if (module !== null)
-                                this.builtinBindings.set(element.name.text, `${module}.${member}`);
+                            this.recordBinding(element.name.text, element.name, module === null
+                                ? null
+                                : { builtin: `${module}.${member}`, cjs: false, createRequire: false });
                         }
                     }
                 }
@@ -723,6 +871,14 @@ class ModuleScanner {
             this.visitFunction(node);
         }
     }
+    /** The builtin module whose CommonJS object `value` names, or null when
+     * the binding there holds anything else. */
+    cjsModuleOf(value) {
+        if (!ts.isIdentifier(value))
+            return null;
+        const binding = this.bindingAt(value.text, value);
+        return binding !== undefined && binding.cjs ? binding.builtin : null;
+    }
     /** Records a read of a member of a builtin module's CommonJS object, so
      * a patch installed by an island module can be checked against it
      * (H3.4). The left of an assignment (and a delete or ++/-- target) is a
@@ -730,11 +886,12 @@ class ModuleScanner {
      * so it is recorded as the whole module ("fs.*"). */
     recordCjsRead(node) {
         const root = chainRoot(node);
-        if (root === null || !this.cjsBuiltinObjects.has(root.text))
+        if (root === null)
             return;
-        const module = this.builtinBindings.get(root.text);
-        if (module === undefined)
+        const binding = this.bindingAt(root.text, root);
+        if (binding === undefined || !binding.cjs || binding.builtin === null)
             return;
+        const module = binding.builtin;
         const text = chainText(node);
         const parent = node.parent;
         if (parent !== undefined) {
@@ -841,7 +998,7 @@ class ModuleScanner {
             return;
         }
         if (this.isRequireCallee(callee) ||
-            (ts.isIdentifier(callee) && this.createdRequires.has(callee.text))) {
+            (ts.isIdentifier(callee) && this.bindingAt(callee.text, callee)?.createRequire === true)) {
             if (first !== undefined && !isFoldableSpecifier(first))
                 this.add("R1.2", "dynamic-require", "require() with a computed specifier", call);
             else if (first !== undefined)
@@ -883,7 +1040,7 @@ class ModuleScanner {
             return;
         }
         const root = chainRoot(target);
-        const rootBinding = root === null ? undefined : this.builtinBindings.get(root.text);
+        const rootBinding = root === null ? undefined : (this.bindingAt(root.text, root)?.builtin ?? undefined);
         const resolved = rootBinding !== undefined && root !== null
             ? rootBinding + text.slice(root.text.length)
             : text;
@@ -929,9 +1086,7 @@ class ModuleScanner {
             // A definition on a builtin module's CommonJS object is a patch the
             // code loading that object must see (R2.5, H3.1.4).
             const target = first === undefined ? undefined : stripWrappers(first);
-            const builtin = target !== undefined && ts.isIdentifier(target) && this.cjsBuiltinObjects.has(target.text)
-                ? (this.builtinBindings.get(target.text) ?? null)
-                : null;
+            const builtin = target === undefined ? null : this.cjsModuleOf(target);
             if (builtin !== null) {
                 const key = literalText(args[1] === undefined ? undefined : stripWrappers(args[1]));
                 this.add("R2.5", "builtin-patch", `'${text}()' on the builtin module '${builtin}'`, call, key === null ? `${builtin}.*` : `${builtin}.${key}`);
@@ -945,8 +1100,8 @@ class ModuleScanner {
         // literal key is a patch (R2.5, H3.1.4).
         if (text === "Object.assign" && this.isGlobal("Object") && first !== undefined) {
             const target = stripWrappers(first);
-            if (ts.isIdentifier(target) && this.cjsBuiltinObjects.has(target.text)) {
-                const builtin = this.builtinBindings.get(target.text) ?? null;
+            {
+                const builtin = this.cjsModuleOf(target);
                 if (builtin !== null) {
                     const source = args.length === 2 ? stripWrappers(args[1]) : undefined;
                     const keys = source !== undefined && ts.isObjectLiteralExpression(source)
@@ -1075,7 +1230,8 @@ class ModuleScanner {
         }
         if (root === null)
             return;
-        const binding = this.builtinBindings.get(root.text);
+        const resolvedBinding = this.bindingAt(root.text, root);
+        const binding = resolvedBinding?.builtin ?? undefined;
         // Module internals: Module._load = …, Module.prototype.require = …
         if (text !== null) {
             const resolved = binding !== undefined ? binding + text.slice(root.text.length) : text;
@@ -1109,7 +1265,7 @@ class ModuleScanner {
             if (!this.allowedWrite(member)) {
                 // A write through a builtin module's CommonJS object patches that
                 // object; only code sharing Node's builtin can see it (H3.1).
-                const patch = this.cjsBuiltinObjects.has(root.text);
+                const patch = resolvedBinding?.cjs === true;
                 this.add("R2.5", patch ? "builtin-patch" : "builtin-write", `a ${what} of the builtin module member '${member}'`, node, patch ? member : undefined);
             }
             return;