@scriptc/compiler 0.4.6 → 0.4.7

package/dist/frontend/lowering/generic-functions.js

@@ -8,6 +8,7 @@ import { heritageElementTarget, isHeritageTypeReference } from "../heritage-elem
 import { bodyReadsArguments } from "../arguments-usage.js";
 import { BOOL, DYN, STRING, VOID, isUnitType, typeEquals, } from "../../ir/ir.js";
 import { helperLoc, nodeThrowExpr } from "../../ir/build.js";
+import { unsupportedDiag } from "../../diagnostics/diagnostic.js";
 import { isJsSourceFile, locOf } from "../program.js";
 import { typeKey } from "../type-mapper.js";
 import { functionCanReturnUndefined } from "../function-completion.js";
@@ -22,6 +23,7 @@ import { isVarDeclared, jsBindingHasOpenWrites } from "./lower-stmts.js";
 import { paramShapes, generatorMeta, funcTypeFromParamShapes, } from "./call-signatures.js";
 import { fenceGenericSignatureResult, blockBodyOf, resolveInferredReturn, appendImplicitUndefinedReturn, hasExplicitJsDocReturn, promiseCarriesDyn, } from "./function-returns.js";
 import { bindingNeverReassigned, stripValueWrappers } from "./binding-analysis.js";
+import { declareContextLocal } from "./function-context.js";
 import { extendInstantiationPath, MAX_INSTANTIATION_RECURSION, } from "./instantiation-path.js";
 /** Defaults bind during inference; collection only resolves symbols in
  * declaration order and preserves each declaration form's diagnostic. */
