@scriptc/compiler 0.4.3 → 0.4.5

package/dist/frontend/lowering/expressions/property-access.js

@@ -1,17 +1,21 @@
 /* Property reads (`a.b`): lowerExprInner's property-access branch, intrinsic and union properties, field reads and targets, and match-group reads. */
+import { indexedUnionArms, lowerIndexedUnionMember } from "../indexed-unions.js";
 import { keyedHelperName } from "../stable-names.js";
+import { builtinNamespaceValue } from "../builtin-namespaces.js";
 import { staticallySelected } from "../static-typeof.js";
 import * as ts from "../../ts7/adapter.js";
 import { lowerHistogramProperty } from "../builtins/performance.js";
 import { staticFunctionNameRead } from "../static-function-names.js";
 import { typedArgumentsArity } from "../typed-arguments.js";
 import { isThisParameter } from "../call-signatures.js";
+import { argumentCountSlot, contextualCallCount, usedAsValue } from "../argument-counts.js";
 import { checkedPrivateValue, localPrivateBrandClass, privateNameClass, } from "../private-brands.js";
 import { PoisonError, jsFuncNameOf, neverTaintedJsType, own } from "../lowerer.js";
 import { ARRAY_METHODS, MAP_METHODS, NARROW_FIRST, OBJECT_CALLABLE_VALUES, SET_METHODS, STDLIB_SURFACE, STRING_INDEX_METHODS, STR_METHODS, isChildSurfaceMember, stdlibGlobalNameOf, } from "../surfaces.js";
 import { isGenericCallableMemberType, isLegacyUrlSymbol, isOsConstantsType, isParseArgsDynTypeName, } from "../../type-mapper.js";
 import { BOOL, BYTES_ELEMENT_NAME, BYTES_U8, DYN, F64, NULL_T, SEARCH_PARAMS_T, STRING, SYMBOL_T, UNDEFINED_T, arrayOf, canBoxFuncIntoDyn, funcOf, isDynTypedRefType, isUnitType, typeEquals, typeKey, unionContainerArmsOk, BYTES_ELEMENT_SIZE, } from "../../../ir/ir.js";
 import { lowerNavigatorMember } from "../builtins/navigator.js";
+import { lowerX509PublicKey } from "../builtins/x509.js";
 import { NODE_COMPAT_VERSION } from "../builtins/process.js";
 import { inlineNamespaceRequireOf, lowerWithInlineRequireInit, wholeExportValue, } from "../cjs-inline-require.js";
 import { cjsAccessorCall, constInitializerOf, exactUnionWidening, hasClassPayload, lowerExpr, matchAllCallbackRegexOf, matchAllRegexOf, namedCaptureGroupsOfPattern, primitiveCtorClosure, recordKeyResultOk, representedClassFieldTarget, staticRegexPatternOf, } from "../lower-exprs.js";
@@ -31,11 +35,13 @@ import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../.
 import { typedArrayLacksMember } from "../builtins/typed-array-members.js";
 import { TEMPORAL_GLOBAL } from "../../builtin-modules.js";
 import { tryLowerExpression } from "./try-lower-expression.js";
+import { DATE_METHOD_HINT } from "../builtins/dates.js";
 import { cjsClassExprWholeExportOf, cjsExportAssignmentOf, cjsExportDiscardReason, isCjsExportTableLiteral, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, isNodeEsmFile, locOf, } from "../../program.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, contextualUndefReadType, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead, } from "../lower-namespaces.js";
 import { expandoMemberRead } from "../lower-expando.js";
 import { lowerProtocolPropertyRead } from "../class-protocol-dispatch.js";
 import { lowerReadlineProperty } from "../builtins/readline.js";
+import { lowerAsyncLocalStorageProperty } from "../builtins/async-context.js";
 import { lowerEventStaticProperty } from "../builtins/numbers.js";
 import { lowerStreamProperty, lowerStreamStateProperty, streamSidesOf } from "../lower-stream.js";
 import { lowerValueStreamProperty } from "../builtins/hash-stream.js";
@@ -46,12 +52,16 @@ import { nullishGenericBindingUnitOf } from "../binding-analysis.js";
 import { blockedBindingUseDiag } from "../../../diagnostics/diagnostic.js";
 import { npmStaticPackageOfPath } from "../../npm-static.js";
 import { importMetaField, isImportMeta } from "../import-meta.js";
+import { createRequireCalleeFileOf } from "../builtins/module-bindings.js";
+import { createRequireResolveFenceValue } from "../builtins/module-resolution.js";
 import { builtinPrototypeMethod, lowerArrayIsArrayValue, lowerCheckedPredicateValue, lowerNumberParserValue, lowerObjectAssignValue, lowerStringCodesValue, } from "../lower-builtin-values.js";
 import { lowerArrayFromValue } from "../containers/array-construction.js";
