monkeypatchlist 0.0.0-stage → 0.1.0

package/dist/packages/analysis/lib/rewritten-deletes.js

@@ -0,0 +1,142 @@
+// A delete that is always rewritten (§3). A delete that the same function follows, on every path, with a define or
+// assign of the same slot gives no finding of its own: the later write's finding stands, and the delete leaves only a
+// trace `note`. So core-js's `defineBuiltIn(Array.prototype, wellKnownSymbol('iterator'), …)`, which runs
+// `try { if (!options.unsafe) delete O[key] } catch {}` and then `O[key] = value` or `definePropertyModule.f(O, key, …)`,
+// gives one `Array.prototype.@@iterator` `replace`. A delete that isn't always rewritten stays a `delete` finding.
+//
+// This module decides "on every path", from the syntax of the function the delete is in: which nodes write the slot
+// (an assignment, or a call whose instantiation writes it) is the caller's to say.
+import { walkTree } from "./ast.js";
+import { isFunction } from "./summaries.js";
+/** Statements that may leave the code after them: control leaves before it runs. */
+const leaving = new Set(['ReturnStatement', 'ThrowStatement', 'BreakStatement', 'ContinueStatement']);
+/**
+ * Whether every path from the delete `site` to the end of its function, `fn`, runs one of the nodes `writes` accepts,
+ * in `fn`'s own code, before control can leave. `parentOf` gives each node's parent.
+ */
+export function alwaysRewritten(site, fn, writes, parentOf) {
+    /** Whether evaluating `expression` always runs a write, before anything that could skip it. */
+    const expressionWrites = (expression) => {
+        if (writes(expression))
+            return true;
+        switch (expression.type) {
+            case 'SequenceExpression':
+                return expression['expressions'].some(expressionWrites);
+            case 'ConditionalExpression':
+                return (expressionWrites(expression['test']) ||
+                    (expressionWrites(expression['consequent']) && expressionWrites(expression['alternate'])));
+            case 'LogicalExpression':
+                return expressionWrites(expression['left']);
+            case 'AssignmentExpression':
+                return expression['operator'] === '=' && expressionWrites(expression['right']);
+            case 'ParenthesizedExpression':
+            case 'ChainExpression':
+                return expressionWrites(expression['expression']);
+            default:
+                return false;
+        }
+    };
+    /** Whether running `statement` always runs a write before control can leave it. */
+    const statementWrites = (statement) => {
+        switch (statement.type) {
+            case 'ExpressionStatement':
+                return expressionWrites(statement['expression']);
+            case 'ReturnStatement':
+            case 'ThrowStatement': {
+                const argument = statement['argument'];
+                return argument !== null && expressionWrites(argument);
+            }
+            case 'VariableDeclaration':
+                return statement['declarations'].some((declarator) => {
+                    const init = declarator['init'];
+                    return init !== null && expressionWrites(init);
+                });
+            case 'BlockStatement':
+                return listWrites(statement['body'], 0);
+            case 'IfStatement': {
+                const alternate = statement['alternate'];
+                return (expressionWrites(statement['test']) ||
+                    (alternate !== null && statementWrites(statement['consequent']) && statementWrites(alternate)));
+            }
+            case 'TryStatement': {
+                // A write that throws writes nothing, so the handler must write too; a finalizer that writes always does.
+                const handler = statement['handler'];
+                const finalizer = statement['finalizer'];
+                if (finalizer !== null && statementWrites(finalizer))
+                    return true;
+                const block = statementWrites(statement['block']);
+                return block && (handler === null || statementWrites(handler['body']));
+            }
+            default:
+                return false;
+        }
+    };
+    /** Whether running `list` from `from` always runs a write before control can leave it. */
+    const listWrites = (list, from) => {
+        for (let index = from; index < list.length; index++) {
+            const statement = list[index];
+            if (statementWrites(statement))
+                return true;
+            if (mayLeave(statement))
+                return false;
+        }
+        return false;
+    };
+    // Out from the delete: what runs after each node around it, until the function's end.
+    for (let child = site, parent = parentOf(site); parent !== undefined; child = parent, parent = parentOf(parent)) {
+        if (child === fn || isFunction(child))
+            return false;
+        switch (parent.type) {
+            case 'SequenceExpression': {
+                const expressions = parent['expressions'];
+                if (expressions.slice(expressions.indexOf(child) + 1).some(expressionWrites))
+                    return true;
+                break;
+            }
+            case 'BlockStatement':
+            case 'StaticBlock':
+            case 'Program': {
+                const list = parent['body'];
+                if (listWrites(list, list.indexOf(child) + 1))
+                    return true;
+                break;
+            }
+            case 'SwitchCase':
+            case 'SwitchStatement':
+            case 'LabeledStatement':
+            case 'ForStatement':
+            case 'ForInStatement':
+            case 'ForOfStatement':
+            case 'WhileStatement':
+            case 'DoWhileStatement':
+                // What runs after these the walk doesn't follow.
+                return false;
+            case 'TryStatement':
+                // A delete in the `try` block that throws goes to the handler, which must not leave; one in the finalizer or
+                // handler goes on after the statement.
+                if (child === parent['block']) {
+                    const handler = parent['handler'];
+                    if (handler !== null && mayLeave(handler['body']))
+                        return false;
+                }
+                break;
+            default:
+                if (isFunction(parent))
+                    return false;
+        }
+    }
+    return false;
+}
+/** Whether control may leave a statement other than by reaching its end: a `return`, `throw`, `break` or `continue`. */
+function mayLeave(statement) {
+    let found = false;
+    walkTree(statement, {
+        enter(node) {
+            if (found || (node !== statement && isFunction(node)))
+                return false;
+            if (leaving.has(node.type))
+                found = true;
+        },
+    });
+    return found;
+}

