monkeypatchlist 0.0.0-stage → 0.1.0

package/dist/packages/analysis/lib/parameter-arguments.d.ts

@@ -0,0 +1,12 @@
+import type { AstNode } from './ast.ts';
+import type { Definitions } from './definitions.ts';
+import type { Position } from './global-object.ts';
+/**
+ * The arguments a parameter `id` takes, each where its call evaluates it, when `id` reads a plain parameter of a function
+ * that a frame of `at` instantiates from listed calls, and nothing in the function reassigns it. Undefined otherwise: a
+ * function judged from its creation site, a destructured or reassigned parameter, a spread or unlisted argument.
+ */
+export declare function parameterArguments(definitions: Definitions, id: AstNode, at: Position): {
+    node: AstNode;
+    at: Position;
+}[] | undefined;

package/dist/packages/analysis/lib/parameter-arguments.js

@@ -0,0 +1,34 @@
+// The arguments a helper's parameter takes (§5 Resolver capabilities 3): a parameter of a function instantiated from
+// listed calls holds what each call passes, evaluated where the call is. Wrap evidence and restore proofs (§3)
+// read them where the values alone can't say what they need: that a value is a factory's result given the original, or
+// the slot a constructor was read from.
+/**
+ * The arguments a parameter `id` takes, each where its call evaluates it, when `id` reads a plain parameter of a function
+ * that a frame of `at` instantiates from listed calls, and nothing in the function reassigns it. Undefined otherwise: a
+ * function judged from its creation site, a destructured or reassigned parameter, a spread or unlisted argument.
+ */
+export function parameterArguments(definitions, id, at) {
+    const key = definitions.keyOf(id);
+    if (key === undefined || key.scope === 'global')
+        return undefined;
+    const fn = key.scope;
+    const index = (fn['params'] ?? []).findIndex((param) => param.type === 'Identifier' && param['name'] === key.name);
+    if (index < 0 || definitions.of(key).length > 0)
+        return undefined;
+    let frame = at.frame;
+    while (frame !== undefined && frame.fn !== fn)
+        frame = frame.outer;
+    if (frame === undefined || frame.how === 'creation' || frame.bindings.length === 0)
+        return undefined;
+    const found = [];
+    for (const { site, caller, element } of frame.bindings) {
+        // An iteration native's callback is passed the element it visits, which no argument expression gives.
+        const argument = element === undefined ? site.args[index] : undefined;
+        if (argument === undefined || argument.type === 'SpreadElement')
+            return undefined;
+        if (site.unlisted !== undefined && index >= site.unlisted)
+            return undefined;
+        found.push({ node: argument, at: { guard: (name) => site.guards.get(name), topLevel: site.topLevel, frame: caller } });
+    }
+    return found;
+}

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

@@ -0,0 +1,10 @@
+import type { AstNode } from './ast.ts';
+/**
+ * Parses code with `oxc-parser`: its program, or the first error. A partially recovered AST is never returned (§13). A
+ * script with an `import` or `export` declaration doesn't parse, as in a browser.
+ */
+export declare function parse(text: string, sourceType: 'script' | 'module'): {
+    program: AstNode;
+} | {
+    error: string;
+};

package/dist/packages/analysis/lib/parse.js

@@ -0,0 +1,39 @@
+import { parseSync, rawTransferSupported } from 'oxc-parser';
+/** Raw transfer where the platform supports it (§5 Parsing and scope). The option is not in oxc's typings. */
+const rawTransfer = rawTransferSupported();
+/** The parser options §5 fixes, with the `sourceType` always explicit. */
+const parserOptions = (sourceType) => ({
+    lang: 'js',
+    sourceType,
+    range: true,
+    preserveParens: false,
+    experimentalRawTransfer: rawTransfer,
+});
+/**
+ * The early error for an `import` or `export` declaration in a script, by declaration type. The ECMAScript Script goal
+ * has no such declarations, but oxc reports them only among its semantic errors, which §5's options leave out.
+ */
+const moduleDeclarations = new Map([
+    ['ImportDeclaration', 'Cannot use import statement outside a module'],
+    ['ExportNamedDeclaration', 'Cannot use export statement outside a module'],
+    ['ExportDefaultDeclaration', 'Cannot use export statement outside a module'],
+    ['ExportAllDeclaration', 'Cannot use export statement outside a module'],
+]);
+/**
+ * Parses code with `oxc-parser`: its program, or the first error. A partially recovered AST is never returned (§13). A
+ * script with an `import` or `export` declaration doesn't parse, as in a browser.
+ */
+export function parse(text, sourceType) {
+    const parsed = parseSync('artifact.js', text, parserOptions(sourceType));
+    const [error] = parsed.errors;
+    if (error !== undefined)
+        return { error: error.message };
+    const program = parsed.program;
+    if (sourceType === 'script') {
+        // Import and export declarations can only be top-level statements, so the program's body holds any there are.
+        const declaration = program['body'].find(({ type }) => moduleDeclarations.has(type));
+        if (declaration !== undefined)
+            return { error: moduleDeclarations.get(declaration.type) };
+    }
+    return { program };
+}

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

