@scriptc/compiler 0.2.2 → 0.2.3

package/dist/frontend/lowering/lower-exprs.js

@@ -11,7 +11,6 @@ import { literalUnionArm } from "../union-discriminants.js";
 import * as ts from "../ts7/adapter.js";
 import { dirname } from "node:path";
 import * as posix from "node:path/posix";
-import { pathToFileURL } from "node:url";
 import { captureContextArguments } from "./function-context.js";
 import { OBJECT_CALLABLE_VALUES } from "./surfaces.js";
 import { wasiGuestPath } from "../../wasi-paths.js";
@@ -54,11 +53,12 @@ import { classSymbolKeyOf } from "./symbol-fields.js";
 import { lowerClassMethodValue } from "./class-method-values.js";
 import { classInstanceOf } from "./class-dynamic-dispatch.js";
 import { lowerGlobalValue } from "./lower-global-value.js";
+import { importMetaField, isImportMeta } from "./import-meta.js";
 import { lowerClassPrototypeData, lowerClassPrototypeComputedAssignment } from "./class-prototypes.js";
 import { isClassCallback } from "./class-callbacks.js";
 import { builtinPrototypeMethod, lowerArrayIsArrayValue, lowerCheckedPredicateValue, lowerNumberParserValue, lowerObjectAssignValue, lowerStringCodesValue } from "./lower-builtin-values.js";
 import { lowerArrayFromValue } from "./lower-containers.js";
-import { lowerPerfHooksTypeof } from "./lower-builtins.js";
+import { lowerPerfHooksTypeof, lowerUrlAssignment } from "./lower-builtins.js";
 import { jsBindingHasOpenWrites } from "./lower-stmts.js";
 import { checkedClassInstanceOf } from "./class-construction.js";
 import { lowerModuleNamespaceElement } from "./module-namespace-elements.js";
@@ -125,6 +125,25 @@ function isParseArgsDynProperty(lowerer, expr) {
         return false;
     });
 }