+import { lowerBufferPrototypeMember } from "../containers/bytes.js";
 import { lowerNetAddressStaticRead } from "../builtins/net-address.js";
 import { STATS_TYPE_TESTS } from "../builtins/filesystem.js";
 import { arrayValueRead, arrayValueType } from "../array-values.js";
 import { lowerClassMethodValue } from "../class-method-values.js";
+import { reflectMemberValue } from "../builtins/reflection.js";
 import { objLitGenericFnInfoOf, objLitGenericFnNodeOf, requireObjLitGenericReceiver, } from "../generic-functions.js";
 import { narrowStoredClassValue, structuralReadType } from "../class-unions.js";
 import { InternalCompilerError } from "../../../errors.js";
@@ -155,6 +165,16 @@ const DGRAM_METHOD_VALUES = new Set([
     "ref",
     "unref",
 ]);
+function isCreateRequireResolveValue(lowerer, expr) {
+    let resolve = expr;
+    if (expr.name.text === "paths" &&
+        ts.isPropertyAccessExpression(expr.expression) &&
+        !expr.expression.questionDotToken)
+        resolve = expr.expression;
+    return (ts.isPropertyAccessExpression(resolve) &&
+        resolve.name.text === "resolve" &&
+        createRequireCalleeFileOf(lowerer, resolve.expression) !== null);
+}
 export function lowerPropertyAccessExpr(lowerer, expr, loc) {
     // `value.#x` on a checked-dynamic value, or on a checked extraction of
     // one: the field of the brand-checked receiver (checkedPrivateValue).
@@ -179,6 +199,11 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
     const navigator = lowerNavigatorMember(lowerer, expr, NODE_COMPAT_VERSION);
     if (navigator)
         return navigator;
+    {
+        const member = lowerBufferPrototypeMember(lowerer, expr);
+        if (member)
+            return member;
+    }
     // A dgram socket's method read as a value in JavaScript (`emit:
     // socket.emit.bind(socket)`): the socket crosses as its checked-dynamic
     // handle, whose methods are function values that dispatch on their
@@ -210,6 +235,12 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
         if (reading)
             return reading;
     }