package/dist/packages/analysis/lib/scope.d.ts

@@ -0,0 +1,110 @@
+import { type AstNode } from './ast.ts';
+import type { BindingResolver } from './binding.ts';
+import type { GlobalDeclarationKind } from './types.ts';
+/** A declaration that binds a property of the global object (§5). */
+export interface GlobalDeclaration {
+    kind: GlobalDeclarationKind;
+    node: AstNode;
+}
+/** What lies on a name's resolution path that could make it resolve elsewhere (§5 post-pass 3). */
+export interface Taint {
+    /** The `with` statements on the resolution path, in document order. */
+    withs: AstNode[];
+    /** The direct `eval` calls in sloppy functions on the resolution path, in document order. */
+    evals: AstNode[];
+}
+/**
+ * A name that resolves to a property of the global object (§5 Global resolution): either to no declaration at all, or
+ * to a declaration that binds the global object's property.
+ */
+export interface GlobalBinding extends Taint {
+    declaration?: GlobalDeclaration;
+}
+/** A name that resolves to a `const` declaration (§5 Resolver capabilities 1), with the taint between the two. */
+export interface ConstantBinding extends Taint {
+    /** The `const` declaration: a `VariableDeclaration` whose `kind` is `const`. */
+    declaration: AstNode;
+}
+/** How the program relates to the code around it, when it is nested code (§2) or holds some. */
+export interface ScopeOptions {
+    /** The arrow functions grafted in place of literal direct-eval code, whose code runs in its caller's scope. */
+    directEvals?: ReadonlySet<AstNode>;
+    /** For global code: the names the host classic script declares with `let`, `const` or `class` at its top level. */
+    lexicalGlobals?: ReadonlySet<string>;
+    /** Whether the program is eval code, whose top-level `var`s and functions stay its own when it is strict. */
+    evalCode?: boolean;
+    /**
+     * For a link group's program (§6 Link groups): the variable an import binding is, by the declaration the seam gives
+     * the binding and its name. A reference to a linked import resolves to that variable.
+     */
+    imports?: (declaration: AstNode, name: string) => {
+        declaration: AstNode;
+        name: string;
+    } | undefined;
+}
+export interface ScopeRules {
+    /** What a reference resolves to after the post-passes: a property of the global object, or else a local binding. */
+    resolve(id: AstNode): GlobalBinding | 'local';
+    /**
+     * The `const` declaration a reference resolves to after the post-passes, if it resolves to one, with the `with`
+     * statements and the direct evals in sloppy functions between the reference and the declaration (post-pass 3).
+     */
+    constant(id: AstNode): ConstantBinding | undefined;
+    /**
+     * The declaration a reference resolves to after the post-passes, as the seam gives it (§19), or none: a free name, a
+     * name global code sees among the host's top-level lexical declarations, or a name an Annex B var binding hides.
+     */
+    declaration(id: AstNode): AstNode | undefined;
+    /**
+     * The name of the variable a reference resolves to: its own, or for an import binding of a link group, the name the
+     * variable it is has where it is declared (§6 Link groups).
+     */
+    nameOf(id: AstNode): string;
+    /** Whether the code at a UTF-16 offset is strict mode code. */
+    isStrict(offset: number): boolean;
+    /**
+     * For a `VariableDeclaration`, `FunctionDeclaration` or `ClassDeclaration`, how it declares the global object's
+     * members (§3 Declarations in classic scripts), if it does: see `Declared`.
+     */
+    declared(node: AstNode): Declared | undefined;
+}
+/**
+ * How a declaration binds a name of the global object's (§3 Declarations in classic scripts), as ECMA-262's global and
+ * eval declaration instantiation give it:
+ * - `var`: a `var` whose binding is the global object's property, in a classic script or in eval code (direct or
+ *   indirect) that declares its vars there
+ * - `function`: a function declared at the top level of such code
+ * - `block-function`: a block-level function that Annex B gives such a var binding (B.3.2.2, B.3.2.3)
+ * - `let`, `const` and `class`: a lexical declaration at the top level of a classic script, which hides the global
+ *   object's property from bare-name callers. Eval code's are its own.
+ *
+ * `configurable` is the `D` those steps pass: true for eval code, whose bindings can be deleted, and false for a
+ * script. `loop` says a `var` is the head of a `for`-`in` or `for`-`of` loop, which assigns it each iteration.
+ */
+export interface Declared {
+    kind: GlobalDeclarationKind;
+    configurable: boolean;
+    loop?: boolean;
+}
+export declare function scopeRules(program: AstNode, sourceType: 'script' | 'module', bindings: BindingResolver, options?: ScopeOptions): ScopeRules;
+/**
+ * The names a classic script declares lexically at its top level (`let`, `const`, `using`, `class`). They are global
+ * bindings that are not properties of the global object, and global code sees them. A module's are its own.
+ */
+export declare function globalLexicalNames(program: AstNode, sourceType: 'script' | 'module'): ReadonlySet<string>;
+interface LexicalGlobal {
+    name: string;
+    kind: 'let' | 'const' | 'class';
+    id: AstNode;
+}
+/**
+ * A classic script's top-level `let`, `const` and `class` declarations, in document order, each with the identifier it
+ * binds: the names the scan-wide lexical-name check collects (§3 Declarations in classic scripts). A module's are its
+ * own, so it has none.
+ */
+export declare function globalLexicalDeclarations(program: AstNode, sourceType: 'script' | 'module'): LexicalGlobal[];
+/** The names a binding pattern binds. */
+export declare function boundNames(pattern: AstNode): string[];
+/** The identifiers a binding pattern binds, in document order. */
+export declare function boundIdentifiers(pattern: AstNode): AstNode[];
+export {};