@scriptc/compiler 0.2.5 → 0.2.6

package/dist/frontend/type-mapper.js

@@ -858,6 +858,18 @@ let contextResolutions = 0;
 export function mapType(type, ctx) {
     if (mapTypeDepth >= MAP_TYPE_MAX_DEPTH)
         return null;
+    // These intrinsic domains cannot depend on generic bindings, declaration
+    // provenance, or recursive shape state. Enum literals retain the ordinary
+    // widening path, including mixed numeric/string enum representations.
+    const flags = type.flags;
+    if ((flags & ts.TypeFlags.EnumLike) === 0) {
+        if (flags & (ts.TypeFlags.Number | ts.TypeFlags.NumberLiteral))
+            return F64;
+        if (flags & (ts.TypeFlags.String | ts.TypeFlags.StringLiteral | ts.TypeFlags.TemplateLiteral))
+            return STRING;
+        if (flags & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral))
+            return BOOL;
+    }
     const topLevel = mapTypeDepth === 0;
     const typeId = type.id;
     const memoizable = typeId !== undefined && (ctx.canMemoizeType?.() ?? true);
@@ -1858,6 +1870,7 @@ function mapTypeInner(type, ctx) {
     if (isStdlibInterface("Immediate"))
         return F64;
     if (isStdlibInterface("ArrayBuffer") ||
+        isStdlibInterface("SharedArrayBuffer") ||
         isStdlibInterface("PropertyDescriptor") ||
         isStdlibInterface("ProcessVersions"))
         return DYN;
@@ -1944,6 +1957,13 @@ function mapTypeInner(type, ctx) {
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "fs")))
         return DYN;
+    if ((psym?.name === "Worker" || psym?.name === "MessagePort") &&
+        checker
+            .declarationsOf(psym)
+            .some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
+            ctx.isStdlibFile(d.getSourceFile()) &&
+            isDeclaredInAmbientModule(d, "worker_threads")))
+        return DYN;
     // fs/promises.FileHandle: an owned descriptor object. Module provenance
     // distinguishes it from user interfaces with the same name; both the
     // fallback and @types/node declare it in "fs/promises".
@@ -2973,6 +2993,7 @@ function mapTypeInner(type, ctx) {
         try {
             const byKey = new Map();
             const recordParts = [];
+            const substitutedUnions = [];
             for (const part of ts.constituentTypes(widened)) {
                 // TypeScript's client can retain impossible intersections in a
                 // distributed union. They have no inhabitants and no runtime tag.
@@ -3016,6 +3037,19 @@ function mapTypeInner(type, ctx) {
                     byKey.set(typeKey(UNDEFINED_T), UNDEFINED_T);
                     continue;
                 }
+                // A generic parameter can substitute a complete union into one
+                // checker constituent: `(T | undefined)` with nullable T still
+                // has one flat storage contract. An unfinished recursive union
+                // cannot supply its arms yet, so retain that existing boundary.
+                if (mapped.kind === "union") {
+                    const substituted = unions.get(mapped.unionId);
+                    if (!substituted?.arms.length || substituted.arms.some((arm) => arm.kind === "union"))
+                        return null;
+                    substitutedUnions.push(substituted);
+                    for (const arm of substituted.arms)
+                        byKey.set(typeKey(arm), arm);
+                    continue;
+                }
                 byKey.set(typeKey(mapped), mapped);
                 if (mapped.kind === "record")
                     recordParts.push({ source: part, mapped });
@@ -3070,7 +3104,10 @@ function mapTypeInner(type, ctx) {
                 return null;
             }
             arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
-            const discriminant = unionDiscriminant(recordParts, arms, ctx);
+            const discriminant = unionDiscriminant(recordParts, arms, ctx) ??
+                (substitutedUnions.length === 1
+                    ? remapUnionDiscriminant(substitutedUnions[0], arms)
+                    : undefined);
             if (unions.recursivePending(widened)) {
                 // The knot closed through this union. A frame that resolved
                 // through context-sensitive hooks (generic type parameters, mixin
@@ -4162,6 +4199,8 @@ function mapRecordTypeInner(widened, ctx) {
     const computed = widened.isIntersectionType() || isMappedShape(widened);
     {
         const props = checker.getPropertiesOfType(widened);
+        if (ctx.classImplementedProtocol?.(widened))
+            return DYN;
         // Symbol-keyed records use the checked object's descriptor table. A
         // checker-internal __@ name is not a string field in a native struct.
         if (props.some((property) => property.name.startsWith("__@")))
@@ -4196,7 +4235,10 @@ function mapRecordTypeInner(widened, ctx) {
             return DYN;
         }
         const fields = [];
-        for (const p of props) {
+        for (let propertyIndex = 0; propertyIndex < props.length; propertyIndex++) {
+            if (propertyIndex % 32 === 0)
+                checker.prefetchMemberTypes(props, propertyIndex);
+            const p = props[propertyIndex];
             if (p.flags & (ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor)) {
                 // OBJECT-LITERAL get/set accessors (TS sources): the property has
                 // no data slot — the shape carries reserved closure fields instead