@scriptc/compiler 0.4.0 → 0.4.2

package/dist/frontend/lowering/expressions/object-literals.js

@@ -1,3 +1,4 @@
+import { keyedHelperName } from "../stable-names.js";
 import { dateJsonType, isDateJsonSource } from "../builtins/dates.js";
 import { dynUndefinedExpr, numLit, strLit, varRef } from "../../../ir/build.js";
 import { pathModuleValue } from "../lower-builtin-values.js";
@@ -7,7 +8,7 @@ import { BOOL, DYN, F64, STRING, UNDEFINED_T, VOID, arrayOf, canDynCheckTo, isUn
 import { isCjsExportTableLiteral, isJsSourceFile, locOf } from "../../program.js";
 import { NARROW_FIRST } from "../surfaces.js";
 import { recordShapeMismatchDiag } from "../../../diagnostics/diagnostic.js";
-import { PoisonError, neverTaintedJsType } from "../lowerer.js";
+import { PoisonError, jsFuncNameOf, neverTaintedJsType } from "../lowerer.js";
 import { lowerIndexMergeHelper } from "../containers/indexed-objects.js";
 import { PERF_ENTRY_MARKER, isGenericCallableMemberType, jsOpenObjectType, } from "../../type-mapper.js";
 import { isSafeToRepeat } from "./evaluation-safety.js";
@@ -15,6 +16,7 @@ import { tryLowerExpression } from "./try-lower-expression.js";
 import { fenceSymbolFieldCopy } from "../symbol-fields.js";
 import { planUnionRetag } from "../union-retag.js";
 import { jsHoldsDynObject, runtimeOptionalStorageOperand } from "../lower-exprs.js";
+import { builtinGlobalValue } from "./property-access.js";
 /** `{ a: 1, b: "x" }` → recordLit. The record type comes from the
  * contextual type when tsc has one (annotated declarations, arguments,
  * nested literals) and from the literal's own type otherwise — both intern
@@ -166,6 +168,18 @@ function propNameText(lowerer, name) {
         return String(Number(name.text));
     return name.text;
 }
+/** The name an anonymous function or a method takes from its property key
+ * (NamedEvaluation): an identifier, string or numeric key, or a computed
+ * key that folds to one string. Null for other keys. */
+function propertyFunctionName(lowerer, name) {
+    if (ts.isComputedPropertyName(name))
+        return literalComputedKey(lowerer, name);
+    if (ts.isNumericLiteral(name))
+        return String(Number(name.text));
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name))
+        return name.text;
+    return null;
+}
 /** The runtime-keyed JS object literal (a computed key that doesn't fold):
  * builds a dyn object member-by-member. Keys evaluate before their values,
  * properties in source order — JS's object-literal evaluation exactly.
@@ -347,9 +361,11 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
         try {
             const lowerValue = () => ts.isMethodDeclaration(prop)
                 ? lowerer.lowerLambda(prop, true)
-                : !boxValue && ts.isObjectLiteralExpression(valueExpr)
-                    ? lowerer.lowerExprExpecting(valueExpr, DYN)
-                    : lowerer.lowerExpr(valueExpr);
+                : ts.isShorthandPropertyAssignment(prop) && shorthandBuiltinValue(lowerer, prop)
+                    ? shorthandBuiltinValue(lowerer, prop)
+                    : !boxValue && ts.isObjectLiteralExpression(valueExpr)
+                        ? lowerer.lowerExprExpecting(valueExpr, DYN)
+                        : lowerer.lowerExpr(valueExpr);
             raw = fenceClosureProbe(lowerer, valueExpr, undefined, lowerValue) ?? lowerValue();
         }
         catch (err) {
@@ -362,7 +378,7 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
                 throw err;
             const fence = lowerer.deferToRuntimeFence(propDiagsBefore, prop, {
                 kind: "closure",
-                name: () => `%fn${lowerer.lambdaCounter++}_dynfence`,
+                name: () => lowerer.closureName(loc, "_dynfence"),
                 returnType: VOID,
                 type: { kind: "func", params: [], ret: VOID },
             });
@@ -373,6 +389,25 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
         let v = boxValue
             ? boxValue(valueExpr, raw)
             : lowerer.coerceToExpected(raw, DYN);
+        // A function that boxes into a property takes its name as Node gives
+        // it: a function read by name keeps that name (`{ f }`, `{ k: f }`),
+        // and an anonymous function or a method takes the property's name
+        // (`{ g: function () {} }`, `{ m() {} }`).
+        if (!boxValue &&
+            v.kind === "dynFrom" &&
+            v.value.type.kind === "func" &&
+            v.fnName === undefined) {
+            let anonymous = valueExpr;
+            while (ts.isParenthesizedExpression(anonymous))
+                anonymous = anonymous.expression;
+            const name = ts.isMethodDeclaration(prop) ||
+                ((ts.isFunctionExpression(anonymous) || ts.isArrowFunction(anonymous)) &&
+                    !(ts.isFunctionExpression(anonymous) && anonymous.name))
+                ? propertyFunctionName(lowerer, prop.name)
+                : jsFuncNameOf(valueExpr, lowerer);
+            if (name !== null)
+                v = { ...v, fnName: name };
+        }
         // A JS object's array-valued properties retain the same source array.
         // Repeated references must compare equal and mutations remain shared.
         if (!boxValue &&
@@ -394,7 +429,7 @@ export function lowerDynObjectLiteral(lowerer, expr, boxValue) {
                     throw err;
                 const fence = lowerer.deferToRuntimeFence(convDiagsBefore, prop, {
                     kind: "closure",
-                    name: () => `%fn${lowerer.lambdaCounter++}_dynfence`,
+                    name: () => lowerer.closureName(loc, "_dynfence"),
                     returnType: VOID,
                     type: { kind: "func", params: [], ret: VOID },
                 });
@@ -708,11 +743,14 @@ function lowerOptionalIndexSpreadSource(lowerer, source, loc) {
 export function lowerObjectLiteral(lowerer, expr, expected) {
     // Unannotated JavaScript accumulator fields have no element contract.
     // Preserve their checked arrays instead of assigning never[] a numeric ABI.
+    // An empty object field is a map the program adds keys to.
     if (!expected &&
         isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
         expr.properties.nodes.some((prop) => ts.isPropertyAssignment(prop) &&
             ((ts.isArrayLiteralExpression(prop.initializer) &&
                 prop.initializer.elements.nodes.length === 0) ||
+                (ts.isObjectLiteralExpression(prop.initializer) &&
+                    prop.initializer.properties.nodes.length === 0) ||
                 neverTaintedJsType(lowerer, prop.initializer, lowerer.typeOf(prop.initializer))))) {
         return lowerDynObjectLiteral(lowerer, expr);
     }
@@ -2562,7 +2600,7 @@ function lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc) {
         const key = `declmerge-source:${type.shapeId}:${source.shapeId}`;
         let helper = lowerer.valueHelpers.get(key);
         if (!helper) {
-            helper = `%rec.declmerge.${lowerer.valueHelpers.size}`;
+            helper = keyedHelperName(lowerer, "%rec.declmerge", key);
             const sourceType = source.value.type;
             const destination = varRef("out.0", type, loc);
             const receiver = varRef("source.0", sourceType, loc);
@@ -2749,6 +2787,17 @@ function lowerDeclaredSpreadMerge(lowerer, expr, type, shape, loc) {
 /** The value of a shorthand property (`{ x }`): the binding `x` refers to.
  * The property name's own symbol is the PROPERTY, so resolution goes
  * through getShorthandAssignmentValueSymbol. */
