@scriptc/compiler 0.4.5 → 0.4.6

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

@@ -1,3 +1,5 @@
+import { arrayClassMemberOwner, arrayClassReceiver, lowerArrayClassStaticCall, } from "./builtins/array-classes.js";
+import { structuralCallInstance } from "./structural-instances.js";
 import { checkedPrivateMethodReceiver, privateNameClass } from "./private-brands.js";
 import { assertFunctionAliasOf } from "./lower-assert.js";
 import { keyedHelperName } from "./stable-names.js";
@@ -19,6 +21,9 @@ import { lowerArrayCallbackCall } from "./containers/array-callback-call.js";
 import { dynUndefinedExpr, nodeThrowExpr, countedFor, numLit, varRef } from "../../ir/build.js";
 import { lowerBuiltinCall } from "./builtin-calls.js";
 import { threadsImportOf } from "../threads-import.js";
+import { nodeApiCalleeOf } from "../node-api-import.js";
+import { lowerIslandSuperCall, lowerIslandSuperMethodCall } from "./lower-node-island.js";
+import { lowerNodeApiCall } from "./lower-node-island.js";
 import { adaptZeroArgTimerCallback, lowerTimersMemberCall, TIMER_MODULE_MEMBERS, } from "./lower-timers.js";
 import { lowerMockTimersElementCall } from "./lower-test.js";
 import { objectEnumerationReceiver } from "./object-enumeration-receiver.js";
@@ -97,10 +102,28 @@ import { isThisParameter } from "./call-signatures.js";
 import { dynamicOverloadChoice } from "./overload-choice.js";
 import { lowerStringIteratorValue } from "./iterator-adapters.js";
 import { checkedArmExtraction } from "./coercions/unions.js";
-import { maybePromiseReturnStmt, promiseArmedUnionOf } from "./maybe-promise.js";
+import { maybePromiseReturnStmt, promiseArmedUnionOf, promiseOrUnitUnionOf, } from "./maybe-promise.js";
 import { requireObjLitGenericReceiver, objLitGenericFnNodeOf, objLitGenericFnInfoOf, genericCallInstance, } from "./generic-functions.js";
 import { codeGenerationCalleeOf, lowerCodeGenerationCall } from "./code-generation.js";
+import { lowerRecordInheritedCall } from "./record-inherited.js";
 const ZLIB_STREAM_METHODS = new Set(["flush", "params", "close", "reset"]);
