@scriptc/compiler 0.4.0 → 0.4.1

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

@@ -101,9 +101,13 @@ export function genericCallInstance(lowerer, expr, info) {
     // reconcile bridge, like the non-generic path).
     {
         const rdecl = rsig ? rsig.declaration : undefined;
-        if (rdecl &&
+        if (rsig &&
+            rdecl &&
             (ts.isFunctionDeclaration(rdecl) || ts.isMethodDeclaration(rdecl)) &&
             !rdecl.body) {
+            const overload = overloadCallInstance(lowerer, expr, info, rsig, rdecl);
+            if (overload)
+                return overload;
             lowerer.unsupported("SC1090", expr, `calls selecting an overload signature of a generic ${ts.isMethodDeclaration(rdecl) ? "method" : "function"} (only the implementation signature monomorphizes)`);
         }
     }
@@ -129,14 +133,7 @@ export function genericCallInstance(lowerer, expr, info) {
         fenceGenericSignatureResult(lowerer, expr, retTs);
         lowerer.badType(expr, retTs);
     }
-    // A body that can return an indexed read that misses returns undefined
-    // there, as in JavaScript, whatever the declared result says. An async
-    // body's promise is always present and settles with undefined there.
-    const returnType = lowerer.runtimeOptionalGenericReturns.has(info.decl)
-        ? mappedReturn.kind === "promise"
-            ? { kind: "promise", inner: lowerer.runtimeOptionalType(mappedReturn.inner) }
-            : lowerer.runtimeOptionalType(mappedReturn)
-        : mappedReturn;
+    const returnType = runtimeReturnType(lowerer, info, mappedReturn);
     // keyof-constrained type parameters (`K extends keyof T`): the bound
     // LITERAL is semantic — the instance body reads the named field — so
     // the bindings compute EAGERLY (the key needs them) and each literal
@@ -146,29 +143,112 @@ export function genericCallInstance(lowerer, expr, info) {
     // share one runtime-keyed instance per IR signature, exactly the
     // widened discipline.
     const named = staticNameBindings(lowerer, expr, info);
-    const keyofTps = keyofConstrainedTypeParams(info);
-    if (keyofTps.size > 0) {
+    if (keyofConstrainedTypeParams(info).size > 0) {
         const tsBindings = new Map();
         const bindings = lowerer.inferTypeParamBindings(expr, info, rsig, tsBindings);
-        const litKey = info.typeParams
-            .filter((tp) => keyofTps.has(tp))
-            .map((tp) => {
-            const bound = tsBindings.get(tp);
-            return bound?.isStringLiteralType()
-                ? JSON.stringify(bound.value)
-                : bound?.isNumberLiteralType()
-                    ? String(bound.value)
-                    : "*";
-        })
-            .join(",");
         return internGenericInstance(lowerer, expr, info, params, returnType, () => bindings, {
-            extraKey: `@${litKey}${named?.key ?? ""}`,
+            extraKey: `${keyofLiteralKey(info, tsBindings)}${named?.key ?? ""}`,
             tsBindings,
             ...(named ? { staticFnNames: named.names } : {}),
         });
     }
     return internGenericInstance(lowerer, expr, info, params, returnType, (tsBindings) => lowerer.inferTypeParamBindings(expr, info, rsig, tsBindings), named ? { extraKey: named.key, staticFnNames: named.names } : undefined);
 }
+/** A call that resolved to an OVERLOAD signature of a generic function
+ * or method with an implementation (`request<T>(p: WithHandler<T>):
+ * Promise<T>; request(p: Plain): Promise<Res>; request<T>(p: Params<T>)
+ * {...}`): the implementation monomorphizes under the bindings the
+ * overload's resolved signature proves for its type parameters (the
+ * structural unification every generic call uses, run against the
+ * overload; unbound parameters take their declared defaults). The
+ * instance's parameters and result are the IMPLEMENTATION's under those
+ * bindings — the body was checked against them — and the call's
+ * arguments and result coerce across, exactly as a non-generic overload
+ * call reconciles with its implementation (parameters the overload omits
+ * must be optional in the implementation). Null when the overload does
+ * not belong to this implementation or the arities do not line up. */
+function overloadCallInstance(lowerer, expr, info, rsig, rdecl) {
+    const impl = info.decl;
+    if (rdecl.parent !== impl.parent ||
+        rdecl.name === undefined ||
+        impl.name === undefined ||
+        rdecl.name.getText() !== impl.name.getText() ||
+        rdecl.parameters.nodes.length > impl.parameters.nodes.length ||
+        impl.parameters.nodes
+            .slice(rdecl.parameters.nodes.length)
+            .some((p) => p.questionToken === undefined && p.initializer === undefined) ||
+        rdecl.parameters.nodes.some((p) => p.dotDotDotToken !== undefined))
+        return null;
+    const declSig = lowerer.checker.getSignatureFromDeclaration(impl);
+    if (!declSig)
+        return null;
+    const tsBindings = new Map();
+    const bindings = new Map();
+    unifySignatureBindings(lowerer, info, rsig, bindings, tsBindings);
+    // Explicit type arguments name the OVERLOAD's type parameters, which
+    // need not match the implementation's in order: the resolved overload
+    // already carries them, so unification binds first, and an explicit
+    // argument binds only a still-unbound implementation parameter of the
+    // same name.
+    const overloadTps = rdecl.typeParameters?.nodes ?? [];
+    expr.typeArguments?.nodes.forEach((ta, i) => {
+        const name = overloadTps[i]?.name.text;
+        const tp = info.typeParams.find((p) => ts.symbolName(p) === name);
+        if (!tp || bindings.has(tp))
+            return;
+        const taT = lowerer.checker.getTypeFromTypeNode(ta);
+        const mapped = lowerer.mapTypeOf(taT);
+        if (mapped) {
+            bindings.set(tp, mapped);
+            tsBindings.set(tp, taT);
+        }
+    });
+    bindDefaultTypeParams(lowerer, info.typeParams, impl.typeParameters?.nodes, bindings, tsBindings);
+    // A type parameter the overload never mentions (a handler the overload
+    // omits) is `unknown`, the checker's own answer for an uninferred one.
+    for (const tp of info.typeParams) {
+        if (bindings.has(tp))
+            continue;
+        bindings.set(tp, DYN);
+        tsBindings.set(tp, lowerer.checker.getUnknownType());
+    }
+    const previous = lowerer.typeParamBindings;
+    const previousTs = lowerer.typeParamTsBindings;
+    lowerer.typeParamBindings = bindings;
+    lowerer.typeParamTsBindings = tsBindings;
+    let params;
+    let returnType;
+    try {
+        params = paramShapes(lowerer, impl.parameters.nodes, declSig, (_param, i) => expr.arguments.nodes[i] ?? expr);
+        returnType = lowerer.mapTypeOf(lowerer.checker.getReturnTypeOfSignature(declSig));
+    }
+    finally {
+        lowerer.typeParamBindings = previous;
+        lowerer.typeParamTsBindings = previousTs;
+    }
+    if (!returnType)
+        return null;
+    // keyof-constrained parameters key their instance on the bound literal,
+    // as on the implementation-signature path.
+    const runtimeReturn = runtimeReturnType(lowerer, info, returnType);
+    return internGenericInstance(lowerer, expr, info, params, runtimeReturn, () => bindings, {
+        ...(keyofConstrainedTypeParams(info).size > 0
+            ? { extraKey: keyofLiteralKey(info, tsBindings) }
+            : {}),
+        tsBindings,
+    });
+}
+/** An instance's result type: a body that can return an indexed read
+ * that misses returns undefined there, as in JavaScript, whatever the
+ * declared result says. An async body's promise is always present and
+ * settles with undefined there. */
+function runtimeReturnType(lowerer, info, mapped) {
+    if (!lowerer.runtimeOptionalGenericReturns.has(info.decl))
+        return mapped;
+    return mapped.kind === "promise"
+        ? { kind: "promise", inner: lowerer.runtimeOptionalType(mapped.inner) }
+        : lowerer.runtimeOptionalType(mapped);
+}
 /** A generic factory whose result is one of its own local classes
  * (`function base<T>(v: T) { return class { value: T = v }; }`). Each
  * instance has its own class, so the instance is keyed on its bindings and
@@ -374,6 +454,24 @@ function keyofConstrainedTypeParams(info) {
     info.keyofTps = out;
     return out;
 }
+/** The instance-key suffix of the literals bound to `info`'s
+ * keyof-constrained type parameters (`@"a"`; `*` for a non-literal
+ * binding): two literals can map to one IR signature while their bodies
+ * read different fields. */
+function keyofLiteralKey(info, tsBindings) {
+    const keyofTps = keyofConstrainedTypeParams(info);
+    const literals = info.typeParams
+        .filter((tp) => keyofTps.has(tp))
+        .map((tp) => {
+        const bound = tsBindings.get(tp);
+        return bound?.isStringLiteralType()
+            ? JSON.stringify(bound.value)
+            : bound?.isNumberLiteralType()
+                ? String(bound.value)
+                : "*";
+    });
+    return `@${literals.join(",")}`;
+}
 /** Type-parameter symbol → concrete IR type for one instantiation.
  * Explicit type arguments bind directly; the rest come from structurally
  * matching each DECLARED param/return type (which mentions the type
@@ -491,6 +589,31 @@ function unifySignatureBindings(lowerer, info, rsig, bindings, tsBindings) {
                 // too is safe only when no undeclared null arm remains.
                 unify(dParts[0], lowerer.checker.getNonNullableType(inst), depth + 1);
             }
+            else if (dParts.length > 1 && iParts.length === dParts.length) {
+                // `T | Promise<T>` against `Res | Promise<Res>`: each declared
+                // part that names a generic target (Promise, an interface, an
+                // alias) pairs with the one instantiated part of the same target;
+                // a single remaining bare type parameter takes the single
+                // remaining instantiated part.
+                const remaining = [...iParts];
+                const bare = [];
+                for (const d of dParts) {
+                    if (d.flags & ts.TypeFlags.TypeParameter) {
+                        bare.push(d);
+                        continue;
+                    }
+                    const target = d.getSymbol() ?? d.getAliasSymbol();
+                    if (target === undefined)
+                        return;
+                    const matches = remaining.filter((i) => (i.getSymbol() ?? i.getAliasSymbol()) === target);
+                    if (matches.length !== 1)
+                        return;
+                    remaining.splice(remaining.indexOf(matches[0]), 1);
+                    unify(d, matches[0], depth + 1);
+                }
+                if (bare.length === 1 && remaining.length === 1)
+                    unify(bare[0], remaining[0], depth + 1);
+            }
             return;
         }
         // Instantiations of the SAME generic ALIAS (Partial<T> vs
@@ -783,6 +906,12 @@ export function lowerGenericFnValue(lowerer, ref, info) {
         lowerer.noteEdge(inst.name);
         return { kind: "closure", fnName: inst.name, captures: [], type: funcType, loc };
     }
+    // Each call of the enclosing function makes a new function object for a
+    // binding declared inside it (`make() !== make()` when make returns
+    // it), which one shared compiled instance cannot give.
+    if (info.functionScoped) {
+        lowerer.unsupported("SC1090", ref, `generic arrow/function-expression bindings declared inside functions as values (each call of the enclosing function makes a new '${info.baseName}' function object, while its compiled instances are shared module functions — call '${info.baseName}' directly, or declare it at module scope)`);
+    }
     const fenceUnpinned = () => lowerer.unsupported("SC1090", ref, `generic functions as values without a pinned concrete signature (annotate the destination — e.g. 'const f: (x: number) => number = ${info.baseName}' — instantiate explicitly ('${info.baseName}<number>'), or call '${info.baseName}' directly)`);
     // The PINNING type: an instantiation expression's own checker type
     // (explicit type arguments applied), else the reference's contextual
@@ -1711,28 +1840,50 @@ export function implicitLocalFnNodeOf(lowerer, decl) {
             return null;
         if (!isConst && !bindingNeverReassigned(lowerer, sym, decl))
             return null;
-        // The capture scan: instances are module functions with no frame.
-        let captures = false;
-        const scan = (n) => {
-            if (captures)
-                return;
-            if (n.kind === ts.SyntaxKind.ThisKeyword || n.kind === ts.SyntaxKind.SuperKeyword) {
-                // 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.
-                captures = true;
-                return;
+        // Instances are module functions with no frame.
+        return capturesEnclosingFrame(lowerer, init, decl, init.body) ? null : init;
+    };
+    const node = probe();
+    if (node === null) {
+        lowerer.implicitLocalFns.set(decl, null);
+        return null;
+    }
+    return node;
+}
+/** True when `fn`, bound by `decl`, uses its enclosing function's frame
+ * somewhere in `scope`: `this`, `super`, `arguments` or `new.target`, or
+ * a value or type declared in an enclosing function (a local, a parameter,
+ * an enclosing generic's type parameter). Module-scope declarations and
+ * the binding itself are reachable from the module functions the
+ * instances compile to. */
+function capturesEnclosingFrame(lowerer, fn, decl, scope) {
+    const file = ts.getSourceFileOfNode(decl);
+    const self = lowerer.checker.getSymbolAtLocation(decl.name);
+    let captures = false;
+    const scan = (n) => {
+        if (captures)
+            return;
+        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.
+            captures = true;
+            return;
+        }
+        if (ts.isIdentifier(n)) {
+            const s = lowerer.checker.getSymbolAtLocation(n);
+            if (s === undefined) {
+                if (n.text === "arguments")
+                    captures = true;
             }
-            if (ts.isIdentifier(n)) {
-                const s = lowerer.checker.getSymbolAtLocation(n);
-                const d = s ? s.valueDeclaration : undefined;
-                if (d &&
-                    ts.getSourceFileOfNode(d) === ts.getSourceFileOfNode(decl) &&
-                    !(d.pos >= init.pos && d.end <= init.end)) {
-                    // Declared outside the initializer, in this file: a capture
-                    // exactly when some enclosing FUNCTION scope declares it —
-                    // module-scope declarations are reachable from any module
-                    // function.
+            else if (s !== self) {
+                for (const d of s.declarations) {
+                    if (ts.getSourceFileOfNode(d) !== file || (d.pos >= fn.pos && d.end <= fn.end))
+                        continue;
+                    // Declared outside the function, in this file: a capture
+                    // exactly when some enclosing FUNCTION scope declares it.
                     for (let p = d.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
                         if (ts.isFunctionLike(p)) {
                             captures = true;
@@ -1741,17 +1892,11 @@ export function implicitLocalFnNodeOf(lowerer, decl) {
                     }
                 }
             }
-            ts.forEachChild(n, scan);
-        };
-        scan(init.body);
-        return captures ? null : init;
+        }
+        ts.forEachChild(n, scan);
     };
-    const node = probe();
-    if (node === null) {
-        lowerer.implicitLocalFns.set(decl, null);
-        return null;
-    }
-    return node;
+    scan(scope);
+    return captures;
 }
 /** Registers (or returns) the GenericFnInfo of a qualifying implicit-any
  * function-value binding — implicitLocalFnNodeOf's companion, the
@@ -1925,9 +2070,16 @@ 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.
+    let functionScoped = false;
     for (let n = decl.parent; n !== undefined && !ts.isSourceFile(n); n = n.parent) {
         if (ts.isFunctionLike(n)) {
-            lowerer.unsupported("SC1090", fnNode, `generic arrow/function-expression bindings declared inside functions (the compiled instantiations of '${name}' are module functions and cannot capture the enclosing frame — declare the binding at module scope)`);
+            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)`);
+            }
+            functionScoped = true;
+            break;
         }
     }
     const sym = lowerer.checker.getSymbolAtLocation(decl.name);
@@ -1956,12 +2108,17 @@ export function bindingGenericFnInfoOf(lowerer, decl, fnNode) {
     }
     checkGenericParameterNames(lowerer, fnNode.parameters.nodes, true);
     const stmt = decl.parent?.parent; // declarator → list → statement (nsPathPrefix wants the statement)
+    // A binding in a function or block can share its name with another; its
+    // instances take the declaration's position.
+    const topLevel = stmt?.parent !== undefined && (ts.isSourceFile(stmt.parent) || ts.isModuleBlock(stmt.parent));
     const info = {
         decl: fnNode,
         baseName: name,
-        qualifiedName: lowerer.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(stmt ?? decl, decl) + name),
+        qualifiedName: lowerer.qualify(ts.getSourceFileOfNode(decl), nsPathPrefix(stmt ?? decl, decl) +
+            (topLevel ? name : `${name}%l${ts.tokenStartOfNode(decl)}`)),
         typeParams,
         instances: new Map(),
+        ...(functionScoped ? { functionScoped: true } : {}),
     };
     lowerer.bindingGenericFns.set(fnNode, info);
     lowerer.genericFnsBySymbol.set(sym, info);