@scriptc/compiler 0.0.6 → 0.0.8

package/dist/frontend/lowering/lowerer.d.ts

@@ -41,6 +41,8 @@ export type WidthLift = {
     how: "objWidth";
 } | {
     how: "clsWidth";
+} | {
+    how: "narrow";
 };
 export declare class PoisonError extends Error {
 }
@@ -355,6 +357,12 @@ export declare class Lowerer {
     /** Non-null while an instance body lowers: type-parameter symbol →
      * concrete IR type, consulted inside mapType's recursion. */
     typeParamBindings: Map<ts.Symbol, IrType> | null;
+    /** The ts-level twin of typeParamBindings, non-null while a CALL-keyed
+     * instance body lowers: type-parameter symbol → the bound CHECKER type,
+     * consulted where the mapped IrType has already widened away information
+     * the body needs — indexed accesses (`T[K]` needs K's literal key) and
+     * keyed record reads (`o[k]` where k's type is a literal-bound K). */
+    typeParamTsBindings: Map<ts.Symbol, ts.Type> | null;
     /** Non-null while an IMPLICIT-ANY instance body lowers (npm-static JS —
      * lower-calls' implicit-monomorphization section): bound param symbol →
      * the call site's checker type, consulted by typeOf for identifier
@@ -880,6 +888,12 @@ export declare class Lowerer {
      * (`T`, `T[]`, `{ v: T }`, `(x: T) => T` all resolve). Inert outside
      * generic instantiation. */
     readonly typeParamResolver: (t: ts.Type) => IrType | null;
+    /** The ts-level twin of typeParamResolver: the bound CHECKER type of a
+     * type parameter in the current instantiation (typeParamTsBindings), for
+     * the resolutions where mapType's widening already dropped what the body
+     * needs (indexed accesses over literal-bound keys). Inert outside
+     * call-keyed generic instantiation. */
+    readonly typeParamTsResolver: (t: ts.Type) => ts.Type | null;
     irTypeOf(node: ts.Node): IrType;
     /** Exact-shape enforcement (SC2002). Records are monomorphic structs, so
      * everywhere a value flows into a typed slot (call arg, initializer,
@@ -1370,7 +1384,7 @@ export declare class Lowerer {
     genericFnOf(ident: ts.Identifier): GenericFnInfo | null;
     lowerGenericCall(expr: ts.CallExpression, info: GenericFnInfo): IrExpr;
     lowerGenericFnValue(ref: ts.Expression, info: GenericFnInfo): IrExpr;
-    inferTypeParamBindings(expr: ts.CallExpression, info: GenericFnInfo, rsig: ts.Signature): Map<ts.Symbol, IrType>;
+    inferTypeParamBindings(expr: ts.CallExpression, info: GenericFnInfo, rsig: ts.Signature, tsBindings?: Map<ts.Symbol, ts.Type>): Map<ts.Symbol, IrType>;
     lowerGenericInstance(info: GenericFnInfo, inst: GenericInstance): IrFunction;
     collectClassShape(decl: ts.ClassDeclaration): void;
     collectClassShapeInner(decl: ts.ClassLikeDeclaration, jsNameOverride?: string, inst?: {
@@ -1610,9 +1624,11 @@ export declare class Lowerer {
     isStdlibSymbol(symbol: ts.Symbol | undefined): boolean;
     isStdlibGlobal(expr: ts.Expression, name: string): boolean;
     stdlibGlobalMember(access: ts.PropertyAccessExpression, name: string): string | null;
-    lowerArrayLiteral(expr: ts.ArrayLiteralExpression, expected?: IrType & {
+    lowerArrayLiteral(expr: ts.ArrayLiteralExpression, expected?: (IrType & {
         kind: "array";
-    }): IrExpr;
+    }) | (IrType & {
+        kind: "record";
+    })): IrExpr;
     lowerObjectLiteral(expr: ts.ObjectLiteralExpression): IrExpr;
     lowerShorthandValue(prop: ts.ShorthandPropertyAssignment): IrExpr;
     rejectThisInObjectMethod(node: ts.Node): void;

package/dist/frontend/lowering/lowerer.js

@@ -14,11 +14,11 @@
  */
 import { isRelativeSpecifier } from "../shared.js";
 import * as ts from "../ts7/adapter.js";
-import { anyOpRequiresDynamicDiag, blockedBindingUseDiag, checkerPanicDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, noLoweringDiag, recordShapeMismatchDiag, requiresDynamicApiDiag, requiresDynamicPackageDiag, requiresDynamicTypeDiag, unionMismatchDiag, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
+import { anyOpRequiresDynamicDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, requiresDynamicApiDiag, requiresDynamicPackageDiag, requiresDynamicTypeDiag, unionMismatchDiag, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
 import { arrayOf, BOOL, canAdaptDynFuncTo, canConvertToDyn, canCrossIslandBoundary, canExitIslandToType, canMarshalTypedFuncIntoIsland, DYN, F64, isJsonSafeType, isUndefinedArmedUnion, isUnitType, JSVAL, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID } from "../../ir/nodes.js";
 import { provenanceActive } from "../provenance-registry.js";
 import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
-import { containsRecord, containsUnion, formatIrType, ISLAND_AMBIENT_TYPES, isUnitOnlyTsType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../types.js";
+import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, ISLAND_AMBIENT_TYPES, isUnitOnlyTsType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../types.js";
 import { boundaryIntoIslandMsg, boundaryOutOfIslandMsg, builtinConstLit, builtinModuleConstOf, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalMember, nodeTypesOnlySymbol } from "./surfaces.js";
 import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, defaultExportSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules } from "./lower-modules.js";
 import { registerBuiltinErrorClasses, registerBuiltinEmitterClass, registerBuiltinStreamClasses, builtinErrorInfoOf, builtinEmitterInfoOf, builtinStreamInfoOf, analyzeClassDecoration, classIteratorDrainCall, classIteratorNextCall, classIteratorOf, classIteratorOpenCall, classIteratorRestDrainCall, classMemberNameOf, classValueRef, collectClassShape, exactClassOfReceiver, collectClassShapeInner, ctorAbiEquals, findMethodOn, findStaticOn, findGenericMethodOn, findGenericStaticOn, genericClassInstanceType, isSubclassOf, inHierarchy, overrideBelow, staticShadowBelow, upcastTo, lowerClassMembers, lowerClassCtor, lowerClassExpression, lowerClassExpressionInfo, lowerClassMethodMember, lowerClassValueProperty, lowerStaticMethod, throwingSetterFn, fieldInitStmts, lowerStaticFieldInits, lowerStaticFieldRead, lowerDerivedCtorBody, superCallStmt, lowerSuperMethodCall, superThisRef, lowerSuperAccessorRead, lowerSuperAccessorWrite, inheritsBuiltinErrorCtor, inheritsBuiltinEmitterCtor, errorMessageArg, lowerNew, accessorCall } from "./lower-classes.js";
@@ -27,7 +27,7 @@ import { bindingNeverReassigned, bodyReadsArguments, isThisParameter, paramShape
 import { lowerArrayMethodCall, lowerBufferStaticCall, lowerBytesMethodCall, lowerBytesNew, lowerMapMethodCall, lowerMapForEachCall, buildMapForEachFn, lowerRecordOvfCaptureHelper, lowerEnvToPairsHelper, lowerSetMethodCall, lowerSetForEachCall, buildSetForEachFn, lowerRegexMethodCall, lowerStringMethodCall } from "./lower-containers.js";
 import { lowerStreamModuleCall } from "./lower-stream.js";
 import { builtinImportOf, lowerBuiltinModuleCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, promisifiedExecFileDecl, lowerExecFileAsyncCall, execFileAsyncHelper, lowerStringDecoderMethodCall, strdecHelper, lowerReadlineMethodCall, lowerDcChannelMethodCall, lowerDcChannelProperty, lowerAlsMethodCall, lowerDcTracingChannelMethodCall, lowerDcTracingChannelProperty, lowerJsonProperty, lowerErrorCodeProperty, lowerProcessProperty, isProcessEnv, envValueType, lowerProcessEnvGet, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerTimeoutMethodCall, envSnapshotHelper, isConsoleLog, consoleCallMember, lowerNumberStaticCall, lowerNumberStaticProperty, lowerDateCall, lowerTextCodecCall, lowerFsConstantsProperty, lowerHttp2ConstantsProperty, http2ConstantBindingOf, http2ConstantsDestructureDecl, lowerProcessStreamProperty, lowerStringStaticCall, lowerStringLastIndexOfCall, lowerPromiseStaticCall } from "./lower-builtins.js";
-import { isIslandExpr, islandRegexpOf, jsvalIn, requireDynamicApi, islandGlobalFnOf, lowerDynamicImportCall, lowerFetchCall, lowerIslandMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol } from "./lower-island.js";
+import { isIslandExpr, islandFuncValueFence, islandRegexpOf, jsvalIn, requireDynamicApi, islandGlobalFnOf, lowerDynamicImportCall, lowerFetchCall, lowerIslandMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol } from "./lower-island.js";
 import { lowerHttpHeadersElement, lowerNetModuleCall, lowerServerMethodCall, lowerServerProperty } from "./lower-server.js";
 import { lowerDgramDnsModuleCall, lowerDgramMethodCall } from "./lower-dgram.js";
 import { lowerNodeTestModuleCall, lowerTestDirectCall, lowerTestMethodCall, lowerTestCtxProperty } from "./lower-test.js";
@@ -35,7 +35,7 @@ import { lowerAssertModuleCall, lowerAssertDirectCall } from "./lower-assert.js"
 import { lowerUtilModuleCall } from "./lower-inspect.js";
 import { lowerComptime, comptimeBakeable, rejectComptimeCaptures, comptimeValueToIr } from "./lower-comptime.js";
 import { lowerStmts, noteBlockedBindings, isBlockedBinding, lowerScopedBlock, predeclareForwardCapture, predeclareForwardFnDecl, predeclareForwardVar, rejectJumpCrossingFinally, lowerStmt, lowerVarStatement, lowerDestructuringDecl, lowerDestructuringAssignParts, lowerBindingPattern, lowerJsvalBindingPattern, checkBindingElement, bindPatternTarget, lowerVarDeclList, lowerVarDecl, lowerSwitch, lowerTry, lowerExprStatement, lowerForOf, lowerForStatement } from "./lower-stmts.js";
-import { lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerOptionalChain, finishOptionalChain, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerObjectLiteral, lowerShorthandValue, rejectThisInObjectMethod, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf, foldedStringKeyOf } from "./lower-exprs.js";
+import { lowerDynObjectLiteral, lowerExpr, maybeNarrow, lowerUnitComparison, lowerNullishCoalesce, lowerOptionalChain, finishOptionalChain, lowerCondition, ensureBool, requireTruthyUnion, eqComparableUnion, lowerIntrinsicProperty, lowerArrayLiteral, lowerObjectLiteral, lowerShorthandValue, rejectThisInObjectMethod, lowerElementAccess, lowerElementWrite, lowerRecordKeyRead, ensureString, lowerTemplate, lowerAsExpression, lowerPrefixUnary, lowerBinary, lowerCaughtTypeofTest, caughtRead, caughtLocalOf, caughtToString, lowerInstanceOf, lowerRegexLiteral, lowerFieldRead, lowerUnionProperty, fieldTarget, fieldGetExpr, fieldSetStmt, lowerFieldCompound, uniqueSymbolKeyOf, foldedStringKeyOf } from "./lower-exprs.js";
 import { lowerRecordFieldCall, lowerObjectMethodCall } from "./lower-calls.js";
 import { fenceCrossBlockNsRef, nsPathPrefix } from "./lower-namespaces.js";
 /** Entry function name. '%' cannot appear in a TS identifier, so a user
@@ -468,6 +468,12 @@ export class Lowerer {
     /** Non-null while an instance body lowers: type-parameter symbol →
      * concrete IR type, consulted inside mapType's recursion. */
     typeParamBindings = null;
+    /** The ts-level twin of typeParamBindings, non-null while a CALL-keyed
+     * instance body lowers: type-parameter symbol → the bound CHECKER type,
+     * consulted where the mapped IrType has already widened away information
+     * the body needs — indexed accesses (`T[K]` needs K's literal key) and
+     * keyed record reads (`o[k]` where k's type is a literal-bound K). */
+    typeParamTsBindings = null;
     /** Non-null while an IMPLICIT-ANY instance body lowers (npm-static JS —
      * lower-calls' implicit-monomorphization section): bound param symbol →
      * the call site's checker type, consulted by typeOf for identifier
@@ -811,6 +817,7 @@ export class Lowerer {
             unions: this.unions,
             classNamer: this.classNamer,
             resolveTypeParam: this.typeParamResolver,
+            resolveTypeParamTs: this.typeParamTsResolver,
             genericClassInstance: (decl, ref) => this.genericClassInstanceType(decl, ref),
             mixinClassInstance: (decl) => this.mixinTypeContext && this.mixinTypeContext.classNode === decl
                 ? { kind: "object", className: this.mixinTypeContext.className }
@@ -1904,6 +1911,59 @@ export class Lowerer {
             this.pushDiag(requiresDynamicTypeDiag(this.checker.typeToString(type), locOf(node)));
             throw new PoisonError();
         }
+        // STANDARD-LIBRARY nominal provenance, decided once: interface/class
+        // declarations in the lib's own files (Date, ArrayBuffer, WeakMap, the
+        // iterator/constructor interfaces). Such types report the SC2020 story
+        // below — the same one the index-signature-carrying lib types above
+        // tell — rather than an overload/record claim no user can act on.
+        const stdlibOwnSym = widened.getSymbol();
+        const stdlibNominal = stdlibOwnSym !== undefined &&
+            this.checker.declarationsOf(stdlibOwnSym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+                this.isStdlibFile(d.getSourceFile()));
+        // OVERLOADED call signatures (SC2007) — after the generic branch, so a
+        // generic overload set keeps the monomorphization story: a value of a
+        // multi-signature type has no single compiled signature to hold.
+        if (!stdlibNominal && this.checker.getCallSignatures(widened).length > 1) {
+            this.pushDiag(overloadedSignatureTypeDiag(this.checker.typeToString(type), locOf(node)));
+            throw new PoisonError();
+        }
+        // INTERSECTIONS that resolved to no lowering (SC2008). The ones that
+        // compile never get here: member intersections intern through the
+        // record path, callable hybrids map to '%call' records, and pinned
+        // mixin instantiations resolve by chain structure.
+        if (widened.isIntersectionType()) {
+            this.pushDiag(intersectionTypeDiag(this.checker.typeToString(type), locOf(node)));
+            throw new PoisonError();
+        }
+        // SUPPORTED shapes over a component outside its slot (SC2009): the
+        // Map/Set domains, array/tuple elements, union arms, function
+        // parameters/returns. The container is not the blocker — name the
+        // component instead of reciting the supported set. Checked BEFORE the
+        // lib claim so Map/Set/Promise instantiation failures keep their
+        // component story (describeComponentBlocker always answers for those
+        // heads).
+        {
+            const detail = describeComponentBlocker(widened, this.typeCtx);
+            if (detail !== null) {
+                this.pushDiag(componentTypeDiag(this.checker.typeToString(type), detail, locOf(node)));
+                throw new PoisonError();
+            }
+        }
+        // STANDARD-LIBRARY nominal types with no lowering at all: the SC2020
+        // story, naming the type.
+        if (stdlibNominal) {
+            this.pushDiag(noLoweringDiag(this.checker.typeToString(type), locOf(node)));
+            throw new PoisonError();
+        }
+        // USER record shapes blocked by ONE member (SC2009's record arm):
+        // name the member and its type.
+        {
+            const detail = describeRecordMemberBlocker(widened, this.typeCtx);
+            if (detail !== null) {
+                this.pushDiag(componentTypeDiag(this.checker.typeToString(type), detail, locOf(node)));
+                throw new PoisonError();
+            }
+        }
         this.pushDiag(unsupportedTypeDiag(this.checker.typeToString(type), locOf(node)));
         throw new PoisonError();
     }
@@ -2051,6 +2111,17 @@ export class Lowerer {
         const sym = t.getSymbol();
         return (sym && this.typeParamBindings.get(sym)) ?? null;
     };
+    /** The ts-level twin of typeParamResolver: the bound CHECKER type of a
+     * type parameter in the current instantiation (typeParamTsBindings), for
+     * the resolutions where mapType's widening already dropped what the body
+     * needs (indexed accesses over literal-bound keys). Inert outside
+     * call-keyed generic instantiation. */
+    typeParamTsResolver = (t) => {
+        if (!this.typeParamTsBindings || !(t.flags & ts.TypeFlags.TypeParameter))
+            return null;
+        const sym = t.getSymbol();
+        return (sym && this.typeParamTsBindings.get(sym)) ?? null;
+    };
     irTypeOf(node) {
         const t = this.typeOf(node);
         // A never-tainted JS type (neverTaintedJsType) maps — never rides as
@@ -2667,6 +2738,15 @@ export class Lowerer {
                 return null;
             return { how: "liftWrap", tag: candidates[0].tag, arm: candidates[0].arm };
         }
+        // A UNION source into a slot that is ONE of its arms (a width copy
+        // whose target field narrowed — the option-table choices shape:
+        // `value: boolean | string` copying into a `value: string` slot the
+        // checker approved): the CHECKED extraction — narrowedArmHelper,
+        // exactly `x!`'s machinery — the proven arm's payload comes out, any
+        // other arm throws the catchable TypeError (divergence 38's stance).
+        if (src.kind === "union" && !isUnitType(dst) && dst.kind !== "void" && this.armTag(src.unionId, dst) >= 0) {
+            return { how: "narrow" };
+        }
         if (dst.kind === "record" && src.kind === "record") {
             return this.recordWidthPlan(src.shapeId, dst.shapeId) !== null ? { how: "width" } : null;
         }
@@ -2786,6 +2866,14 @@ export class Lowerer {
                     throw new Error("lowerer bug: planned clsWidth lift failed to intern");
                 return { kind: "call", callee: helper, args: [value], type: dst, loc };
             }
+            case "narrow": {
+                if (value.type.kind !== "union")
+                    throw new Error("lowerer bug: narrow lift on a non-union");
+                const helper = this.narrowedArmHelper(value.type.unionId, dst, loc);
+                if (!helper)
+                    throw new Error("lowerer bug: planned narrow lift failed to intern");
+                return { kind: "call", callee: helper, args: [value], type: dst, loc };
+            }
             default: {
                 const _exhaustive = lift;
                 void _exhaustive;
@@ -3503,8 +3591,14 @@ export class Lowerer {
             return this.boundaryExitSafe(dst);
         if (dst.kind === "dyn")
             return src.kind !== "dyn" && this.dynConvertible(src);
-        if (src.kind === "dyn")
-            return this.jsonSafe(dst);
+        if (src.kind === "dyn") {
+            // The checked-dynamic function boundary's OUT direction joins the
+            // mechanical set: a dyn result landing in an adaptable func slot
+            // takes dynCheck's per-target shim (coerceToExpected's funcOk rule
+            // — the production/development function-choice ternary shape).
+            return (this.jsonSafe(dst) ||
+                (dst.kind === "func" && canAdaptDynFuncTo(dst, (id) => this.shapes.get(id), (id) => this.unions.get(id))));
+        }
         if (dst.kind === "union") {
             if (src.kind === "union")
                 return this.unionRetagMappable(src.unionId, dst.unionId);
@@ -3552,10 +3646,19 @@ export class Lowerer {
                 strandParams = true;
         }
         let voidRet = null;
+        let strandRet = false;
         if (toT.ret.kind !== "void" && !this.coercibleValue(fromT.ret, toT.ret)) {
-            if (fromT.ret.kind !== "void")
-                return null;
-            voidRet = toT.ret.kind === "dyn" ? "dyn" : toT.ret.kind === "jsval" ? "jsval" : "strand";
+            if (fromT.ret.kind !== "void") {
+                // A RESULT that cannot convert — the strandParams stance, result
+                // side (the production/development function-choice ternary: the
+                // untaken arm's result shape never lands in the slot's): the
+                // assignment compiles, INVOKING the slot runs the function and
+                // throws the stranded TypeError where its result would convert.
+                strandRet = true;
+            }
+            else {
+                voidRet = toT.ret.kind === "dyn" ? "dyn" : toT.ret.kind === "jsval" ? "jsval" : "strand";
+            }
         }
         if (toT.ret.kind === "void" && fromT.ret.kind === "jsval")
             return null;
@@ -3623,6 +3726,12 @@ export class Lowerer {
                     strandThrow(`a void result where the '${this.fmt(toT)}' slot promises '${this.fmt(toT.ret)}' (a thrower typed 'never' never reaches this; a genuinely void function has no result to hand over)`),
                 ];
             }
+            else if (strandRet) {
+                body = [
+                    { kind: "exprStmt", expr: call, loc },
+                    strandThrow(`a '${this.fmt(fromT)}' function invoked through a '${this.fmt(toT)}' slot (the result cannot convert to '${this.fmt(toT.ret)}' — the checker's loose function compatibility admitted the assignment, but the call has no exact lowering)`),
+                ];
+            }
             else {
                 const result = this.coerceToExpected(call, toT.ret);
                 if (!typeEquals(result.type, toT.ret))
@@ -4646,6 +4755,25 @@ export class Lowerer {
                 e = { kind: "call", callee: helper, args: [e], type: expected, loc: e.loc };
             }
         }
+        // A JS FUNC value outside the island marshal set flowing into a
+        // jsval slot (`withPlugins(getSupportInfoWithoutPlugins, 0)` — a
+        // wrapper built at module init around a function the run may never
+        // call): the crossing defers to a call-time fence closure instead of
+        // stopping the statement — jsvalIn's deferral, the implicit-coercion
+        // spelling.
+        if (expected.kind === "jsval" && e.type.kind === "func" && !typeEquals(e.type, expected)) {
+            const diagsBefore = this.diags.length;
+            try {
+                this.requireExactShape(node, e.type, expected);
+            }
+            catch (err) {
+                const fence = islandFuncValueFence(this, err, diagsBefore, node);
+                if (fence)
+                    return fence;
+                throw err;
+            }
+            return e;
+        }
         this.requireExactShape(node, e.type, expected);
         return e;
     }
@@ -4732,6 +4860,55 @@ export class Lowerer {
                 return this.coerceInto(node, this.lowerArrayLiteral(x, expected), expected);
             }
         }
+        // An OBJECT LITERAL against a checked-dynamic slot in a JS file (the
+        // getSupportInfo options argument — a dyn-ABI param): the value's
+        // world IS the DOM — build the DOM literal directly, before the
+        // island gate could claim the checker's `any` context (an island
+        // build could never land in the slot: no engine→DOM crossing).
+        if (expected?.kind === "dyn") {
+            let x = node;
+            while (ts.isParenthesizedExpression(x))
+                x = x.expression;
+            if (ts.isObjectLiteralExpression(x) && isJsSourceFile(x.getSourceFile())) {
+                return lowerDynObjectLiteral(this, x);
+            }
+        }
+        // An ARRAY LITERAL against a UNION slot whose own type has no static
+        // home (the JS dyn fallback — the checker gave no usable context):
+        // when the union has exactly ONE array-family arm — an array, or an
+        // arity-matching tuple (the option-table `default: [{ value: [] }]`
+        // shape) — build AS that arm and wrap; the IR-directed twin of
+        // lowerArrayLiteral's contextual-union rule.
+        if (expected?.kind === "union") {
+            let x = node;
+            while (ts.isParenthesizedExpression(x))
+                x = x.expression;
+            if (ts.isArrayLiteralExpression(x)) {
+                const own = this.mapTypeOf(this.checker.getContextualType(x) ?? this.typeOf(x));
+                // Elements beyond bare null/undefined literals can never live in
+                // a unit-only-element array — a checker type that degraded to one
+                // (`[]`-flavored inference over a populated literal) carries no
+                // element information.
+                const nonUnitElems = x.elements.some((el) => !ts.isOmittedExpression(el) &&
+                    el.kind !== ts.SyntaxKind.NullKeyword &&
+                    !(ts.isIdentifier(el) && el.text === "undefined"));
+                if (own === null || own.kind === "dyn" || own.kind === "jsval" ||
+                    (own.kind === "array" && nonUnitElems && this.unitOnlyElem(own.elem)) ||
+                    this.widthLiftPlan(own, expected) === null) {
+                    const def = this.unions.get(expected.unionId);
+                    const arms = (def?.arms ?? []).filter((a) => (a.kind === "array" && !(nonUnitElems && this.unitOnlyElem(a.elem))) ||
+                        (a.kind === "record" &&
+                            !!this.shapes.get(a.shapeId)?.tuple &&
+                            this.shapes.get(a.shapeId).fields.length === x.elements.length &&
+                            !x.elements.some(ts.isSpreadElement)));
+                    if (arms.length === 1) {
+                        const arm = arms[0];
+                        const built = this.lowerArrayLiteral(x, arm);
+                        return this.coerceInto(node, built, expected);
+                    }
+                }
+            }
+        }
         const e = this.lowerExpr(node);
         return expected ? this.coerceInto(node, e, expected) : e;
     }
@@ -4999,8 +5176,8 @@ export class Lowerer {
     lowerGenericFnValue(ref, info) {
         return lowerGenericFnValue(this, ref, info);
     }
-    inferTypeParamBindings(expr, info, rsig) {
-        return inferTypeParamBindings(this, expr, info, rsig);
+    inferTypeParamBindings(expr, info, rsig, tsBindings) {
+        return inferTypeParamBindings(this, expr, info, rsig, tsBindings);
     }
     lowerGenericInstance(info, inst) {
         return lowerGenericInstance(this, info, inst);