@@ -0,0 +1,60 @@
+import { type AstNode } from './ast.ts';
+import type { Definitions, VariableKey } from './definitions.ts';
+import { type Key as MemberKey } from './keys.ts';
+import type { OpenWrite, WildWrite } from './writes.ts';
+export interface ShapeContext {
+    program: AstNode;
+    definitions: Definitions;
+    /** The constant key an expression folds to, as ToPropertyKey converts it, or none when it doesn't fold to one. */
+    fold(key: AstNode): MemberKey | undefined;
+    /** Whether a callee is a catalog native: a native function, a native holder, or a catalog member read from one. */
+    isCatalogNative(callee: AstNode): boolean;
+    /** Whether a callee is `Object.getOwnPropertyDescriptor` or `Reflect.getOwnPropertyDescriptor`. */
+    isDescriptorReader(callee: AstNode): boolean;
+    /** How deep an alias chain is followed to its root (§18, `Caps.aliasDepth`). */
+    aliasDepth: number;
+    /** Counts a hit of the `aliasDepth` cap at the alias it keeps from being followed (§18). */
+    aliasCut(id: AstNode): void;
+    /** The functions the program makes that a callee can be, for reads made in a summarized callee. */
+    calleeFunctions(callee: AstNode): AstNode[];
+}
+/**
+ * How a wildcard write reuses its key (§5 Partially resolved writes): the reads of the same (holder, key) before
+ * it, which give the original, and whether the write keeps the member when present, which makes its value equal the
+ * read then.
+ */
+export interface Reuse {
+    /** Whether a node gives the original: a read of the slot, a summarized call that reads it, or a fetched descriptor's `value`. */
+    isOriginal(node: AstNode): boolean;
+    /** Whether the write keeps the member when present: `o[k] || p`, `o[k] ||= p`, `if (!o[k])`, `if (!(k in o))`. */
+    keptWhenPresent: boolean;
+    /** Whether the value written is a read of the same slot, which writes back what is there. */
+    writesBack: boolean;
+}
+/** Patch-shape and key-reuse judgements over one program (§5 Partially resolved writes). */
+export interface Shapes {
+    /** Whether a write site whose holder doesn't resolve keeps the original of its slot. */
+    patchShaped(write: OpenWrite): boolean;
+    /** How a wildcard write reuses its key, or undefined when it doesn't: no read of it, nor its descriptor, comes first. */
+    reuse(write: WildWrite): Reuse | undefined;
+}
+/**
+ * Holder signatures over one program (§5 Partially resolved writes): the same for two expressions that give the same
+ * holder, the same root variable, parameter or `this` through the same constant property chain after aliases.
+ */
+export interface Slots {
+    /** A holder expression's signature, with the variables it reads in `roots`; none when it is no such expression. */
+    signature(expression: AstNode, roots: VariableKey[]): string | undefined;
+    /**
+     * A key expression's signature, with the variables it reads in `roots`, read from the syntax alone, with nothing
+     * evaluated: the same for two expressions that give the same key, a literal, or the same variable, parameter or
+     * `this` through the same property chain, whose computed keys are such expressions too (`names[i]`); none for
+     * anything else.
+     */
+    keySignature(expression: AstNode, roots: VariableKey[]): string | undefined;
+    /** Whether a root variable is defined again between `from` and `to`. */
+    redefined(roots: readonly VariableKey[], from: number, to: number): boolean;
+}
+export declare function slotSignatures(context: Pick<ShapeContext, 'definitions' | 'fold' | 'aliasDepth' | 'aliasCut'>): Slots;
+/** Patch-shape and key-reuse judgements over one program: its parents, computed once. */
+export declare function patchShapes(context: ShapeContext): Shapes;