+    // An X509Certificate's publicKey KeyObject.
+    {
+        const publicKey = lowerX509PublicKey(lowerer, expr);
+        if (publicKey)
+            return publicKey;
+    }
     // `.length` of a forwarded fixed tuple (a typed `arguments`, a tuple
     // rest parameter, an alias of either): the signature's arity.
     if (expr.name.text === "length" && !expr.questionDotToken) {
@@ -367,6 +398,8 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
         };
     }
     if (lowerer.stdlibGlobalMember(expr, "Object") === "freeze") {
+        // Object.freeze as a value can freeze any untyped value it is passed.
+        lowerer.untypedIntegrity = true;
         const name = "%builtin.Object.freeze";
         if (!lowerer.liftedFns.some((fn) => fn.name === name))
             lowerer.liftedFns.push({
@@ -540,7 +573,21 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
             if (fixedArity) {
                 // A `this` parameter is type-only: callers never pass it.
                 const declared = fn.parameters.nodes.filter((p) => !isThisParameter(p)).length;
-                const count = Math.max(declared, contextualArgumentCount(lowerer, fn) ?? 0);
+                const contextual = contextualArgumentCount(lowerer, fn);
+                if (contextual === "varies") {
+                    lowerer.unsupported("SC1090", expr, "'arguments.length' in function expressions passed where the expected function type has optional or rest parameters (the count varies per call)");
+                }
+                // A top-level declaration also used as a value reads the count its
+                // caller stored (argument-counts.ts).
+                if (ts.isFunctionDeclaration(fn) && lowerer.ctx.argumentCount !== undefined)
+                    return varRef(lowerer.ctx.argumentCount.id, F64, loc);
+                if ((ts.isFunctionDeclaration(fn) || ts.isMethodDeclaration(fn)) &&
+                    usedAsValue(lowerer, fn)) {
+                    lowerer.unsupported("SC1090", expr, ts.isFunctionDeclaration(fn) && argumentCountSlot(lowerer, fn) !== null
+                        ? "'arguments.length' in an arrow function inside a function that is also used as a value"
+                        : "'arguments.length' in methods, nested, async and generator functions used as values (a caller of the value can pass more arguments than the function declares)");
+                }
+                const count = Math.max(declared, contextual ?? 0);
                 // Calls through the expression's own name pass the declared count,
                 // calls through the wider slot pass more: no constant answers both.
                 if (count > declared && referencesOwnName(lowerer, fn)) {
@@ -684,6 +731,8 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
         // diagnostics_channel Channel receivers — name/hasSubscribers
         // over the f64 channel handle.
         lowerer.lowerDiagnosticsChannelProperty(expr) ??
+        // AsyncLocalStorage receivers — the name option.
+        lowerAsyncLocalStorageProperty(lowerer, expr) ??
         // readline Interface receivers — the history and option members
         // over the f64 interface handle.
         lowerReadlineProperty(lowerer, expr) ??
@@ -925,11 +974,17 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
             probed?.type.kind === "func" &&
             canBoxFuncIntoDyn(probed.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
             const fnName = jsFuncNameOf(expr.expression);
+            // A builtin function value whose length is not its adapter's
+            // parameter count (`Math.max.length` is 2).
+            const fnLength = probed.kind === "closure"
+                ? lowerer.builtinCallableValueLengths.get(probed.fnName)
+                : undefined;
             const boxed = {
                 kind: "dynFrom",
                 value: probed,
                 type: DYN,
                 ...(fnName !== null ? { fnName } : {}),
+                ...(fnLength !== undefined ? { fnLength } : {}),
                 loc,
             };
             const key = {
@@ -1068,6 +1123,11 @@ export function lowerPropertyAccessExpr(lowerer, expr, loc) {
             return declared && declared.kind !== "void" ? lowerer.coerceToExpected(read, declared) : read;
         }
     }
+    // A createRequire loader's resolve read as a value (passed on, or
+    // picked by `??`): resolution happens at build time, so only calls
+    // with a literal specifier lower.
+    if (isCreateRequireResolveValue(lowerer, expr))
+        return createRequireResolveFenceValue(lowerer, expr, loc);
     // The lib fence's PROPERTY chokepoint: a stdlib-declared member that
     // no lowering above claimed ([1,2].entries, Math.SQRT2, Promise.all,
     // re.exec as a value, ...) reports SC2020 here.
@@ -1418,15 +1478,8 @@ export function lowerIntrinsicProperty(lowerer, expr) {
             return primitiveCtorClosure(lowerer, name, locOf(expr), isJsSourceFile(ts.getSourceFileOfNode(expr)));
         }
     }
-    if (lowerer.stdlibGlobalMember(expr, "Reflect") === "ownKeys") {
-        const value = lowerer.lowerNativeCallableValue({
-            fn: "dyn.ownKeys",
-            params: [DYN],
-            result: DYN,
-            valueParams: [{ mode: "required", type: DYN }],
-        }, "Reflect.ownKeys", locOf(expr));
-        return { kind: "dynFrom", value, fnName: "ownKeys", type: DYN, loc: locOf(expr) };
-    }
+    if (lowerer.stdlibGlobalMember(expr, "Reflect") === "ownKeys")
+        return reflectMemberValue(lowerer, "ownKeys", locOf(expr));
     if (lowerer.chainBlocked(expr))
         return null;
     // Object.prototype.constructor: the Object constructor value.
@@ -1523,6 +1576,27 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         return lowerNumberParserValue(lowerer, numberMember, locOf(expr));
     if (lowerer.stdlibGlobalMember(expr, "Buffer") === "poolSize")
         return { kind: "libCall", fn: "buffer.poolSize", args: [], type: F64, loc: locOf(expr) };
+    {
+        const member = lowerer.stdlibGlobalMember(expr, "Buffer");
+        if (member === "name")
+            return { kind: "strLit", value: "Buffer", type: STRING, loc: locOf(expr) };
+        if (member === "length")
+            return numLit(3, locOf(expr));
+        // JavaScript reads the statics from the Buffer function's value, so
+        // each has one identity and Node's name and length.
+        if (member !== null &&
+            BUFFER_VALUE_STATICS.has(member) &&
+            isJsSourceFile(ts.getSourceFileOfNode(expr))) {
+            const loc = locOf(expr);
+            return {
+                kind: "libCall",
+                fn: "buffer.staticValue",
+                args: [{ kind: "strLit", value: member, type: STRING, loc }],
+                type: DYN,
+                loc,
+            };
+        }
+    }
     const netAddressStatic = lowerNetAddressStaticRead(lowerer, expr);
     if (netAddressStatic)
         return netAddressStatic;
@@ -1727,6 +1801,10 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         lowerer.noLowering(`Stats.${name}`, expr, "isFile(), isDirectory(), isSymbolicLink(), isBlockDevice(), isCharacterDevice(), isFIFO(), isSocket(), dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks, atimeMs, mtimeMs, ctimeMs, birthtimeMs, atime, mtime, ctime, and birthtime are the supported Stats members", lowerer.checker.getSymbolAtLocation(expr.name));
     }
     if (kind === "date") {
+        // A Date held as a checked-dynamic value (a Date a JavaScript file
+        // constructs) answers its method values at run time.
+        if (tryLowerExpression(lowerer, expr.expression)?.type.kind === "dyn")
+            return null;
         const methods = new Set([
             "getTime",
             "valueOf",
@@ -1752,7 +1830,7 @@ export function lowerIntrinsicProperty(lowerer, expr) {
         if (methods.has(name)) {
             lowerer.unsupported("SC1090", expr, `Date methods as values (call '${name}' directly)`);
         }
-        lowerer.noLowering(`Date.prototype.${name}`, expr, "getTime(), valueOf(), toISOString(), the local/UTC calendar getters, and getTimezoneOffset() are supported; Date setters and locale/string formatters have no lowering", lowerer.checker.getSymbolAtLocation(expr.name));
+        lowerer.noLowering(`Date.prototype.${name}`, expr, DATE_METHOD_HINT, lowerer.checker.getSymbolAtLocation(expr.name));
     }
     if (kind === "symbol") {
         const loc = locOf(expr);
@@ -2937,6 +3015,14 @@ export function lowerUnionProperty(lowerer, expr) {
             loc: locOf(expr),
         };
     }
+    // A union of typed arrays and number arrays: each arm's own length
+    // (and, for typed arrays only, byteLength, byteOffset, BYTES_PER_ELEMENT).
+    const indexedArms = indexedUnionArms(lowerer, value.type);
+    if (indexedArms) {
+        const member = lowerIndexedUnionMember(lowerer, value, indexedArms, field, locOf(expr));
+        if (member)
+            return member;
+    }
     lowerer.unsupported("SC1090", expr, `reading '${field}' on a union-typed value (every arm must be an object/record ` +
         `with a same-typed field '${field}'; ` +
         `${NARROW_FIRST})`);
@@ -3658,6 +3744,8 @@ export function builtinFunctionValue(name, loc) {
 export function builtinGlobalValue(canonical, loc, js = false) {
     if (js && GLOBAL_FUNCTION_VALUES.has(canonical))
         return builtinFunctionValue(canonical, loc);
+    if (js && canonical === "Buffer")
+        return { kind: "libCall", fn: "buffer.constructor", args: [], type: DYN, loc };
     if (GLOBAL_CONSTRUCTOR_VALUES.has(canonical)) {
         return {
             kind: "libCall",
@@ -3694,6 +3782,11 @@ const BUILTIN_VALUE_REFLECTION = new Set([
  * which would observe or change members the interned value does not
  * model. */
 export function builtinGlobalValueAt(lowerer, expr, canonical, loc, js) {
+    // A namespace object models its own properties, so member reads and
+    // reflection read it like any object.
+    const namespace = js ? builtinNamespaceValue(lowerer, canonical, loc) : null;
+    if (namespace !== null)
+        return namespace;
     if (readsBuiltinGlobalMembers(expr))
         return null;
     const value = builtinGlobalValue(canonical, loc, js);
@@ -3761,6 +3854,21 @@ function fenceBuiltinConstructorStaticRead(lowerer, access) {
         lowerer.stdlibMemberFence(access);
     return null;
 }
+/** The Buffer statics the Buffer function's value holds
+ * (scr_buffer_constructor_value). */
+const BUFFER_VALUE_STATICS = new Set([
+    "from",
+    "copyBytesFrom",
+    "of",
+    "alloc",
+    "allocUnsafe",
+    "allocUnsafeSlow",
+    "isBuffer",
+    "compare",
+    "isEncoding",
+    "concat",
+    "byteLength",
+]);
 /** Object.prototype members a plain record inherits, read as values. */
 const OBJECT_PROTOTYPE_VALUE_READS = new Set([
     "constructor",
@@ -3928,30 +4036,9 @@ function referencesOwnName(lowerer, fn) {
     return found;
 }
 /** The argument count every caller passes a function expression whose
- * value flows into one fixed-arity function type, an array method's
- * callback or an annotated slot: that type's parameter count. Null when
- * there is no such type or its arity varies. */
+ * value flows into a function type (argument-counts.ts contextualCallCount). */
 function contextualArgumentCount(lowerer, fn) {
-    if (!ts.isFunctionExpression(fn))
-        return null;
-    const contextual = lowerer.checker.getContextualType(fn);
-    if (contextual === undefined)
-        return null;
-    const signatures = lowerer.checker.getCallSignatures(lowerer.checker.getNonNullableType(contextual));
-    if (signatures.length !== 1)
-        return null;
-    const declaration = signatures[0].declaration;
-    if (declaration === undefined)
-        return null;
-    let count = 0;
-    for (const parameter of (declaration.parameters?.nodes ?? [])) {
-        if (isThisParameter(parameter))
-            continue;
-        if (parameter.questionToken || parameter.initializer || parameter.dotDotDotToken)
-            return null;
-        count++;
-    }
-    return count;
+    return ts.isFunctionExpression(fn) ? contextualCallCount(lowerer, fn) : null;
 }
 /** The property names the program assigns on the global object, through
  * `globalThis` or a binding of its type (`(_a = globalThis).x = v`). */