+/** The node:util member a `(0, member)` callee names, or null. */
+function indirectUtilCalleeOf(lowerer, callee) {
+    let e = callee;
+    while (ts.isParenthesizedExpression(e))
+        e = e.expression;
+    if (!ts.isBinaryExpression(e) ||
+        e.operatorToken.kind !== ts.SyntaxKind.CommaToken ||
+        !ts.isNumericLiteral(e.left))
+        return null;
+    const target = e.right;
+    const bi = ts.isIdentifier(target)
+        ? lowerer.builtinImportOf(target)
+        : ts.isPropertyAccessExpression(target) && !target.questionDotToken
+            ? lowerer.builtinMemberOf(target)
+            : null;
+    return bi?.module === "util" ? bi : null;
+}
 /** `Object.defineProperty(target, ...)`, `Object.defineProperties`,
  * `Reflect.defineProperty`, and `target.__defineGetter__/__defineSetter__`
  * over a target that may hold an Error can install an accessor over an
@@ -190,6 +213,22 @@ export function lowerCall(lowerer, expr) {
         if (codeGeneration !== null)
             return lowerCodeGenerationCall(lowerer, expr, codeGeneration);
     }
+    // @scriptc/node call/callSync: a call into the Node island helper
+    // (lower-node-island.ts).
+    {
+        const nodeApi = nodeApiCalleeOf(lowerer.program, expr.expression);
+        if (nodeApi !== null)
+            return lowerNodeApiCall(lowerer, expr, nodeApi);
+    }
+    // `(0, util_1.inspect)(value)`: TypeScript's CommonJS output calls a
+    // named import through a comma expression, which leaves the call's
+    // receiver undefined. node:util's functions do not read their receiver,
+    // so the call lowers as the direct one.
+    {
+        const util = indirectUtilCalleeOf(lowerer, expr.expression);
+        if (util)
+            return lowerBuiltinCall(lowerer, expr, util, loc);
+    }
     // The deprecated Buffer(...) call (containers/bytes.ts). The checker
     // types it `any`, so the bytes cross as a checked-dynamic value, which
     // keeps the Buffer brand for inspection.
@@ -318,6 +357,13 @@ export function lowerCall(lowerer, expr) {
         if (timeoutOptional)
             return timeoutOptional;
     }
+    // `Error.captureStackTrace?.(this, this.constructor)`: Node always has it.
+    if (ts.isPropertyAccessExpression(expr.expression) &&
+        (expr.questionDotToken || expr.expression.questionDotToken)) {
+        const captured = lowerErrorCaptureStackTraceCall(lowerer, expr, expr.expression);
+        if (captured)
+            return captured;
+    }
     // `req.session?.m(...)` remains absent on compatibility requests. Live
     // `req.stream` calls now pass through the normal optional-chain and h2
     // stream lowering using lowerServerProperty's checked getter.
@@ -375,12 +421,18 @@ export function lowerCall(lowerer, expr) {
         const superCall = lowerer.ctx.superCall;
         if (superCall)
             return superCall(expr);
+        const island = lowerIslandSuperCall(lowerer, expr);
+        if (island)
+            return island;
         lowerer.unsupported("SC1090", expr, "super() calls anywhere but as a top-level constructor statement");
     }
     // super.method(...): a DIRECT (never virtual) call of the base chain's
     // implementation over the same `this` — JS's super dispatch exactly.
     if (ts.isPropertyAccessExpression(expr.expression) &&
         expr.expression.expression.kind === ts.SyntaxKind.SuperKeyword) {
+        const island = lowerIslandSuperMethodCall(lowerer, expr, expr.expression);
+        if (island)
+            return island;
         return lowerer.lowerSuperMethodCall(expr, expr.expression);
     }
     // `value.#m(...)` on a checked-dynamic value (`this` in a JavaScript
@@ -1012,6 +1064,16 @@ export function lowerCall(lowerer, expr) {
             const sig = generic ? null : lowerer.fnSigOf(expr.expression);
             if (sig &&
                 !(jsSpreadArgs && spreadNeedsRuntimeArity(lowerer, sig.params, expr.arguments.nodes))) {
+                const layout = structuralCallInstance(lowerer, expr, sig);
+                if (layout) {
+                    return reconcileOverloadReturn(lowerer, expr, {
+                        kind: "call",
+                        callee: layout.name,
+                        args: lowerer.completeArgs(expr.arguments.nodes, layout.params, loc, expr),
+                        type: layout.returnType,
+                        loc,
+                    });
+                }
                 lowerer.noteEdge(sig.name);
                 const args = lowerer.completeArgs(expr.arguments.nodes, sig.params, loc, expr);
                 const symbol = lowerer.resolveValueSymbol(expr.expression);
@@ -1323,6 +1385,9 @@ export function lowerCall(lowerer, expr) {
             // Union receivers whose every arm has a text — the ngrok
             // `(chunk: Buffer | string) => chunk.toString()` idiom.
             lowerUnionToStringCall(lowerer, expr, expr.expression) ??
+            // Object.prototype's methods called by name on records: an own
+            // callable entry, else the built-in with the record as receiver.
+            lowerRecordInheritedCall(lowerer, expr, expr.expression) ??
             // Object.prototype.toString's default answer on records and
             // override-free program classes — "[object Object]", folded.
             lowerDefaultToStringCall(lowerer, expr, expr.expression) ??
@@ -1376,6 +1441,7 @@ export function lowerCall(lowerer, expr) {
             lowerIteratorStaticFence(lowerer, expr, expr.expression) ??
             lowerObjectStaticCall(lowerer, expr, expr.expression) ??
             lowerObjectFromEntriesCall(lowerer, expr, expr.expression) ??
+            lowerArrayClassStaticCall(lowerer, expr, expr.expression) ??
             lowerArrayFromCall(lowerer, expr, expr.expression) ??
             lowerArrayFromAsyncCall(lowerer, expr, expr.expression) ??
             lowerArrayOfCall(lowerer, expr, expr.expression) ??
@@ -3019,7 +3085,16 @@ function lowerDynReceiverMethodCall(lowerer, call, access, boxTypedTemporary = f
         const binding = ts.isIdentifier(access.expression)
             ? lowerer.builtinImportOf(access.expression)
             : null;
-        if (binding?.module !== "worker_threads" || binding.member !== "parentPort")
+        const parentPort = binding?.module === "worker_threads" && binding.member === "parentPort";
+        // node:path's platform namespaces resolve to ambient declarations the
+        // same way, but their VALUE is the checked-dynamic module object (the
+        // whole namespace), so `win32.join(...)` takes this receiver path
+        // exactly like `path.win32.join(...)`.
+        const pathNamespace = (binding?.module === "path" ||
+            binding?.module === "path/posix" ||
+            binding?.module === "path/win32") &&
+            (binding.member === "posix" || binding.member === "win32");
+        if (!parentPort && !pathNamespace)
             return null;
     }
     // Only checker-untyped receivers: `any`/`unknown`, or the `any[]` an
@@ -4085,9 +4160,10 @@ const DYN_STRING_ONLY_METHODS = new Set([
 /** `Array.isArray(v)` — a real runtime test on `unknown` values (the checked-dynamic tree's
  * array kind: dyn arrays answer true, bytes/objects/scalars false — exactly
  * JS, Uint8Array included), a compile-time constant on statically-typed
- * ones (an `T[]` value IS an array, every other static kind is not; folded
- * only over side-effect-free reads, the `in`-operator discipline; unions
- * fence with the narrow-first hint). Null when the callee isn't THE
+ * ones (an `T[]` value IS an array, every other static kind is not; a
+ * computed argument is evaluated and its value discarded, the
+ * `in`-operator discipline; unions fence with the narrow-first hint). Null
+ * when the callee isn't THE
  * stdlib Array.isArray, so the chain keeps trying. */
 function lowerArrayIsArrayCall(lowerer, call, access) {
     if (call.questionDotToken || access.questionDotToken)
@@ -4106,6 +4182,9 @@ function lowerArrayIsArrayCall(lowerer, call, access) {
     if (arg.kind === "dynCheck" && arg.value.type.kind === "dyn")
         arg = arg.value;
     if (arg.type.kind === "dyn") {
+        // With Node islands the value may be an island array (scope-B NI-4).
+        if (lowerer.nodeIslands !== null)
+            return { kind: "libCall", fn: "nodeIsland.isArray", args: [arg], type: BOOL, loc };
         return { kind: "dynTest", test: "array", value: arg, type: BOOL, loc };
     }
     if (arg.type.kind === "union") {
@@ -4154,10 +4233,24 @@ function lowerArrayIsArrayCall(lowerer, call, access) {
     }
     if (arg.type.kind === "caught")
         return null;
-    if (arg.kind === "varRef" || arg.kind === "recordGet" || arg.kind === "fieldGet") {
-        return { kind: "boolLit", value: lowerer.isArrayValueType(arg.type), type: BOOL, loc };
-    }
-    lowerer.unsupported("SC1090", call, "statically-decided Array.isArray on computed arguments (bind the value to a variable first)");
+    const folded = {
+        kind: "boolLit",
+        value: lowerer.isArrayValueType(arg.type),
+        type: BOOL,
+        loc,
+    };
+    if (arg.kind === "varRef" || arg.kind === "recordGet" || arg.kind === "fieldGet")
+        return folded;
+    // A computed argument (`Array.isArray(make())`, `Array.isArray([1, 2])`)
+    // still answers from its static type, so evaluate the argument for its
+    // effects and discard the value.
+    return {
+        kind: "seqExpr",
+        stmts: [{ kind: "exprStmt", expr: arg, loc }],
+        result: folded,
+        type: BOOL,
+        loc,
+    };
 }
 /** Predicate declarations currently being inlined — re-entrancy guard
  * (a self-recursive guard body would otherwise inline forever). */
@@ -4300,7 +4393,13 @@ function lowerNumberToStringCall(lowerer, call, access) {
 function lowerUnionToStringCall(lowerer, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
-    if (access.name.text !== "toString" || call.arguments.nodes.length !== 0)
+    if (access.name.text !== "toString")
+        return null;
+    // `.toString("utf8")` on `string | Buffer` (a Buffer's default decode;
+    // String.prototype.toString ignores its arguments): the same helper.
+    const args = call.arguments.nodes;
+    const utf8Arg = args.length === 1 && ts.isStringLiteralLike(args[0]) && /^utf-?8$/i.test(args[0].text);
+    if (args.length !== 0 && !utf8Arg)
         return null;
     const recvT = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
     if (recvT?.kind !== "union")
@@ -4308,6 +4407,9 @@ function lowerUnionToStringCall(lowerer, call, access) {
     if (!lowerer.isStdlibMember(access))
         return null;
     const def = lowerer.unions.get(recvT.unionId);
+    if (utf8Arg &&
+        !def?.arms.every((a) => a.kind === "string" || (a.kind === "bytes" && a.elem === "u8")))
+        return null;
     const stringable = def?.arms.every((a) => a.kind === "string" ||
         a.kind === "f64" ||
         a.kind === "bool" ||
@@ -5102,11 +5204,22 @@ function markModuleNsHandlerParams(lowerer, handler, type) {
     }
 }
 export function lowerPromiseMethodCall(lowerer, call, access) {
-    if (call.questionDotToken || access.questionDotToken)
+    if (lowerer.chainBlocked(access, call))
         return null;
     const member = access.name.text;
     if (member !== "then" && member !== "catch" && member !== "finally")
         return null;
+    // A call that ENDS an optional chain (`refreshing?.catch(h)`,
+    // `client?.close().catch(h)`) checker-types as the chain's
+    // undefined-armed union while the body this lowering builds is the
+    // promise arm — `finishOptionalChain` wraps it back into the union.
+    // Take the arm so the handler typing sees the promise it handles.
+    const callResultType = () => {
+        const t = lowerer.mapTypeOf(lowerer.typeOf(call));
+        if (!t || t.kind === "promise")
+            return t ?? undefined;
+        return promiseOrUnitUnionOf(lowerer, t)?.promise ?? t;
+    };
     let recvT = lowerer.mapTypeOf(lowerer.typeOf(access.expression)) ??
         dynFallbackType(lowerer, access.expression, lowerer.typeOf(access.expression));
     // A dynamic-import promise under an unmappable checker type
@@ -5215,7 +5328,25 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
             const rejectedNode = call.arguments.nodes[1];
             const fulfilledAbsent = isAbsentHandler(fulfilledNode);
             const rejectedAbsent = isAbsentHandler(rejectedNode);
-            const resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
+            const resultT = callResultType();
+            // An untyped call in JavaScript whose receiver arrived as a typed
+            // promise (a function instantiated with one): Promise.prototype.then
+            // over the promise as a checked-dynamic value, which shares its
+            // identity.
+            if (resultT?.kind !== "promise" && isJsSourceFile(ts.getSourceFileOfNode(call))) {
+                return {
+                    kind: "dynInvoke",
+                    recv: lowerer.coerceToExpected(receiver, DYN),
+                    method: "then",
+                    calleeName: ts.getTextOfNode(access),
+                    args: [
+                        lowerer.lowerExprExpecting(fulfilledNode, DYN),
+                        lowerer.lowerExprExpecting(rejectedNode, DYN),
+                    ],
+                    type: DYN,
+                    loc,
+                };
+            }
             if (resultT?.kind !== "promise") {
                 lowerer.noLowering("then with these handlers", call, "the result must be a representable promise");
             }
@@ -5544,7 +5675,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
             !(param.kind === "dyn" && (inner.kind === "void" || lowerer.dynConvertible(inner)))) {
             lowerer.unsupported("SC1090", call.arguments.nodes[0], `then handlers whose parameter is not the settled value's type (expected '${lowerer.fmt(inner)}', got '${lowerer.fmt(param)}')`);
         }
-        let resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
+        let resultT = callResultType();
         // JavaScript whose declared result type has no mapping (zod's
         // `Promise.all(items).then((r) => ParseStatus.mergeArray(status, r))`,
         // typed by a .d.ts union): the handler's value settles the promise as
@@ -5871,7 +6002,7 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
         lowerer.unsupported("SC1090", param, "catch handlers with a typed parameter (the reject payload can be any thrown " +
             "value — take `(e)` or `(e: unknown)` and narrow with instanceof)");
     }
-    const resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
+    const resultT = callResultType();
     if (resultT?.kind !== "promise") {
         lowerer.noLowering("catch with this handler's result type", call, "the combined result must be representable — a handler with no return value over a " +
             "non-void promise makes the result 'T | void': return a fallback of the promise's " +
@@ -5911,7 +6042,10 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
                 catchBody = lowerer.lowerStmts(hb.statements.nodes);
             }
             else if (R.kind === "void") {
-                catchBody = [{ kind: "exprStmt", expr: lowerer.lowerExpr(hb), loc: locOf(hb) }];
+                // The handler's value is discarded, so the body lowers as a
+                // statement: `() => undefined` is a pure no-op (a bare unit
+                // literal has no IR value), not an expression to evaluate.
+                catchBody = [lowerer.lowerExprStatement(hb)];
             }
             else {
                 // Bare-expression handler: `(e) => v` (promise results flatten
@@ -7583,7 +7717,13 @@ function lowerObjectStaticCall(lowerer, call, access) {
             return { kind: "libCall", fn: "dyn.freeze", args: [value], type: DYN, loc: locOf(call) };
         }
         if (ts.isObjectLiteralExpression(inner) || ts.isArrayLiteralExpression(inner)) {
-            return value; // fresh — freeze is identity here, honestly
+            // A fresh literal can still reach untyped code, which observes and
+            // must honor its frozen state: records and arrays keep the bit.
+            if (freezableRecordType(lowerer, value.type))
+                return lowerNativeFreeze(lowerer, "record.freeze", value, locOf(call));
+            if (value.type.kind === "array")
+                return lowerNativeFreeze(lowerer, "array.freeze", value, locOf(call));
+            return value;
         }
         if (value.type.kind === "string" ||
             value.type.kind === "f64" ||
@@ -7691,6 +7831,54 @@ function lowerObjectStaticCall(lowerer, call, access) {
         const helper = recordHasOwnHelper(lowerer, receiver.type.shapeId, loc);
         return { kind: "call", callee: helper, args: [receiver, key], type: BOOL, loc };
     }
+    // Object.getOwnPropertyNames over a fixed record: every own property a
+    // scriptc record carries is an enumerable declared field (or an index
+    // signature's overflow), so the answer is exactly Object.keys' walk —
+    // same construction, same interned helper. Tuples keep the fence (an
+    // array's own names include "length" and its indices), and so do
+    // accessor-carrying shapes (the walk cannot list accessor names).
+    if (member === "getOwnPropertyNames") {
+        if (call.arguments.nodes.length !== 1 || ts.isSpreadElement(call.arguments.nodes[0]))
+            return null;
+        const node = call.arguments.nodes[0];
+        let recordT = lowerer.mapTypeOf(lowerer.typeOf(node));
+        const represented = tryLowerExpression(lowerer, node);
+        if (represented?.type.kind === "record")
+            recordT = represented.type;
+        if (recordT?.kind !== "record")
+            return null; // arrays, Maps, classes → the fence
+        const shape = lowerer.shapes.get(recordT.shapeId);
+        if (!shape || shape.tuple)
+            return null; // tuple → the fence
+        fencePerfEntryKeyWalk(lowerer, recordT, call, "Object.getOwnPropertyNames");
+        fenceX509KeyWalk(lowerer, recordT, call, "Object.getOwnPropertyNames");
+        if (shapeHasAccessorSlots(shape)) {
+            lowerer.unsupported("SC1090", call, "Object.getOwnPropertyNames over a shape carrying get/set accessor properties (Node lists the accessor names — the static key walk cannot; read the properties explicitly)");
+        }
+        if (shape.indexValue) {
+            return lowerObjectIterOverIndexShape(lowerer, call, "keys", recordT, shape);
+        }
+        const loc = locOf(call);
+        const enumerated = objectEnumerationReceiver(lowerer, lowerer.lowerExpr(node), recordT, loc);
+        const answer = (receiver) => recordKeysArrayCall(lowerer, receiver, recordT, shape, loc);
+        // A record that kept undeclared properties of its checked source
+        // answers from its live checked view (the array checks back into
+        // string[]).
+        return recordMayKeepSource(lowerer, recordT)
+            ? throughRecordSource(lowerer, enumerated, loc, answer, (view, type) => ({
+                kind: "dynCheck",
+                value: {
+                    kind: "libCall",
+                    fn: "dyn.getOwnPropertyNames",
+                    args: [view],
+                    type: DYN,
+                    loc,
+                },
+                type,
+                loc,
+            }))
+            : answer(enumerated);
+    }
     if (member !== "keys" && member !== "values" && member !== "entries")
         return null;
     if (call.arguments.nodes.length !== 1 || ts.isSpreadElement(call.arguments.nodes[0]))
@@ -8835,7 +9023,14 @@ function lowerObjLitGenericMethodCall(lowerer, call, access) {
                     type: DYN,
                     loc,
                 };
-                return lowerer.coerceInto(call, invoked, lowerer.irTypeOf(call));
+                const resultType = lowerer.irTypeOf(call);
+                // A void method's result stays the runtime's untyped value, as a
+                // call through a non-generic void member's dispatch keeps it: a class
+                // may implement the member with a method that returns a value, which
+                // JavaScript passes on (`console.log(c.publish(m))`).
+                if (resultType.kind === "void")
+                    return invoked;
+                return lowerer.coerceInto(call, invoked, resultType);
             }
         }
         if (onInterface) {
@@ -8889,6 +9084,11 @@ export function lowerObjectMethodCall(lowerer, call, access) {
         : null;
     if (specializedReceiver)
         mappedReceiver = specializedReceiver.type;
+    // A member declared by a class that extends Array, called on an instance
+    // (whose type maps to its array): the class's own method.
+    const arrayClassOwner = mappedReceiver?.kind === "array" ? arrayClassMemberOwner(lowerer, access) : null;
+    if (arrayClassOwner !== null)
+        mappedReceiver = { kind: "object", className: arrayClassOwner.def.name };
     if (mappedReceiver?.kind === "union") {
         const dispatched = lowerUnionObjectMethodCall(lowerer, call, access, mappedReceiver) ??
             lowerUnionObjectDynFieldCall(lowerer, call, access, mappedReceiver);
@@ -8918,6 +9118,8 @@ export function lowerObjectMethodCall(lowerer, call, access) {
     if (receiverIr === null)
         return null;
     const lowerReceiver = () => {
+        if (arrayClassOwner !== null)
+            return arrayClassReceiver(lowerer, arrayClassOwner, lowerer.lowerExpr(access.expression), access.expression);
         const receiver = specializedReceiver ?? lowerer.lowerExpr(access.expression);
         const optional = lowerer.runtimeOptionalPropertyReceiver(access.expression, receiver, receiverIr, access.name.text);
         if (optional !== null)
@@ -8931,9 +9133,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
             ? lowerer.coerceInto(access.expression, receiver, receiverIr)
             : receiver;
     };
-    const info = lowerer.classes.get(receiverIr.className);
-    if (!info)
-        lowerer.flushDeferredClass(receiverIr.className);
+    const info = lowerer.classes.get(receiverIr.className) ?? lowerer.flushDeferredClass(receiverIr.className);
     const found = info ? lowerer.findMethodOn(info, access.name.text) : null;
     // The zlib stream members (flush/params/close/reset) are declared on
     // the zlib classes; their receivers are runtime Transform streams.
@@ -9253,11 +9453,9 @@ function lowerUnionObjectMethodCall(lowerer, call, access, receiverT) {
     const method = access.name.text;
     const plans = [];
     for (const arm of def.arms) {
-        const info = lowerer.classes.get(arm.className);
-        if (!info) {
-            lowerer.flushDeferredClass(arm.className);
+        const info = lowerer.classes.get(arm.className) ?? lowerer.flushDeferredClass(arm.className);
+        if (!info)
             return null;
-        }
         const found = lowerer.findMethodOn(info, method);
         if (!found)
             return null;