@@ -91,6 +93,45 @@ export function lowerGenericCall(lowerer, expr, info) {
         ? implicitCallInstance(lowerer, expr, info)
         : genericCallInstance(lowerer, expr, info);
     const args = lowerer.completeArgs(expr.arguments.nodes, instance.params, loc, expr);
+    if (info.captureMode === "env") {
+        // The environment form: a closure over this call site's boxes of the
+        // captured bindings (resolveKey threads them through any closures in
+        // between and boxes the origin), called at once. Arguments evaluate
+        // after the callee, as in JavaScript; building the closure only reads
+        // the boxes.
+        if (instance.params.some((p) => p.mode === "rest" || p.mode === "dynRest" || p.mode === "arguments")) {
+            lowerer.unsupported("SC1090", expr, `generic arrow/function-expression bindings with rest parameters that write the frames of their enclosing functions ('${info.baseName}')`);
+        }
+        const sources = info.captures.map((capture) => {
+            const local = lowerer.resolveKey(capture.symbol, expr);
+            if (local === null || !typeEquals(local.type, capture.type)) {
+                lowerer.unsupported("SC1090", expr, `generic arrow/function-expression bindings sharing '${capture.name}' with their enclosing function when its storage differs from its declared type ('${info.baseName}')`);
+            }
+            // An origin read from its own frame is not boxed by resolveKey; the
+            // closure needs the box (captureContextBinding's origin rule).
+            local.boxed = true;
+            return local.id;
+        });
+        const call = {
+            kind: "callValue",
+            callee: {
+                kind: "closure",
+                fnName: instance.name,
+                captures: sources,
+                type: funcTypeFromParamShapes(instance.params, instance.returnType),
+                loc,
+            },
+            args,
+            type: instance.returnType,
+            loc,
+        };
+        return guardEarlyBindingCall(lowerer, info, expr, call);
+    }
+    // The enclosing-frame values follow the declared arguments, the order
+    // the instance takes them in (lowerGenericInstance).
+    for (const capture of info.captures ?? []) {
+        args.push(lowerer.lowerExprExpecting(capture.nameNode, capture.type));
+    }
     const call = {
         kind: "call",
         callee: instance.name,
@@ -903,7 +944,10 @@ export function lowerGenericInstance(lowerer, info, inst) {
     let bodyReturn = isGenerator
         ? lowerer.genBodyReturnType(inst.returnType)
         : lowerer.bodyReturnType(isAsync, inst.returnType);
-    const fnCtx = newFnCtx(false, null, null, bodyReturn);
+    // The environment form lowers as a LIFTED function: its captures arrive
+    // in the closure environment, never as parameters.
+    const envForm = info.captureMode === "env";
+    const fnCtx = newFnCtx(envForm, null, null, bodyReturn);
     fnCtx.isAsync = isAsync;
     // Instances lower on demand, on top of whichever caller reached them.
     fnCtx.thisBoundary = true;
@@ -943,10 +987,34 @@ export function lowerGenericInstance(lowerer, info, inst) {
             const thisLocal = lowerer.declareThis(thisType);
             params.push({ localId: thisLocal.id, name: "this", type: thisType });
         }
+        // Environment form: one boxed capture entry per captured binding, in
+        // FrameCapture order (the call sites' closure caps[] order), keyed by
+        // the binding's symbol so the body (parameter defaults included)
+        // reads and writes the shared box. Pre-registering them also keeps
+        // resolution from walking past this instance's frame.
+        if (envForm) {
+            for (const capture of info.captures) {
+                const entry = declareContextLocal(fnCtx, capture.name, capture.type, capture.reassigned, undefined, undefined);
+                entry.boxed = true;
+                fnCtx.captureBySymbol.set(capture.symbol, entry);
+                fnCtx.captures.push({ localId: entry.id, name: entry.name, type: entry.type });
+            }
+        }
+        // The enclosing-frame values travel as TRAILING parameters, after the
+        // declared ones: a call lowers its arguments first (JavaScript's
+        // order), then reads the captures. Binding each local to the captured
+        // symbol is what lets the body resolve the reference; the locals are
+        // bound before the declared parameters so that a default initializer
+        // reading a capture resolves it too.
+        const captureParams = [];
+        for (const capture of envForm ? [] : (info.captures ?? [])) {
+            const local = lowerer.declareLocal(capture.nameNode, capture.name, capture.type, false);
+            captureParams.push({ localId: local.id, name: capture.name, type: capture.type });
+        }
         // Default-param initializers lower per instance, with the bindings
         // threaded — a default mentioning T resolves like any body expression.
         const declared = lowerer.declareParams(decl.parameters.nodes, inst.params);
-        params.push(...declared.params);
+        params.push(...declared.params, ...captureParams);
         const body = [...receiverInit, ...declared.prologue];
         const bodyBlock = blockBodyOf(decl);
         if (bodyBlock) {
@@ -1002,6 +1070,7 @@ export function lowerGenericInstance(lowerer, info, inst) {
             params,
             returnType: bodyReturn,
             locals: lowerer.ctx.locals,
+            ...(envForm ? { captures: fnCtx.captures } : {}),
             body,
             loc: locOf(decl),
         };
@@ -1026,6 +1095,18 @@ export function lowerGenericInstance(lowerer, info, inst) {
             lowerer.erasingDepth--;
     }
 }
+/** Records that `instance` is one of `info`'s value instances (see
+ * `valueInstances`). Written as its own statements rather than
+ * `(x ??= new Set()).add(...)`: the self-hosted frontend fences a Set method
+ * call on a non-Set receiver, and this compiler compiles its own source. */
+function noteValueInstance(info, instance) {
+    let instances = info.valueInstances;
+    if (instances === undefined) {
+        instances = new Set();
+        info.valueInstances = instances;
+    }
+    instances.add(instance);
+}
 /** A generic function taken as a VALUE, monomorphized by flow. A function
  * value needs ONE concrete signature; tsc pins one at exactly two
  * reference shapes — an instantiation EXPRESSION (`identity<number>`,
@@ -1046,6 +1127,7 @@ export function lowerGenericFnValue(lowerer, ref, info) {
     // closure per function, so `f === f` holds like any declaration).
     if (info.implicitParams) {
         const inst = implicitDefaultInstance(lowerer, ref, info);
+        noteValueInstance(info, inst.name);
         const funcType = funcTypeFromParamShapes(inst.params, inst.returnType);
         lowerer.requireExactArityValue(ref, ref, inst.params, funcType);
         lowerer.noteEdge(inst.name);
@@ -1087,10 +1169,47 @@ export function lowerGenericFnValue(lowerer, ref, info) {
                 target = callable[0][0];
         }
     }
+    if (!target) {
+        target = identityComparisonPin(lowerer, ref);
+        if (target)
+            lowerer.genericIdentityPins.push({ info, node: ref });
+    }
     if (!target)
         fenceUnpinned();
     return guardEarlyBindingValue(lowerer, info, ref, pinnedGenericClosure(lowerer, ref, info, target, fenceUnpinned));
 }
+/** The pinning signature of a generic declaration compared by identity
+ * (`held === ident`, `held !== ident`, and the loose forms): the other
+ * operand's one concrete call signature. A held value of that type that is
+ * this declaration is its instance at that signature, whose interned
+ * closure is the one this reference names, so the comparison answers as
+ * in JavaScript, provided the program holds the declaration at that one
+ * signature only (checkGenericIdentityPins). Null when the other operand
+ * has no single concrete call signature (another generic value, a union of
+ * callables, a non-function). */
+function identityComparisonPin(lowerer, ref) {
+    let operand = ref;
+    if (ref.parent !== undefined &&
+        ts.isPropertyAccessExpression(ref.parent) &&
+        ref.parent.name === ref)
+        operand = ref.parent;
+    while (operand.parent !== undefined && ts.isParenthesizedExpression(operand.parent))
+        operand = operand.parent;
+    const bin = operand.parent;
+    if (bin === undefined || !ts.isBinaryExpression(bin))
+        return null;
+    const op = bin.operatorToken.kind;
+    if (op !== ts.SyntaxKind.EqualsEqualsEqualsToken &&
+        op !== ts.SyntaxKind.ExclamationEqualsEqualsToken &&
+        op !== ts.SyntaxKind.EqualsEqualsToken &&
+        op !== ts.SyntaxKind.ExclamationEqualsToken)
+        return null;
+    const other = bin.left === operand ? bin.right : bin.left;
+    const sigs = lowerer.checker.getCallSignatures(lowerer.typeOf(other));
+    if (sigs.length !== 1 || sigs[0].getTypeParameters()?.length)
+        return null;
+    return sigs[0];
+}
 /** The value a generic binding declared inside a function stores when a
  * nested function read it before the declaration lowered (`const read =
  * () => id; const id: (x: number) => number = <T>(x: T): T => x`): such
@@ -1173,6 +1292,7 @@ function pinnedGenericClosure(lowerer, ref, info, target, fenceUnpinned) {
     if (info.typeParams.some((tp) => !bindings.get(tp)))
         fenceUnpinned();
     const inst = genericValueInstance(lowerer, ref, info, bindings);
+    noteValueInstance(info, inst.name);
     // The value's type is the completed ABI signature. Typed rest keeps its
     // packed-array slot; dynRest stays hidden behind the rest marker.
     const funcType = funcTypeFromParamShapes(inst.params, inst.returnType);
@@ -1213,12 +1333,139 @@ export function erasedGenericInstance(lowerer, blame, info) {
     try {
         const instance = genericValueInstance(lowerer, blame, info, new Map(info.typeParams.map((tp) => [tp, DYN])));
         instance.erased = true;
+        noteValueInstance(info, instance.name);
         return instance;
     }
     finally {
         lowerer.erasingDepth--;
     }
 }
+/** After every body lowered: an identity comparison of a generic
+ * declaration is exact only when the program holds the declaration as one
+ * function object. Otherwise a held value may be another instance's
+ * closure, where JavaScript has one function, so the comparison is
+ * refused instead of answering false. */
+export function checkGenericIdentityPins(lowerer) {
+    if (lowerer.genericIdentityCheckDone)
+        return;
+    lowerer.genericIdentityCheckDone = true;
+    const seen = new Map();
+    const report = (info, node, dynamic) => {
+        let infos = seen.get(node);
+        if (infos === undefined)
+            seen.set(node, (infos = new Set()));
+        if (infos.has(info))
+            return;
+        infos.add(info);
+        const held = info.valueInstances?.size ?? 0;
+        if (held <= 1)
+            return;
+        const through = dynamic ? " through a dynamic value" : "";
+        lowerer.pushDiag(unsupportedDiag("SC1090", locOf(node), `comparing the generic function '${info.baseName}' by identity${through} while the program holds it at ${held} different signatures (each is a separate compiled function object; JavaScript has one) — compare against a value pinned once, or hold '${info.baseName}' at a single signature`));
+    };
+    for (const { info, node } of lowerer.genericIdentityPins)
+        report(info, node, false);
+    // Dynamic comparisons resolve their provenance only when some declaration
+    // is held at more than one signature: the symbol lookups are the
+    // expensive part, and every other program answers them all at one
+    // instance. Recorded at lowering, resolved here so the pins' instance
+    // sets are complete.
+    let ambiguous = false;
+    for (const info of lowerer.genericFnsBySymbol.values()) {
+        if ((info.valueInstances?.size ?? 0) > 1) {
+            ambiguous = true;
+            break;
+        }
+    }
+    if (!ambiguous)
+        return;
+    for (const { node, left, right } of lowerer.dynIdentityComparisons) {
+        for (const operand of [left, right]) {
+            const info = genericDeclarationBehindValue(lowerer, operand);
+            if (info)
+                report(info, node, true);
+        }
+    }
+}
+/** The generic declaration whose value instance an expression names, when
+ * the expression is a binding initialized (directly, or through casts,
+ * aliasing bindings and property initializers) from that declaration. Used
+ * where a comparison reads the value through `unknown`/`any`, so the
+ * declaration is not syntactically at the compared site. */
+export function genericDeclarationBehindValue(lowerer, node) {
+    let current = node;
+    const seen = new Set();
+    while (current !== undefined && !seen.has(current)) {
+        seen.add(current);
+        if (ts.isParenthesizedExpression(current) ||
+            ts.isAsExpression(current) ||
+            ts.isSatisfiesExpression(current) ||
+            ts.isNonNullExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        if (!ts.isIdentifier(current) && !ts.isPropertyAccessExpression(current))
+            return null;
+        const symbol = lowerer.checker.getSymbolAtLocation(ts.isPropertyAccessExpression(current) ? current.name : current);
+        if (symbol === undefined)
+            return null;
+        const info = lowerer.genericFnsBySymbol.get(symbol);
+        if (info !== undefined)
+            return info;
+        const decl = symbol.valueDeclaration ?? symbol.declarations?.[0];
+        if (decl === undefined)
+            return null;
+        if (!ts.isVariableDeclaration(decl) && !ts.isPropertyDeclaration(decl) && !ts.isParameter(decl))
+            return null;
+        current = decl.initializer;
+    }
+    return null;
+}
+/** An identity comparison at the dynamic boundary (`unknown`/`any`
+ * operands): when either operand reads a generic declaration's value
+ * instance, the comparison is exact only while the program holds that
+ * declaration at one signature (checkGenericIdentityPins). */
+export function noteDynamicIdentityComparison(lowerer, node, left, right) {
+    // A function compared with a string, number, boolean, bigint or symbol
+    // is unequal whichever instance it is, as in JavaScript.
+    if (isPrimitiveTyped(lowerer, left) || isPrimitiveTyped(lowerer, right))
+        return;
+    // The only work done while lowering. No instance count can gate this:
+    // a value reference's instance is interned when its binding settles,
+    // which can be later than the comparison that reads it, so the notes
+    // are resolved at the end of lowering, when every instance is known.
+    if (mightNameBinding(left) || mightNameBinding(right))
+        lowerer.dynIdentityComparisons.push({ node, left, right });
+}
+const PRIMITIVE_TYPE_FLAGS = ts.TypeFlags.StringLike |
+    ts.TypeFlags.NumberLike |
+    ts.TypeFlags.BooleanLike |
+    ts.TypeFlags.BigIntLike |
+    ts.TypeFlags.ESSymbolLike;
+/** Whether the checker types `node` as a string, number, boolean, bigint or
+ * symbol (a union with any other member is not). */
+function isPrimitiveTyped(lowerer, node) {
+    return (lowerer.typeOf(node).flags & PRIMITIVE_TYPE_FLAGS) !== 0;
+}
+/** Whether an expression could name a binding at all — an identifier or a
+ * property access, through parentheses and casts. A literal, a call, an
+ * operator expression: nothing to resolve. */
+function mightNameBinding(node) {
+    let current = node;
+    for (let hops = 0; hops < 16 && current !== undefined; hops++) {
+        if (ts.isIdentifier(current) || ts.isPropertyAccessExpression(current))
+            return true;
+        if (ts.isParenthesizedExpression(current) ||
+            ts.isAsExpression(current) ||
+            ts.isNonNullExpression(current) ||
+            ts.isSatisfiesExpression(current)) {
+            current = current.expression;
+            continue;
+        }
+        return false;
+    }
+    return false;
+}
 /** The instance a pinned VALUE reference names: the declaration's modes
  * over the DECLARED types mapped under the bindings (mapType's resolver
  * substitutes — the instance-body trick), which is the same result the
@@ -2173,6 +2420,110 @@ function capturesEnclosingFrame(lowerer, fn, decl, scope) {
     scan(scope);
     return captures;
 }
+/** The enclosing-frame VALUES `fn`, bound by `decl`, reads — in first-use
+ * order, the order the instances take them as trailing parameters. The
+ * shape is the one the instance body resolves: a binding declared by an
+ * enclosing function (a local, a parameter, a local function or class).
+ *
+ * Module-scope declarations and the binding itself are reachable from the
+ * module functions the instances compile to, so they are not captures; nor
+ * are type-only declarations, whose mapping is static. `this`, `super`,
+ * `arguments`, `new.target`, and an enclosing generic's type parameter
+ * have no value a parameter can stand in for and stay fenced. A
+ * reassigned binding is shared through the environment form instead of
+ * copied. */
+function enclosingFrameCaptures(lowerer, fn, decl, scope, name) {
+    const file = ts.getSourceFileOfNode(decl);
+    const self = lowerer.checker.getSymbolAtLocation(decl.name);
+    const frameFence = () => lowerer.unsupported("SC1090", fn, `generic arrow/function-expression bindings that use the frames of their enclosing functions (the compiled instantiations of '${name}' are module functions and cannot capture its locals, parameters, type parameters or 'this' — pass them as arguments, or declare the binding at module scope)`);
+    const captures = [];
+    const seen = new Set();
+    const scan = (n) => {
+        if (n.kind === ts.SyntaxKind.ThisKeyword ||
+            n.kind === ts.SyntaxKind.SuperKeyword ||
+            ts.isMetaProperty(n)) {
+            // Arrow bodies see the ENCLOSING this; function expressions
+            // rebind their own — but a bare `this` there is untyped JS
+            // dynamism either way. Reject both, cheaply and soundly.
+            frameFence();
+        }
+        if (ts.isIdentifier(n)) {
+            const s = lowerer.checker.getSymbolAtLocation(n);
+            if (s === undefined) {
+                if (n.text === "arguments")
+                    frameFence();
+            }
+            else if (s !== self && !seen.has(s)) {
+                for (const d of s.declarations) {
+                    if (ts.getSourceFileOfNode(d) !== file || (d.pos >= fn.pos && d.end <= fn.end))
+                        continue;
+                    let enclosing = false;
+                    for (let p = d.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
+                        if (ts.isFunctionLike(p)) {
+                            enclosing = true;
+                            break;
+                        }
+                    }
+                    if (!enclosing)
+                        continue;
+                    // A type parameter (of the enclosing function or class) keys
+                    // the enclosing instantiation; the instance would need that
+                    // frame's type arguments, which this binding cannot carry.
+                    if ((s.flags & ts.SymbolFlags.TypeParameter) !== 0)
+                        frameFence();
+                    // Type-only declarations cost no runtime slot.
+                    if ((s.flags & ts.SymbolFlags.Value) === 0)
+                        break;
+                    // A trailing-parameter COPY is exact only while the original
+                    // never changes; a binding written anywhere in the file puts the
+                    // whole binding in the environment form (GenericFnInfo.captureMode).
+                    const reassigned = !bindingNeverReassigned(lowerer, s, d);
+                    // ...and exact only once the original is INITIALIZED. A capture
+                    // declared after the binding could be read from a call that runs
+                    // before its initializer — a temporal dead zone JavaScript would
+                    // throw on. Declared before, the copy is always the initialized
+                    // value: reaching the binding's own declaration ran it.
+                    if (d.pos > decl.pos)
+                        frameFence();
+                    // The declaration's own identifier (a binding element's for a
+                    // destructured name): lowering it resolves the SYMBOL, so the
+                    // instance body reads the parameter we declare for it.
+                    const declaredName = d.name;
+                    const nameNode = declaredName !== undefined && ts.isIdentifier(declaredName) ? declaredName : d;
+                    const type = lowerer.irTypeOf(nameNode);
+                    captures.push({
+                        symbol: s,
+                        nameNode,
+                        name: ts.isIdentifier(nameNode) ? nameNode.text : ts.symbolName(s),
+                        type,
+                        reassigned,
+                    });
+                    seen.add(s);
+                    break;
+                }
+            }
+        }
+        ts.forEachChild(n, scan);
+    };
+    scan(scope);
+    // A capture's type is fixed when the info is registered, once per
+    // binding, while an enclosing generic function or class re-lowers its
+    // frame per instantiation: the second instantiation's value would have a
+    // different type than the parameter the shared instance declares.
+    // Generic enclosing scopes keep the fence; non-generic ones carry no
+    // type argument for the instance to miss.
+    if (captures.length > 0) {
+        for (let p = fn.parent; p && !ts.isSourceFile(p); p = p.parent) {
+            if (!ts.isFunctionLike(p) && !ts.isClassLikeDeclaration(p))
+                continue;
+            const typeParameters = p
+                .typeParameters;
+            if (typeParameters !== undefined && typeParameters.nodes.length > 0)
+                frameFence();
+        }
+    }
+    return captures;
+}
 /** Registers (or returns) the GenericFnInfo of a qualifying implicit-any
  * function-value binding — implicitLocalFnNodeOf's companion, the
  * bindingGenericFnInfoOf shape: the info enters genericFnsBySymbol under
@@ -2345,14 +2696,19 @@ export function bindingGenericFnInfoOf(lowerer, decl, fnNode) {
     const name = decl.name.text;
     if (fnNode.asteriskToken)
         lowerer.unsupported("SC1071", fnNode);
-    // Inside a function, the compiled instances are module functions, so
-    // the initializer may not use the enclosing frame.
+    // Inside a function, the compiled instances are module functions: the
+    // values the initializer reads from the enclosing frame travel as
+    // trailing parameters (FrameCapture), or through a closure environment
+    // when one of them is reassigned (captureMode). `this`, `arguments` and
+    // an enclosing generic's type parameters have no value to pass and stay
+    // fenced.
     let functionScoped = false;
+    let captures;
     for (let n = decl.parent; n !== undefined && !ts.isSourceFile(n); n = n.parent) {
         if (ts.isFunctionLike(n)) {
-            if (capturesEnclosingFrame(lowerer, fnNode, decl, fnNode)) {
-                lowerer.unsupported("SC1090", fnNode, `generic arrow/function-expression bindings that use the frames of their enclosing functions (the compiled instantiations of '${name}' are module functions and cannot capture its locals, parameters, type parameters or 'this' — pass them as arguments, or declare the binding at module scope)`);
-            }
+            const found = enclosingFrameCaptures(lowerer, fnNode, decl, fnNode, name);
+            if (found.length > 0)
+                captures = found;
             functionScoped = true;
             break;
         }
@@ -2394,6 +2750,8 @@ export function bindingGenericFnInfoOf(lowerer, decl, fnNode) {
         typeParams,
         instances: new Map(),
         ...(functionScoped ? { functionScoped: true } : {}),
+        ...(captures ? { captures } : {}),
+        ...(captures?.some((capture) => capture.reassigned) ? { captureMode: "env" } : {}),
         bindingDecl: decl,
     };
     lowerer.bindingGenericFns.set(fnNode, info);