+/** `{ TypeError }`: a stdlib global in shorthand position reads as the value
+ * its name reads as elsewhere (the interned constructor or function value),
+ * or null when the global has no such value. The shorthand's name carries
+ * the property's symbol, so the identifier path cannot resolve it. */
+function shorthandBuiltinValue(lowerer, prop) {
+    const symbol = lowerer.checker.getShorthandAssignmentValueSymbol(prop);
+    if (!symbol || !lowerer.isStdlibSymbol(symbol))
+        return null;
+    const js = isJsSourceFile(ts.getSourceFileOfNode(prop));
+    return builtinGlobalValue(ts.symbolName(symbol), locOf(prop.name), js);
+}
 export function lowerShorthandValue(lowerer, prop) {
     // 7 types the shorthand's name as PropertyName; it is always an
     // Identifier (the grammar allows nothing else in shorthand position).
@@ -2763,6 +2812,9 @@ export function lowerShorthandValue(lowerer, prop) {
         if (callable)
             return callable;
     }
+    const builtinValue = shorthandBuiltinValue(lowerer, prop);
+    if (builtinValue)
+        return builtinValue;
     if (symbol) {
         if (lowerer.ctx.selfSymbol === symbol) {
             return { kind: "selfRef", type: lowerer.ctx.selfType, loc };
@@ -2810,6 +2862,22 @@ export function lowerShorthandValue(lowerer, prop) {
         if (generic) {
             lowerer.unsupported("SC1090", prop, `generic functions as values (call '${propName.text}' directly)`);
         }
+        // A program class name (`{ parse, TomlError }`, an imported class
+        // included): the class object, exactly the long form `{ C: C }`.
+        // Generic classes keep the identifier path's contextual pinning.
+        const classInfo = lowerer.classBySymbol.get(resolved);
+        if (classInfo && !classInfo.generic) {
+            const decoratedGlobal = classInfo.classDecorators?.valueGlobalId;
+            if (decoratedGlobal !== undefined) {
+                return {
+                    kind: "varRef",
+                    localId: decoratedGlobal,
+                    type: { kind: "classval", className: classInfo.def.name },
+                    loc,
+                };
+            }
+            return lowerer.classValueRef(classInfo, propName);
+        }
     }
     lowerer.rejectUnresolvedSymbol(symbol
         ? symbol.flags & ts.SymbolFlags.Alias