+function isStatFsDynProperty(lowerer, expr) {
+    if (!["type", "bsize", "blocks", "bfree", "bavail", "files", "ffree", "bigint"].includes(expr.name.text))
+        return false;
+    const symbol = lowerer.checker.getSymbolAtLocation(expr.name);
+    return !!symbol && lowerer.checker.declarationsOf(symbol).some((declaration) => {
+        if (!lowerer.isStdlibFile(declaration.getSourceFile()))
+            return false;
+        const parent = declaration.parent;
+        if (!ts.isInterfaceDeclaration(parent))
+            return false;
+        if (expr.name.text === "bigint" ? parent.name.text !== "StatFsOptions" : !["StatsFsBase", "StatsFs", "BigIntStatsFs"].includes(parent.name.text))
+            return false;
+        for (let node = parent.parent; node; node = node.parent) {
+            if (ts.isModuleDeclaration(node) && ts.isStringLiteral(node.name))
+                return node.name.text === "fs" || node.name.text === "node:fs";
+        }
+        return false;
+    });
+}
 export function lowerExpr(lowerer, expr) {
     if (lowerExprDepth >= LOWER_EXPR_MAX_DEPTH) {
         lowerer.unsupported("SC1090", expr, `expressions nested deeper than ${LOWER_EXPR_MAX_DEPTH} levels`);
@@ -2031,16 +2050,13 @@ function lowerExprInner(lowerer, expr) {
                     return nsUndefRead(lowerer, ambientRoot.text, expr, t);
             }
         }
-        // parseArgs results/tokens live in the checked-dynamic tree. A token
-        // discriminant check narrows its checker type to one anonymous arm,
-        // whose ambient property symbols would otherwise hit SC2020 before
-        // the generic dyn receiver path below. Provenance is limited to the
-        // node:util parseArgs family; every other stdlib member keeps its
-        // ordinary surface fence.
+        // Checked-dynamic stdlib results retain ambient property symbols,
+        // including parseArgs tokens narrowed to anonymous union arms. Only
+        // members owned by these implemented families bypass the stdlib fence.
         const segmentDataSymbol = lowerer.typeOf(expr.expression).getSymbol();
         const segmentDataProperty = segmentDataSymbol?.name === "SegmentData" && lowerer.isStdlibSymbol(segmentDataSymbol) &&
             ["segment", "index", "input", "isWordLike"].includes(expr.name.text);
-        if (isParseArgsDynProperty(lowerer, expr) || segmentDataProperty) {
+        if (isParseArgsDynProperty(lowerer, expr) || isStatFsDynProperty(lowerer, expr) || segmentDataProperty) {
             const recv = lowerer.lowerExpr(expr.expression);
             if (recv.type.kind === "dyn") {
                 const key = {
@@ -2201,38 +2217,7 @@ function moduleFileName(lowerer, sf) {
         : sf.fileName;
 }
 function importMetaProperty(lowerer, expr) {
-    if (!ts.isMetaProperty(expr.expression))
-        return null;
-    const meta = expr.expression;
-    if (meta.keywordToken !== ts.SyntaxKind.ImportKeyword || meta.name.text !== "meta")
-        return null;
-    const sf = expr.getSourceFile();
-    const fileName = moduleFileName(lowerer, sf);
-    switch (expr.name.text) {
-        case "env":
-            return dynUndefinedExpr(locOf(expr));
-        case "url":
-            return {
-                kind: "strLit",
-                value: pathToFileURL(fileName, { windows: lowerer.targetPlatform === "win32" }).href,
-                type: STRING,
-                loc: locOf(expr),
-            };
-        case "filename":
-            return { kind: "strLit", value: fileName, type: STRING, loc: locOf(expr) };
-        case "dirname":
-            return {
-                kind: "strLit",
-                value: lowerer.targetPlatform === "wasi" ? posix.dirname(fileName) : dirname(fileName),
-                type: STRING,
-                loc: locOf(expr),
-            };
-        case "main":
-            return { kind: "boolLit", value: sf === lowerer.entry, type: BOOL, loc: locOf(expr) };
-        default:
-            lowerer.unsupported("SC1090", expr, `'import.meta.${expr.name.text}' (only url, filename, dirname, and main are supported in static ESM)`);
-            return null;
-    }
+    return isImportMeta(expr.expression) ? importMetaField(lowerer, expr, expr.name.text) : null;
 }
 /** `c ? a : b`. An explicit destination constructs each branch at that
  * layout before joining it. Without one, retain the expression's inferred
@@ -4495,6 +4480,12 @@ export function lowerOptionalNumber(lowerer, operand, loc, narrowedNode) {
    * string-key element access (`a["length"]`) and string indexing (`s[0]`
    * typechecks against the lib's index signature; use .charAt) stay out. */
 export function lowerElementAccess(lowerer, expr) {
+    if (isImportMeta(expr.expression)) {
+        const name = lowerer.foldedStringKeyOf(expr.argumentExpression);
+        if (name === null)
+            lowerer.unsupported("SC1090", expr, "import.meta with a runtime-computed key (use a statically-known metadata field)");
+        return importMetaField(lowerer, expr, name);
+    }
     // `a?.[i]`: the guard lowers as an optional-chain step around the
     // plain element read below.
     if (expr.questionDotToken && !lowerer.chainHandled.has(expr)) {
@@ -6591,6 +6582,9 @@ export function lowerBinary(lowerer, expr) {
     if (cacheHas)
         return cacheHas;
     if (op === ts.SyntaxKind.EqualsToken || (op >= ts.SyntaxKind.FirstCompoundAssignment && op <= ts.SyntaxKind.LastCompoundAssignment)) {
+        const urlWrite = lowerUrlAssignment(lowerer, expr);
+        if (urlWrite)
+            return urlWrite;
         if (op === ts.SyntaxKind.EqualsToken) {
             const prototypeWrite = lowerClassPrototypeComputedAssignment(lowerer, expr);
             if (prototypeWrite)