@scriptc/compiler 0.3.5 → 0.4.0

package/dist/frontend/lowering/divergences.js

@@ -13,8 +13,9 @@
 import * as ts from "../ts7/adapter.js";
 import { locOf } from "../program.js";
 import { isNodeModulesPath } from "../resolve.js";
-import { dateLiteralDivergenceDiag, keyOrderDivergenceDiag, localeCompareDivergenceDiag, unrelatedClassCastDivergenceDiag, widthCopyDivergenceDiag, } from "../../diagnostics/diagnostic.js";
+import { keyOrderDivergenceDiag, localeCompareDivergenceDiag, unrelatedClassCastDivergenceDiag, widthCopyDivergenceDiag, } from "../../diagnostics/diagnostic.js";
 import { isCollationCovered } from "./collation-repertoire.js";
+import { keptIdentityAssertion } from "./assertion-identity.js";
 export function scanDivergences(lowerer, files) {
     const own = files.filter((sf) => !sf.isDeclarationFile && !sf.fileName.endsWith(".json") && !isNodeModulesPath(sf.fileName));
     const out = [];
@@ -23,10 +24,15 @@ export function scanDivergences(lowerer, files) {
     const fnsByName = new Map();
     const calls = [];
     const typedDecls = [];
+    /** `const v = r as T` (also through `unknown`): the binding views `r`. */
+    const castDecls = [];
+    /** `v = r` into a binding declared elsewhere with a type. */
+    const assignments = [];
+    /** `const list: T[] = [r, ...]`: each existing element is stored as T. */
+    const arrayDecls = [];
     const literals = [];
     const observers = [];
     const casts = [];
-    const dates = [];
     const localeCompares = [];
     /** binding name → member names assigned through it (`q.a = 2`). */
     const assignedMembers = new Map();
@@ -35,7 +41,7 @@ export function scanDivergences(lowerer, files) {
             node.body !== undefined &&
             node.name !== undefined &&
             ts.isIdentifier(node.name) &&
-            node.parameters.length > 0) {
+            node.parameters.nodes.length > 0) {
             const list = fnsByName.get(node.name.text) ?? [];
             list.push(node);
             fnsByName.set(node.name.text, list);
@@ -45,15 +51,15 @@ export function scanDivergences(lowerer, files) {
             const callee = node.expression;
             if (ts.isPropertyAccessExpression(callee)) {
                 const member = callee.name.text;
-                if (member === "localeCompare" && node.arguments.length === 1)
+                if (member === "localeCompare" && node.arguments.nodes.length === 1)
                     localeCompares.push(node);
                 const recv = callee.expression;
                 if (ts.isIdentifier(recv)) {
                     if ((recv.text === "JSON" && member === "stringify") ||
                         (recv.text === "Object" &&
                             (member === "keys" || member === "values" || member === "entries"))) {
-                        if (node.arguments[0] !== undefined)
-                            observers.push(node.arguments[0]);
+                        if (node.arguments.nodes[0] !== undefined)
+                            observers.push(node.arguments.nodes[0]);
                     }
                     else if (recv.text === "console" &&
                         (member === "log" ||
@@ -62,24 +68,13 @@ export function scanDivergences(lowerer, files) {
                             member === "error" ||
                             member === "debug" ||
                             member === "dir")) {
-                        for (const a of node.arguments)
+                        for (const a of node.arguments.nodes)
                             if (!isLiteralLike(a))
                                 observers.push(a);
                     }
-                    else if (recv.text === "Date" && member === "parse") {
-                        if (node.arguments[0] !== undefined)
-                            dates.push({ call: node, arg: node.arguments[0] });
-                    }
                 }
             }
         }
-        else if (ts.isNewExpression(node)) {
-            if (ts.isIdentifier(node.expression) &&
-                node.expression.text === "Date" &&
-                node.arguments?.length === 1) {
-                dates.push({ call: node, arg: node.arguments[0] });
-            }
-        }
         else if (ts.isForInStatement(node)) {
             observers.push(node.expression);
         }
@@ -89,14 +84,30 @@ export function scanDivergences(lowerer, files) {
                 isExistingObjectExpression(node.initializer) &&
                 ts.isIdentifier(node.name))
                 typedDecls.push(node);
+            else if (node.initializer !== undefined && ts.isIdentifier(node.name)) {
+                const cast = castView(node.initializer);
+                if (cast !== null && node.type === undefined)
+                    castDecls.push({ decl: node, ...cast });
+                const element = node.type === undefined ? undefined : arrayElementTypeNode(node.type);
+                if (element !== undefined &&
+                    ts.isArrayLiteralExpression(node.initializer) &&
+                    node.initializer.elements.nodes.some(isExistingObjectExpression))
+                    arrayDecls.push({ decl: node, element });
+            }
         }
         else if (ts.isObjectLiteralExpression(node)) {
-            if (node.properties.length >= 1 && node.properties.every(isPlainProperty))
+            if (node.properties.nodes.length >= 1 && node.properties.nodes.every(isPlainProperty))
                 literals.push(node);
         }
         else if (ts.isAsExpression(node) || ts.isTypeAssertion(node)) {
             casts.push(node);
         }
+        else if (ts.isBinaryExpression(node) &&
+            node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            ts.isIdentifier(node.left) &&
+            isExistingObjectExpression(node.right)) {
+            assignments.push(node);
+        }
         else if (ts.isBinaryExpression(node) &&
             node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
             ts.isPropertyAccessExpression(node.left) &&
@@ -114,7 +125,7 @@ export function scanDivergences(lowerer, files) {
     const identityUsesOf = (fn) => {
         let uses = usesByFn.get(fn);
         if (uses === undefined) {
-            uses = fn.parameters.map((p) => ts.isIdentifier(p.name) && fn.body !== undefined ? identityUse(fn.body, p.name.text) : null);
+            uses = fn.parameters.nodes.map((p) => ts.isIdentifier(p.name) && fn.body !== undefined ? identityUse(fn.body, p.name.text) : null);
             usesByFn.set(fn, uses);
         }
         return uses;
@@ -131,14 +142,14 @@ export function scanDivergences(lowerer, files) {
         const signature = safely(() => checker.getResolvedSignature(call));
         if (signature === undefined)
             continue;
-        const decl = safely(() => checker.signatureDeclaration(signature));
+        const decl = safely(() => signature.declaration);
         if (decl === undefined || !candidates.includes(decl))
             continue;
         const fn = decl;
         const uses = identityUsesOf(fn);
-        call.arguments.forEach((arg, i) => {
+        call.arguments.nodes.forEach((arg, i) => {
             const use = uses[i];
-            const param = fn.parameters[i];
+            const param = fn.parameters.nodes[i];
             if (use === null || use === undefined || param === undefined || param.type === undefined)
                 return;
             if (!isExistingObjectExpression(arg))
@@ -162,6 +173,59 @@ export function scanDivergences(lowerer, files) {
             continue;
         out.push(widthCopyDivergenceDiag(copy.source, copy.target, use.kind, use.text, "declaration", locOf(decl.initializer)));
     }
+    for (const { decl, source, type } of castDecls) {
+        // An assertion of the global object keeps that object: no copy.
+        if (keptIdentityAssertion(lowerer, decl.initializer) !== undefined)
+            continue;
+        const name = decl.name.text;
+        const scope = enclosingScope(decl);
+        if (scope === undefined)
+            continue;
+        const use = identityUse(scope, name, decl.end);
+        if (use === null)
+            continue;
+        const copy = safely(() => widthCopyBetween(lowerer, source, type));
+        if (copy === undefined || copy === null)
+            continue;
+        out.push(widthCopyDivergenceDiag(copy.source, copy.target, use.kind, use.text, "cast", locOf(source)));
+    }
+    for (const assignment of assignments) {
+        const left = assignment.left;
+        const symbol = safely(() => checker.getSymbolAtLocation(left));
+        if (symbol === undefined)
+            continue;
+        const decl = symbol.declarations.find((d) => ts.isVariableDeclaration(d) && d.type !== undefined);
+        if (decl === undefined)
+            continue;
+        const scope = enclosingScope(decl);
+        if (scope === undefined)
+            continue;
+        const use = identityUse(scope, left.text, assignment.end);
+        if (use === null)
+            continue;
+        const copy = safely(() => widthCopyBetween(lowerer, assignment.right, decl.type));
+        if (copy === undefined || copy === null)
+            continue;
+        out.push(widthCopyDivergenceDiag(copy.source, copy.target, use.kind, use.text, "declaration", locOf(assignment.right)));
+    }
+    for (const { decl, element } of arrayDecls) {
+        const name = decl.name.text;
+        const scope = enclosingScope(decl);
+        if (scope === undefined)
+            continue;
+        const use = elementWrite(scope, name, decl.end);
+        if (use === null)
+            continue;
+        for (const item of decl.initializer.elements.nodes) {
+            if (!isExistingObjectExpression(item))
+                continue;
+            const copy = safely(() => widthCopyBetween(lowerer, item, element));
+            if (copy === undefined || copy === null)
+                continue;
+            out.push(widthCopyDivergenceDiag(copy.source, copy.target, "write", use, "element", locOf(item)));
+            break;
+        }
+    }
     // ── key order: a reordered literal that reaches an order observer ───
     // Local flow only: the observer's argument is the literal itself, or a
     // const/let binding initialized with it in the same file. A type that
@@ -178,12 +242,12 @@ export function scanDivergences(lowerer, files) {
                 lit = inner;
             else if (ts.isIdentifier(inner)) {
                 const symbol = safely(() => checker.getSymbolAtLocation(inner));
-                const decl = symbol === undefined ? undefined : checker.valueDeclarationOf(symbol);
+                const decl = symbol === undefined ? undefined : symbol.valueDeclaration;
                 if (decl !== undefined &&
                     ts.isVariableDeclaration(decl) &&
                     decl.initializer !== undefined &&
                     ts.isObjectLiteralExpression(decl.initializer) &&
-                    decl.getSourceFile() === inner.getSourceFile()) {
+                    ts.getSourceFileOfNode(decl) === ts.getSourceFileOfNode(inner)) {
                     lit = decl.initializer;
                     binding = inner.text;
                 }
@@ -195,10 +259,10 @@ export function scanDivergences(lowerer, files) {
                 continue;
             if (namedObjectDeclaration(checker, contextual) === null)
                 continue;
-            const declared = safely(() => checker.getPropertiesOfType(contextual).map((p) => p.name));
+            const declared = safely(() => checker.getPropertiesOfType(contextual).map((p) => ts.symbolName(p)));
             if (declared === undefined)
                 continue;
-            const written = lit.properties.map((p) => propertyNameText(p));
+            const written = lit.properties.nodes.map((p) => propertyNameText(p));
             const assigned = binding === null ? new Set() : (assignedMembers.get(binding) ?? new Set());
             const finding = keyOrderFinding(lowerer, contextual, declared, written, assigned);
             if (finding === null)
@@ -210,7 +274,7 @@ export function scanDivergences(lowerer, files) {
     // ── one-argument localeCompare over text outside the collation table ─
     for (const call of localeCompares) {
         const access = call.expression;
-        for (const operand of [access.expression, call.arguments[0]]) {
+        for (const operand of [access.expression, call.arguments.nodes[0]]) {
             const text = stringLiteralText(operand);
             if (text !== null && !isCollationCovered(text)) {
                 out.push(localeCompareDivergenceDiag(text, locOf(operand)));
@@ -234,7 +298,7 @@ export function scanDivergences(lowerer, files) {
             fn = fn.parent;
         if (fn === undefined || !ts.isFunctionLike(fn))
             continue;
-        const index = fn.parameters.findIndex((p) => ts.isIdentifier(p.name) && p.name.text === inner.text);
+        const index = fn.parameters.nodes.findIndex((p) => ts.isIdentifier(p.name) && p.name.text === inner.text);
         if (index < 0)
             continue;
         const target = safely(() => classDeclarationOfTypeNode(lowerer, cast.type));
@@ -260,12 +324,12 @@ export function scanDivergences(lowerer, files) {
             if (name === null || !fnsByName.has(name))
                 continue;
             const signature = safely(() => checker.getResolvedSignature(call));
-            const decl = signature === undefined ? undefined : safely(() => checker.signatureDeclaration(signature));
+            const decl = signature === undefined ? undefined : safely(() => signature.declaration);
             const sites = decl === undefined ? undefined : downcasts.get(decl);
             if (sites === undefined)
                 continue;
             for (const site of sites) {
-                const arg = call.arguments[site.index];
+                const arg = call.arguments.nodes[site.index];
                 if (arg === undefined)
                     continue;
                 const argType = safely(() => checker.getTypeAtLocation(arg));
@@ -283,56 +347,8 @@ export function scanDivergences(lowerer, files) {
             }
         }
     }
-    // ── Date strings the native parser does not accept ────────────────
-    for (const { call, arg } of dates) {
-        const callee = ts.isNewExpression(call)
-            ? call.expression
-            : ts.isPropertyAccessExpression(call.expression)
-                ? call.expression.expression
-                : undefined;
-        if (callee === undefined || !lowerer.isStdlibGlobal(callee, "Date"))
-            continue;
-        for (const literal of dateStringLiterals(checker, arg)) {
-            const text = stringLiteralText(literal);
-            if (nativeDateParses(text) || !/\d/.test(text))
-                continue;
-            out.push(dateLiteralDivergenceDiag(text, locOf(literal)));
-        }
-    }
     return out;
 }
-/** The string literals a Date argument can be: the literal itself, or
- * each element of a const array of literals a for-of binding iterates. */
-function dateStringLiterals(checker, arg) {
-    if (stringLiteralText(arg) !== null)
-        return [arg];
-    if (!ts.isIdentifier(arg))
-        return [];
-    const symbol = safely(() => checker.getSymbolAtLocation(arg));
-    const decl = symbol === undefined ? undefined : checker.valueDeclarationOf(symbol);
-    const list = decl?.parent;
-    const loop = list?.parent;
-    if (decl === undefined ||
-        !ts.isVariableDeclaration(decl) ||
-        list === undefined ||
-        loop === undefined ||
-        !ts.isForOfStatement(loop) ||
-        loop.initializer !== list)
-        return [];
-    let iterated = loop.expression;
-    if (ts.isIdentifier(iterated)) {
-        const source = safely(() => checker.getSymbolAtLocation(iterated));
-        const init = source === undefined ? undefined : checker.valueDeclarationOf(source);
-        if (init === undefined || !ts.isVariableDeclaration(init) || init.initializer === undefined)
-            return [];
-        if (init.parent === undefined || (init.parent.flags & ts.NodeFlags.Const) === 0)
-            return [];
-        iterated = init.initializer;
-    }
-    if (!ts.isArrayLiteralExpression(iterated))
-        return [];
-    return iterated.elements.filter((e) => stringLiteralText(e) !== null);
-}
 /** A checker query that fails here only loses a warning. */
 function safely(f) {
     try {
@@ -402,7 +418,7 @@ function identityUse(root, name, from = -1) {
         return cur;
     };
     const textOf = (node) => {
-        const text = node.getText();
+        const text = ts.getTextOfNode(node);
         return text.length > 60 ? `${text.slice(0, 57)}...` : text;
     };
     const visit = (node) => {
@@ -412,7 +428,7 @@ function identityUse(root, name, from = -1) {
             return node.end > from ? undefined : "skip";
         if (node !== root &&
             ts.isFunctionLike(node) &&
-            node.parameters.some((p) => ts.isIdentifier(p.name) && p.name.text === name))
+            node.parameters.nodes.some((p) => ts.isIdentifier(p.name) && p.name.text === name))
             return "skip";
         if (ts.isBinaryExpression(node)) {
             const op = node.operatorToken.kind;
@@ -454,6 +470,89 @@ function identityUse(root, name, from = -1) {
     ts.walkPreorder(root, visit);
     return found;
 }
+/** `expr as T`, possibly through `as unknown`: the viewed value and `T`. */
+function castView(expr) {
+    while (ts.isParenthesizedExpression(expr))
+        expr = expr.expression;
+    if (!ts.isAsExpression(expr) && !ts.isTypeAssertion(expr))
+        return null;
+    const type = expr.type;
+    let inner = expr.expression;
+    for (;;) {
+        while (ts.isParenthesizedExpression(inner) || ts.isNonNullExpression(inner))
+            inner = inner.expression;
+        if ((ts.isAsExpression(inner) || ts.isTypeAssertion(inner)) &&
+            (inner.type.kind === ts.SyntaxKind.UnknownKeyword ||
+                inner.type.kind === ts.SyntaxKind.AnyKeyword)) {
+            inner = inner.expression;
+            continue;
+        }
+        break;
+    }
+    return isExistingObjectExpression(inner) ? { source: inner, type } : null;
+}
+/** The element type node of `T[]`, `readonly T[]` or `Array<T>`. */
+function arrayElementTypeNode(node) {
+    if (ts.isTypeOperatorNode(node))
+        node = node.type;
+    if (ts.isArrayTypeNode(node))
+        return node.elementType;
+    if (ts.isTypeReferenceNode(node) &&
+        ts.isIdentifier(node.typeName) &&
+        (node.typeName.text === "Array" || node.typeName.text === "ReadonlyArray") &&
+        node.typeArguments?.nodes.length === 1)
+        return node.typeArguments.nodes[0];
+    return undefined;
+}
+/** The first write through an element of the array binding `name`
+ * (`list[i].p = v`, or through a for-of variable over it) after `from`. */
+function elementWrite(root, name, from) {
+    const throughElement = (node) => {
+        let cur = node;
+        while (ts.isPropertyAccessExpression(cur) || ts.isElementAccessExpression(cur)) {
+            const inner = cur.expression;
+            if (ts.isElementAccessExpression(inner) && ts.isIdentifier(inner.expression))
+                return inner.expression.text === name;
+            cur = inner;
+        }
+        return false;
+    };
+    let found = null;
+    ts.walkPreorder(root, (node) => {
+        if (found !== null)
+            return "stop";
+        if (node.end <= from)
+            return "skip";
+        let target;
+        if (ts.isBinaryExpression(node) &&
+            node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+            node.operatorToken.kind <= ts.SyntaxKind.LastAssignment)
+            target = node.left;
+        else if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+            (node.operator === ts.SyntaxKind.PlusPlusToken ||
+                node.operator === ts.SyntaxKind.MinusMinusToken))
+            target = node.operand;
+        if (target !== undefined && throughElement(target)) {
+            found = ts.getTextOfNode(target);
+            return "stop";
+        }
+        if (ts.isForOfStatement(node) &&
+            ts.isIdentifier(node.expression) &&
+            node.expression.text === name &&
+            ts.isVariableDeclarationList(node.initializer)) {
+            const binding = node.initializer.declarations.nodes[0]?.name;
+            if (binding !== undefined && ts.isIdentifier(binding)) {
+                const use = identityUse(node.statement, binding.text);
+                if (use?.kind === "write") {
+                    found = use.text;
+                    return "stop";
+                }
+            }
+        }
+        return undefined;
+    });
+    return found;
+}
 function testsInstanceof(root, name) {
     let found = false;
     ts.walkPreorder(root, (node) => {
@@ -479,30 +578,46 @@ function enclosingScope(node) {
         cur = cur.parent;
     return cur;
 }
-/** A plain-record width copy between the value at `source` and the
- * declared `targetNode` type: both are object types that are not class
- * instances, arrays, functions or built-in containers, and the target's
- * properties are a strict subset of the source's — the shape scriptc
- * compiles as a field copy. */
+/** A width copy between the value at `source` and the declared `targetNode`
+ * type: a plain record whose property set differs from the target's (the
+ * target may drop properties or add optional ones), or a program class
+ * instance flowing into a plain record type that does not keep class
+ * identity (ClassProtocols marks the targets a class instance visibly
+ * flows into; a value reaching another record type is a field copy). */
 function widthCopyBetween(lowerer, source, targetNode) {
     const checker = lowerer.checker;
     const s = checker.getTypeAtLocation(source);
     const t = checker.getTypeFromTypeNode(targetNode);
-    if (!isPlainRecordType(checker, s) || !isPlainRecordType(checker, t))
+    if (!isPlainRecordType(checker, t))
         return null;
-    // Accessor members write through to captured state, so a copy of them
-    // still observes the same writes: no divergence to report.
-    const accessor = ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor;
-    if (checker.getPropertiesOfType(s).some((p) => (p.flags & accessor) !== 0))
+    const classSource = isProgramClassType(checker, s);
+    if (!classSource && !isPlainRecordType(checker, s))
         return null;
-    const sourceProps = new Set(checker.getPropertiesOfType(s).map((p) => p.name));
-    const targetProps = checker.getPropertiesOfType(t).map((p) => p.name);
-    if (targetProps.length === 0 || targetProps.length >= sourceProps.size)
-        return null;
-    if (!targetProps.every((p) => sourceProps.has(p)))
+    // A class-backed protocol view keeps the original value.
+    if (lowerer.classImplementedProtocol(t))
         return null;
+    const sourceProps = checker.getPropertiesOfType(s);
+    if (!classSource) {
+        // Accessor members write through to captured state, so a copy of them
+        // still observes the same writes: no divergence to report.
+        const accessor = ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor;
+        if (sourceProps.some((p) => (p.flags & accessor) !== 0))
+            return null;
+        const sourceNames = new Set(sourceProps.map((p) => ts.symbolName(p)));
+        const targetNames = checker.getPropertiesOfType(t).map((p) => ts.symbolName(p));
+        if (targetNames.length === sourceNames.size && targetNames.every((n) => sourceNames.has(n)))
+            return null;
+    }
     return { source: checker.typeToString(s), target: checker.typeToString(t) };
 }
+function isProgramClassType(checker, type) {
+    if ((type.flags & ts.TypeFlags.Object) === 0)
+        return false;
+    const symbol = type.getSymbol();
+    return (symbol !== undefined &&
+        (symbol.flags & ts.SymbolFlags.Class) !== 0 &&
+        symbol.declarations.some((d) => !ts.getSourceFileOfNode(d).isDeclarationFile));
+}
 function isPlainRecordType(checker, type) {
     if ((type.flags & ts.TypeFlags.Object) === 0)
         return false;
@@ -518,8 +633,8 @@ function isPlainRecordType(checker, type) {
     if (symbol !== undefined && (symbol.flags & ts.SymbolFlags.Class) !== 0)
         return false;
     // Library-declared object types (Map, Date, Promise, ...) are not records.
-    const decls = symbol === undefined ? [] : checker.declarationsOf(symbol);
-    if (decls.some((d) => d.getSourceFile().isDeclarationFile))
+    const decls = symbol === undefined ? [] : symbol.declarations;
+    if (decls.some((d) => ts.getSourceFileOfNode(d).isDeclarationFile))
         return false;
     return true;
 }
@@ -534,13 +649,17 @@ function namedObjectDeclaration(checker, type) {
         return null;
     if ((symbol.flags & ts.SymbolFlags.Class) !== 0)
         return null;
-    const decl = checker.declarationsOf(symbol)[0];
-    if (decl === undefined || decl.getSourceFile().isDeclarationFile)
+    const decl = symbol.declarations[0];
+    if (decl === undefined || ts.getSourceFileOfNode(decl).isDeclarationFile)
         return null;
     return decl;
 }
 function keyOrderFinding(lowerer, contextual, declared, written, assignedNames) {
-    const present = declared.filter((name) => written.includes(name));
+    // A shape whose table the witness pass re-chose (key-order-witness.ts)
+    // enumerates that table, not the checker's declaration order.
+    const table = witnessTable(lowerer, contextual);
+    const native = table ?? declared;
+    const present = native.filter((name) => written.includes(name) && declared.includes(name));
     const writtenKnown = written.filter((name) => declared.includes(name));
     if (present.join("\0") !== writtenKnown.join("\0") && writtenKnown.length >= 2) {
         return { native: present.join(", "), node: writtenKnown.join(", "), detail: "reordered" };
@@ -559,21 +678,29 @@ function keyOrderFinding(lowerer, contextual, declared, written, assignedNames)
         if (prop === undefined || (prop.flags & ts.SymbolFlags.Optional) === 0)
             continue;
         const nodeOrder = [...writtenKnown, name];
-        const nativeOrder = declared.filter((d) => nodeOrder.includes(d));
+        const nativeOrder = native.filter((d) => nodeOrder.includes(d));
+        if (table !== null && nativeOrder.join("\0") === nodeOrder.join("\0"))
+            continue;
         return { native: nativeOrder.join(", "), node: nodeOrder.join(", "), detail: "added-later" };
     }
     return null;
 }
+/** The re-chosen enumeration table of the record shape a contextual type
+ * lowered to, or null when the witness pass kept today's table. */
+function witnessTable(lowerer, contextual) {
+    const mapped = safely(() => lowerer.mapTypeOf(contextual));
+    if (mapped?.kind !== "record" || !lowerer.keyOrder.changed.has(mapped.shapeId))
+        return null;
+    return lowerer.shapes.get(mapped.shapeId)?.declaredOrder ?? null;
+}
 function classDeclarationOfTypeNode(lowerer, node) {
     if (!ts.isTypeReferenceNode(node) || !ts.isIdentifier(node.typeName))
         return null;
     const symbol = lowerer.checker.getSymbolAtLocation(node.typeName);
     if (symbol === undefined || (symbol.flags & ts.SymbolFlags.Class) === 0)
         return null;
-    const decl = lowerer.checker
-        .declarationsOf(symbol)
-        .find((d) => ts.isClassDeclaration(d) || ts.isClassExpression(d));
-    if (decl === undefined || decl.getSourceFile().isDeclarationFile)
+    const decl = symbol.declarations.find((d) => ts.isClassDeclaration(d) || ts.isClassExpression(d));
+    if (decl === undefined || ts.getSourceFileOfNode(decl).isDeclarationFile)
         return null;
     return decl;
 }
@@ -581,10 +708,8 @@ function classDeclarationOfType(checker, type) {
     const symbol = type.getSymbol();
     if (symbol === undefined || (symbol.flags & ts.SymbolFlags.Class) === 0)
         return null;
-    const decl = checker
-        .declarationsOf(symbol)
-        .find((d) => ts.isClassDeclaration(d) || ts.isClassExpression(d));
-    if (decl === undefined || decl.getSourceFile().isDeclarationFile)
+    const decl = symbol.declarations.find((d) => ts.isClassDeclaration(d) || ts.isClassExpression(d));
+    if (decl === undefined || ts.getSourceFileOfNode(decl).isDeclarationFile)
         return null;
     return decl;
 }
@@ -594,8 +719,8 @@ function classExtends(lowerer, sub, base) {
     for (let guard = 0; cur !== null && guard < 64; guard++) {
         if (cur === base)
             return true;
-        const heritage = cur.heritageClauses?.find((h) => h.token === ts.SyntaxKind.ExtendsKeyword);
-        const expr = heritage?.types[0]?.expression;
+        const heritage = cur.heritageClauses?.nodes.find((h) => h.token === ts.SyntaxKind.ExtendsKeyword);
+        const expr = heritage?.types?.nodes[0]?.expression;
         if (expr === undefined)
             return false;
         const symbol = lowerer.checker.getSymbolAtLocation(expr);
@@ -604,9 +729,7 @@ function classExtends(lowerer, sub, base) {
         const resolved = (symbol.flags & ts.SymbolFlags.Alias) !== 0
             ? lowerer.checker.getAliasedSymbol(symbol)
             : symbol;
-        const decl = lowerer.checker
-            .declarationsOf(resolved)
-            .find((d) => ts.isClassDeclaration(d) || ts.isClassExpression(d));
+        const decl = resolved.declarations.find((d) => ts.isClassDeclaration(d) || ts.isClassExpression(d));
         cur = decl === undefined ? null : decl;
     }
     return false;
@@ -614,17 +737,4 @@ function classExtends(lowerer, sub, base) {
 function className(decl) {
     return decl.name?.text ?? "(anonymous class)";
 }
-const MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
-/** The date-string grammar the native runtime accepts (scr_lib.c
- * scr_date_parse_get_time): ECMAScript's date-time format with an explicit
- * offset (date-only forms are UTC) and the certificate-time shape
- * "Mon DD HH:MM:SS YYYY GMT". Everything else parses to NaN natively. */
-export function nativeDateParses(text) {
-    const iso = /^(?:[+-]\d{6}|\d{4})(?:-(\d{2})(?:-(\d{2}))?)?$/.test(text) ||
-        /^(?:[+-]\d{6}|\d{4})-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{3})?)?(?:Z|[+-]\d{2}:\d{2})$/.test(text);
-    if (iso)
-        return true;
-    const cert = /^([A-Za-z]{3}) {1,2}\d{1,2} \d{2}:\d{2}:\d{2} \d{4} GMT$/.exec(text);
-    return cert !== null && MONTHS.includes(cert[1].toLowerCase());
-}
 //# sourceMappingURL=divergences.js.map