@scriptc/compiler 0.1.4 → 0.1.5

package/dist/frontend/lowering/lowerer.js

@@ -616,6 +616,27 @@ function jsFallbackFunctionType(lowerer, node, t) {
     const ret = retT.flags & ts.TypeFlags.Void ? VOID : lowerer.mapTypeOf(retT) ?? DYN;
     return { kind: "func", params, ret };
 }
+/** A JavaScript `arguments` reader has the spelled parameters plus a hidden
+ * array of all supplied arguments in the native ABI. Recover that ABI from
+ * the implementation when the function flows through a value binding. */
+function jsArgumentsFunctionType(lowerer, t) {
+    if (!(t.flags & ts.TypeFlags.Object))
+        return null;
+    const sigs = lowerer.checker.getCallSignatures(t);
+    if (sigs.length !== 1 || sigs[0].getTypeParameters().length !== 0 || lowerer.checker.getConstructSignatures(t).length !== 0 || lowerer.checker.getPropertiesOfType(t).length !== 0)
+        return null;
+    const decl = lowerer.checker.signatureDeclaration(sigs[0]);
+    if (decl === undefined || !(ts.isFunctionDeclaration(decl) || ts.isFunctionExpression(decl)) ||
+        !isJsSourceFile(decl.getSourceFile()) || !isNodeEsmFile(decl.getSourceFile()) ||
+        decl.parameters.length === 0 ||
+        decl.parameters.some((p) => p.dotDotDotToken !== undefined) ||
+        !bodyReadsArguments(decl))
+        return null;
+    const shapes = paramShapes(lowerer, decl.parameters);
+    const retType = lowerer.checker.getReturnTypeOfSignature(sigs[0]);
+    const ret = retType.flags & ts.TypeFlags.Void ? VOID : lowerer.mapTypeOf(retType) ?? DYN;
+    return funcTypeFromParamShapes([...shapes, { type: DYN, mode: "arguments" }], ret);
+}
 /** The one call signature of a PURE function type — single signature, no
  * properties, no construct signatures, no type parameters, no rest params
  * (declared or synthesized from an `arguments` read). Null for every
@@ -1003,7 +1024,7 @@ export class Lowerer {
                     if (sig) {
                         return {
                             ...fallback,
-                            params: sig.params.filter((p) => p.mode !== "dynRest").map((p) => p.type),
+                            params: sig.params.filter((p) => p.mode !== "dynRest" && p.mode !== "arguments").map((p) => p.type),
                             ret: sig.returnType,
                         };
                     }
@@ -2629,6 +2650,10 @@ export class Lowerer {
                 return true;
             if (ts.isCallExpression(e) && this.runtimeOptionalReduceTypes.has(e))
                 return true;
+            if (ts.isCallExpression(e) && e.arguments.length === 0 &&
+                ts.isPropertyAccessExpression(e.expression) &&
+                e.expression.name.text === "stringify" && this.isStdlibGlobal(e.expression.expression, "JSON"))
+                return true;
             if (ts.isCallExpression(e) &&
                 ts.isPropertyAccessExpression(e.expression) &&
                 (e.expression.name.text === "pop" || e.expression.name.text === "shift") &&
@@ -4364,7 +4389,8 @@ export class Lowerer {
     /** mapType with this Lowerer's registries and (while a generic instance
      * body lowers) type-parameter bindings threaded through. */
     mapTypeOf(t) {
-        return mapType(t, this.typeCtx);
+        const mapped = mapType(t, this.typeCtx);
+        return mapped?.kind === "func" ? jsArgumentsFunctionType(this, t) ?? mapped : mapped;
     }
     /** The one position where a contextual UNION must not be adopted over the
      * expression's own: the LEFT operand of `&&`, `||`, or `??`. Adopting a
@@ -4524,6 +4550,9 @@ export class Lowerer {
         // answers instead.
         const mapped = neverTaintedJsType(this, node, t) ? null : this.mapTypeOf(t);
         if (!mapped) {
+            const argumentsType = jsArgumentsFunctionType(this, t);
+            if (argumentsType !== null)
+                return argumentsType;
             // The checked-dynamic declaration fallback (dynFallbackType): a
             // JAVASCRIPT binding of any inference residue, or a TypeScript
             // binding of genuine checker-`any`, becomes the checked-dynamic
@@ -9491,6 +9520,12 @@ export class Lowerer {
         if (bi.module === "module" && bi.member === "builtinModules") {
             return builtinModulesArrayLit(loc);
         }
+        if (bi.module === "http" && bi.member === "METHODS") {
+            return { kind: "libCall", fn: "http.methods", args: [], type: arrayOf(STRING), loc };
+        }
+        if (bi.module === "http" && bi.member === "STATUS_CODES") {
+            return { kind: "libCall", fn: "http.statusCodes", args: [], type: DYN, loc };
+        }
         // tls.rootCertificates through the namespace: the same runtime-valued
         // constant the named-import read lowers to.
         {