From fe6a4a8503bd72766c02308dc7b70e2d89fea971 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sat, 10 Oct 2026 16:26:29 -0700 Subject: [PATCH 1/8] Check narrowed member reads that a call can invalidate TypeScript keeps the narrowing of a property reference (and of a binding that a closure assigns) across calls. After `c.cb = fn` or `if (c.name !== undefined)`, a callback, method or getter that clears or replaces the property leaves later reads typed by the old value. Lowering trusted that type: maybeNarrow extracted the union payload unchecked, and `?.`, truthiness and `typeof` folded by the narrowed type. A second `c.cb?.()` after a self-clearing callback threw where Node answers undefined, and `string | undefined`, `string | number` or record fields read after such a call crashed or reinterpreted memory. NarrowingStability decides whether a narrowing is provably current: every property in the reference is construction-only (no store to its name outside `this.name = ...` in a constructor body, no accessor, no computed or reflective store into instances) with a stable root, or nothing between the earliest occurrence of the reference in the use's function and the use can run other code or store the property through another reference (standard library calls without callbacks are inert; a loop around the use contributes its whole body). Proven reads keep the unchecked extraction. Otherwise the read observes the stored value. In `?.` receivers, absence, type and truthiness tests, member reads the declared type supports, and slots that accept the declared type, the reference reads as declared, so the consumer tests at runtime exactly as Node does. Everywhere else the extraction is checked and throws Node's TypeError for the consuming operation (`Cannot read properties of undefined (reading 'x')`, `o.f is not a function`). Calls through callback fields use the same message. A null-only receiver of a restored `?.` short-circuits to undefined, and `typeof` evaluates an effectful union operand once. The checked failure path groups arms by message so wide unions stay small: the self-hosted compiler's IR grows by 0.03%. tsc-ts self-check, Linux, interleaved in one VM: check time -1.5% (noise), `--checkers 8` -1.2%. Corpus 4650 pins the shapes; a unit test pins which reads stay unchecked. --- .../src/frontend/lowering/coercions/unions.ts | 68 ++ .../lowering/expressions/optional-chains.ts | 5 +- .../src/frontend/lowering/lower-calls.ts | 16 +- .../src/frontend/lowering/lower-exprs.ts | 92 +- .../compiler/src/frontend/lowering/lowerer.ts | 12 + .../lowering/narrowing-stability.test.ts | 115 ++ .../frontend/lowering/narrowing-stability.ts | 1071 +++++++++++++++++ .../test/ts7/baselines/order-parity.json | 6 + tests/corpus/4650-stale-property-narrowing.ts | 263 ++++ 9 files changed, 1644 insertions(+), 4 deletions(-) create mode 100644 packages/compiler/src/frontend/lowering/narrowing-stability.test.ts create mode 100644 packages/compiler/src/frontend/lowering/narrowing-stability.ts create mode 100644 tests/corpus/4650-stale-property-narrowing.ts diff --git a/packages/compiler/src/frontend/lowering/coercions/unions.ts b/packages/compiler/src/frontend/lowering/coercions/unions.ts index 95f770e7d..40edb3a70 100644 --- a/packages/compiler/src/frontend/lowering/coercions/unions.ts +++ b/packages/compiler/src/frontend/lowering/coercions/unions.ts @@ -400,6 +400,74 @@ export function checkedNarrowCall( }; } +/** A checked extraction found a value arm other than the one the checker + * promised (a narrowing the program invalidated before the read). */ +export const OTHER_ARM_FAILURE_MESSAGE = + "a value of another type is not representable in the target union (a value narrowed or asserted past it still held it)"; + +/** checkedNarrowCall's in-place form with the TypeError of the consuming + * operation: `messageFor` names Node's error for finding another arm + * (`o.f is not a function`), or null for the stranded-value message. Null + * when the operand cannot be evaluated more than once. + * + * The failure path stays small for wide unions: arms are grouped by their + * message (every non-nullish arm without its own shares one), so it tests + * at most the null and undefined arms before a final throw. */ +export function checkedArmExtraction( + lowerer: Lowerer, + value: IrExpr, + tag: number, + arm: IrType, + messageFor: (found: IrType) => string | null, +): IrExpr | null { + if (value.type.kind !== "union" || !isSafeToRepeat(value)) return null; + const unionId = value.type.unionId; + const from = lowerer.unions.get(unionId); + const stored = from?.arms[tag]; + if (!from || from.arms.length < 2 || !stored || !typeEquals(stored, arm)) return null; + const loc = value.loc; + const isTag = (t: number): IrExpr => ({ + kind: "unionIsTag", + unionId, + tag: t, + negated: false, + value, + type: BOOL, + loc, + }); + const groups = new Map(); + from.arms.forEach((found, t) => { + if (t === tag) return; + const message = + messageFor(found) ?? + (isUnitType(found) + ? unionNarrowFailureMessage(found, (type) => lowerer.fmt(type)) + : OTHER_ARM_FAILURE_MESSAGE); + const tags = groups.get(message); + if (tags) tags.push(t); + else groups.set(message, [t]); + }); + // The largest group needs no test of its own: it is whatever remains. + const ordered = [...groups].sort((a, b) => a[1].length - b[1].length); + const [lastMessage] = ordered.pop()!; + let failure: IrExpr = nodeThrowExpr(1, "", lastMessage, arm, loc); + for (const [message, tags] of ordered.reverse()) { + let cond = isTag(tags[0]!); + for (const t of tags.slice(1)) + cond = { kind: "logical", op: "||", left: cond, right: isTag(t), type: BOOL, loc }; + const thrown = nodeThrowExpr(1, "", message, arm, loc); + failure = { kind: "ternary", cond, then: thrown, else_: failure, type: arm, loc }; + } + return { + kind: "ternary", + cond: isTag(tag), + then: { kind: "unionNarrow", unionId, tag, value, type: arm, loc }, + else_: failure, + type: arm, + loc, + }; +} + /** The operand of a checked extraction in either form checkedNarrowCall * produces, or null for every other expression. */ export function checkedNarrowOperand(lowerer: Lowerer, value: IrExpr): IrExpr | null { diff --git a/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts b/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts index 9ed011125..b86a9c728 100644 --- a/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts +++ b/packages/compiler/src/frontend/lowering/expressions/optional-chains.ts @@ -509,10 +509,13 @@ export function finishOptionalChain( return { kind: "optChain", id, receiver, body, type: DYN, loc }; } let type = lowerer.irTypeOf(expr); + // The checker can call a receiver present that holds a nullish value at + // runtime (runtime-optional reads; a stale narrowing restored to its + // declared type). Either nullish arm short-circuits to undefined. const hiddenOptionalResult = (type.kind !== "union" || lowerer.armTag(type.unionId, UNDEFINED_T) < 0) && receiver.type.kind === "union" && - lowerer.armTag(receiver.type.unionId, UNDEFINED_T) >= 0 && + (lowerer.unions.get(receiver.type.unionId)?.arms.some(isUnitType) ?? false) && body.type.kind !== "generator" && body.type.kind !== "jsval" ? lowerer.withUndefinedArmOf(body.type) diff --git a/packages/compiler/src/frontend/lowering/lower-calls.ts b/packages/compiler/src/frontend/lowering/lower-calls.ts index 6335a317e..66020271a 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -174,6 +174,7 @@ import { completeArgs, } from "./call-arguments.js"; import { isThisParameter, type ParamShape } from "./call-signatures.js"; +import { checkedArmExtraction } from "./coercions/unions.js"; import { requireObjLitGenericReceiver, objLitGenericFnNodeOf, @@ -8994,8 +8995,19 @@ export function lowerObjectMethodCall( }); let callee = target ? lowerer.fieldGetExpr(target, locOf(access), access) : null; if (callee?.type.kind === "union" && callableType !== null) { - const helper = lowerer.narrowedArmHelper(callee.type.unionId, callableType, locOf(access)); - if (helper !== null) { + // Calling a cleared callback field throws Node's call TypeError. + const inPlace = checkedArmExtraction( + lowerer, + callee, + lowerer.armTag(callee.type.unionId, callableType), + callableType, + () => `${access.getText()} is not a function`, + ); + const helper = inPlace + ? null + : lowerer.narrowedArmHelper(callee.type.unionId, callableType, locOf(access)); + if (inPlace) callee = inPlace; + else if (helper !== null) { callee = lowerer.checkedNarrowCall(helper, callee, callableType, locOf(access)); } } diff --git a/packages/compiler/src/frontend/lowering/lower-exprs.ts b/packages/compiler/src/frontend/lowering/lower-exprs.ts index b625b41d7..a7f58bab2 100644 --- a/packages/compiler/src/frontend/lowering/lower-exprs.ts +++ b/packages/compiler/src/frontend/lowering/lower-exprs.ts @@ -20,6 +20,7 @@ import { dirname } from "node:path"; import * as posix from "node:path/posix"; import type { Lowerer } from "./lowerer.js"; import { checkedClassAssertion, checkedClassUnionAssertion } from "./class-assertions.js"; +import { checkedArmExtraction } from "./coercions/unions.js"; import { narrowClassUnion, narrowStoredClassValue } from "./class-unions.js"; import { lowerUnionFieldRead, lowerUnionFieldWrite } from "./expressions/union-fields.js"; import { captureContextArguments } from "./function-context.js"; @@ -1044,6 +1045,13 @@ function lowerExprInner(lowerer: Lowerer, expr: ts.Expression): IrExpr { // tests, so only side-effect-free reads compose — and when every arm // agrees the whole expression folds to that one string (dropping only // the pure read, the trust-the-checker bet lowerUnitComparison makes). + // An effectful producer (a getter) evaluates once into a hidden local. + const prelude: IrStmt[] = []; + if (operand.type.kind === "union" && !isSafeToRepeat(operand)) { + const local = lowerer.declareHiddenLocal("%typeofOperand", operand.type); + prelude.push({ kind: "varDecl", localId: local.id, init: operand, loc }); + operand = varRef(local.id, operand.type, loc); + } if (operand.type.kind === "union" && isSafeToRepeat(operand)) { const def = lowerer.unions.get(operand.type.unionId); const answers = def?.arms.map(typeofAnswer); @@ -1094,7 +1102,9 @@ function lowerExprInner(lowerer: Lowerer, expr: ts.Expression): IrExpr { loc, }; } - return result; + return prelude.length > 0 + ? { kind: "seqExpr", stmts: prelude, result, type: STRING, loc } + : result; } } if (operand.type.kind === "dyn") { @@ -3629,6 +3639,10 @@ export function maybeNarrow(lowerer: Lowerer, expr: IrExpr, node: ts.Node): IrEx narrowed.className !== expr.type.className && lowerer.isSubclassOf(narrowed.className, expr.type.className) ) { + if (lowerer.narrowing.untrusted(node, narrowed)) { + const checked = checkedClassAssertion(lowerer, expr, narrowed, expr.loc); + if (checked) return checked; + } return { kind: "downcast", value: expr, type: narrowed, loc: expr.loc }; } return expr; @@ -3675,6 +3689,8 @@ export function maybeNarrow(lowerer: Lowerer, expr: IrExpr, node: ts.Node): IrEx const arrayTags = lowerer.arrayValueTags(expr.type.unionId); if (arrayTags.length === 1) { const arm = def!.arms[arrayTags[0]!]!; + const checked = checkedStaleArm(lowerer, node, expr, arrayTags[0]!, arm); + if (checked) return checked; return { kind: "unionNarrow", unionId: expr.type.unionId, @@ -3712,6 +3728,14 @@ export function maybeNarrow(lowerer: Lowerer, expr: IrExpr, node: ts.Node): IrEx const values = literalValues(lowerer.checker.getTypeOfSymbol(property)); const arm = values && literalUnionArm(def, values, (id) => lowerer.shapes.get(id)); if (arm) { + const checked = checkedStaleArm( + lowerer, + node, + expr, + lowerer.armTag(expr.type.unionId, arm), + arm, + ); + if (checked) return checked; return { kind: "unionNarrow", unionId: expr.type.unionId, @@ -3746,6 +3770,10 @@ export function maybeNarrow(lowerer: Lowerer, expr: IrExpr, node: ts.Node): IrEx ) && lowerer.isSubclassOf(narrowed.className, valueType.className) ) { + const checked = checkedStaleArm(lowerer, node, expr, valueTag, valueType, narrowed); + if (checked) { + return checkedClassAssertion(lowerer, checked, narrowed, expr.loc) ?? checked; + } return { kind: "downcast", value: { @@ -3762,6 +3790,8 @@ export function maybeNarrow(lowerer: Lowerer, expr: IrExpr, node: ts.Node): IrEx } return expr; } + const checked = checkedStaleArm(lowerer, node, expr, tag, narrowed); + if (checked) return checked; return { kind: "unionNarrow", unionId: expr.type.unionId, @@ -3772,6 +3802,66 @@ export function maybeNarrow(lowerer: Lowerer, expr: IrExpr, node: ts.Node): IrEx }; } +/** The checked form of maybeNarrow's arm extraction for a narrowing the + * checker may hold past code that replaced the value (a call clearing the + * property; see NarrowingStability). Every other arm throws the TypeError + * Node raises for the operation consuming the read (`Cannot read + * properties of undefined (reading 'x')`, `o.f is not a function`), or the + * stranded-value TypeError where Node would carry the value on. Null when + * the narrowing is provably current. `narrowed` is the checker's type when + * it refines the arm (a subclass view). */ +function checkedStaleArm( + lowerer: Lowerer, + node: ts.Node, + value: IrExpr, + tag: number, + arm: IrType, + narrowed: IrType = arm, +): IrExpr | null { + if (value.type.kind !== "union" || tag < 0) return null; + if (!lowerer.narrowing.untrusted(node, narrowed)) return null; + const inPlace = checkedArmExtraction(lowerer, value, tag, arm, (found) => + staleReadMessage(node, found), + ); + if (inPlace) return inPlace; + const helper = lowerer.narrowedArmHelper(value.type.unionId, arm, value.loc); + return helper ? lowerer.checkedNarrowCall(helper, value, arm, value.loc) : null; +} + +/** Node's TypeError for the operation consuming `node` when it holds a + * value of type `found`, or null where Node would not throw. */ +function staleReadMessage(node: ts.Node, found: IrType): string | null { + let child: ts.Node = node; + let parent = node.parent; + while (ts.isParenthesizedExpression(parent)) { + child = parent; + parent = parent.parent; + } + if (ts.isCallExpression(parent) && parent.expression === child && !parent.questionDotToken) { + return found.kind === "func" ? null : `${node.getText()} is not a function`; + } + const unit = found.kind === "undefinedT" ? "undefined" : found.kind === "nullT" ? "null" : null; + if (unit === null) return null; + if ( + !(ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) || + parent.expression !== child || + parent.questionDotToken + ) + return null; + let key: string | null = null; + if (ts.isPropertyAccessExpression(parent)) key = parent.name.text; + else if (ts.isStringLiteral(parent.argumentExpression)) key = parent.argumentExpression.text; + else if (ts.isNumericLiteral(parent.argumentExpression)) + key = String(Number(parent.argumentExpression.text)); + if (key === null) return null; + const store = parent.parent; + return ts.isBinaryExpression(store) && + store.left === parent && + store.operatorToken.kind === ts.SyntaxKind.EqualsToken + ? `Cannot set properties of ${unit} (setting '${key}')` + : `Cannot read properties of ${unit} (reading '${key}')`; +} + /** A runtime-optional slot can be assigned while a truthy guard is in * force. TypeScript then types a direct member receiver as the plain arm, * even though an OOB-safe assignment may have restored undefined. Check diff --git a/packages/compiler/src/frontend/lowering/lowerer.ts b/packages/compiler/src/frontend/lowering/lowerer.ts index 20ba4b9a7..dff05fa46 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -71,6 +71,7 @@ import { import { everyExprChild, everyStmtChild, transformStmtList } from "../../ir/traverse.js"; import { RuntimeOptionalProvenance } from "./runtime-optional-provenance.js"; import { presentAtUse, reassignedBindings } from "./runtime-optional-guards.js"; +import { NarrowingStability } from "./narrowing-stability.js"; import { ArrayElementStates } from "./runtime-optional-elements.js"; import { indexReadInBounds } from "./runtime-optional-bounds.js"; import { ArrayOwnership } from "./runtime-optional-ownership.js"; @@ -1878,6 +1879,10 @@ export class Lowerer { * discriminant was captured. A case match narrows the captured value, * not that mutable binding; preserve its tagged representation on reads. */ readonly unstableSwitchBindings = new Set(); + /** Whether a checker narrowing of a mutable member or closure-assigned + * binding still holds at its use (calls do not reset TypeScript's + * narrowing). Stale ones read the declared storage or check it. */ + readonly narrowing = new NarrowingStability(this); /** All storage slots widened for runtime absence, including slots whose * current control-flow branch has temporarily narrowed the value. */ readonly runtimeOptionalStorageLocals = new Set(); @@ -5542,6 +5547,7 @@ export class Lowerer { run(): LowerResult { const parts = this.splitFiles(); + this.narrowing.setFiles(parts.map((fp) => fp.sf)); // The coverage remainder deliberately visits every body that reachable // emit skipped. Those files are already phase-managed, so an ordinary // checker miss would stay a one-node IPC query instead of falling back @@ -5911,6 +5917,7 @@ export class Lowerer { emitReachable(extraRoots?: readonly string[]): { reachable: Set; result: LowerResult } { this.deferredModuleInitializers = new DeferredModuleInitializers(); const parts = this.splitFiles(); + this.narrowing.setFiles(parts.map((fp) => fp.sf)); // Direct lowering callers do not necessarily run program preflight. // Establish the same managed header/top-level batch here before // collection, while the production path simply finds warm memos. @@ -6895,6 +6902,11 @@ export class Lowerer { // receiver-kind check downstream sees the narrowed arm. const narrowed = this.chainNarrowedType.get(node); if (narrowed) return narrowed; + // A stale narrowing of a mutable member or closure-assigned binding in + // an absence/type test (or a slot accepting the declared type) reads + // as declared, so the test inspects the stored value. + const widened = this.narrowing.widenedType(node); + if (widened) return widened; const t = this.checker.getTypeAtLocation(node); // ALIASED-TYPEOF narrowing: inside a branch a `type === 'string'` // test proves (type = typeof val, both never reassigned), references diff --git a/packages/compiler/src/frontend/lowering/narrowing-stability.test.ts b/packages/compiler/src/frontend/lowering/narrowing-stability.test.ts new file mode 100644 index 000000000..81bea782c --- /dev/null +++ b/packages/compiler/src/frontend/lowering/narrowing-stability.test.ts @@ -0,0 +1,115 @@ +import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { expect, test } from "vitest"; +import { compile, deserializeModule, validateModule } from "../../index.js"; +import type { IrModule } from "../../ir/ir.js"; + +async function lower(source: string): Promise { + const dir = await mkdtemp(join(tmpdir(), "scriptc-narrowing-stability-")); + try { + const entry = join(dir, "main.ts"), + output = join(dir, "main.ir.json"); + await writeFile(entry, source); + const result = await compile(entry, { outDir: dir, outPath: output, outputKind: "ir" }); + if (!result.ok) + throw new Error(result.diagnostics.map((item) => `${item.code}: ${item.message}`).join("\n")); + const module = deserializeModule(await readFile(output, "utf8")); + expect(validateModule(module)).toEqual([]); + return module; + } finally { + await rm(dir, { recursive: true, force: true }); + } +} + +/** The TypeError messages a function's checked reads can throw. */ +function thrownMessages(module: IrModule, name: string): string[] { + const fn = module.functions.find((f) => f.name === name || f.name.endsWith(`.${name}`)); + if (!fn) throw new Error(`no function ${name}`); + const messages: string[] = []; + JSON.stringify(fn.body, (_key, value: unknown) => { + const node = value as { kind?: string; fn?: string; args?: { value?: unknown }[] }; + if (node?.kind === "libCall" && node.fn === "error.nodeThrow") + messages.push(String(node.args?.[2]?.value)); + return value; + }); + return messages; +} + +const SOURCE = ` +class Tree { + parent: Tree | undefined; + depth: number; + constructor(parent: Tree | undefined) { + this.parent = parent; + this.depth = parent ? parent.depth + 1 : 0; + } +} +class Box { + label: string | undefined = undefined; + clear(): void { this.label = undefined; } +} +function visit(t: Tree): number { return t.depth; } +function constructionOnly(t: Tree): number { + if (t.parent) { + visit(t); + return t.parent.depth; + } + return -1; +} +function noCall(b: Box): number { + if (b.label !== undefined) return b.label.length + b.label.length; + return 0; +} +function libraryCalls(b: Box, xs: number[]): number { + if (b.label !== undefined) { + xs.push(Math.max(1, 2)); + console.log("x"); + return b.label.length; + } + return 0; +} +function userCall(b: Box): number { + if (b.label !== undefined) { + visit(new Tree(undefined)); + return b.label.length; + } + return 0; +} +function methodCall(b: Box): number { + if (b.label !== undefined) { + b.clear(); + return b.label.length; + } + return 0; +} +function loopBackEdge(b: Box): number { + let n = 0; + if (b.label !== undefined) { + for (let i = 0; i < 2; i++) { + n += b.label.length; + b.clear(); + } + } + return n; +} +const b = new Box(); +b.label = "abc"; +console.log(constructionOnly(new Tree(new Tree(undefined))), noCall(b), libraryCalls(b, []), + userCall(b), methodCall(b), loopBackEdge(b)); +`; + +test("narrowed reads keep the unchecked extraction where nothing can change the field", async () => { + const module = await lower(SOURCE); + expect(thrownMessages(module, "constructionOnly")).toEqual([]); + expect(thrownMessages(module, "noCall")).toEqual([]); + expect(thrownMessages(module, "libraryCalls")).toEqual([]); +}); + +test("narrowed reads after code that can clear the field check it with Node's TypeError", async () => { + const module = await lower(SOURCE); + const read = "Cannot read properties of undefined (reading 'length')"; + expect(thrownMessages(module, "userCall")).toContain(read); + expect(thrownMessages(module, "methodCall")).toContain(read); + expect(thrownMessages(module, "loopBackEdge")).toContain(read); +}); diff --git a/packages/compiler/src/frontend/lowering/narrowing-stability.ts b/packages/compiler/src/frontend/lowering/narrowing-stability.ts new file mode 100644 index 000000000..954d9fee8 --- /dev/null +++ b/packages/compiler/src/frontend/lowering/narrowing-stability.ts @@ -0,0 +1,1071 @@ +import * as ts from "../ts7/adapter.js"; +import { InternalCompilerError } from "../../errors.js"; +import { typeEquals } from "../../ir/ir.js"; +import type { IrType } from "../../ir/ir.js"; +import type { Lowerer } from "./lowerer.js"; + +/** Whether TypeScript's control-flow narrowing of a mutable reference still + * holds when the narrowed read executes. + * + * TypeScript narrows property references (`o.p`, `this.a.b`) and bindings + * after assignments and tests, and keeps that narrowing across calls: a + * callback, method or getter that clears or replaces the property (or a + * closure that reassigns the binding) leaves the reference typed by its old + * value. Lowering bridges a narrowed union read with an UNCHECKED payload + * extraction and folds `?.`, truthiness and `typeof` by the narrowed type, + * so such a read would interpret the wrong arm. This analysis decides when + * the narrowing is provably current: + * + * - every property in the reference is construction-only (no store to its + * name anywhere in the program except `this.name = ...` directly in a + * constructor body, no accessor of that name, no reflective or computed + * store into class instances) and the root binding is never assigned + * from another function; or + * - nothing between the earliest occurrence of the same reference in the + * use's function and the use can run other code or store the property + * through another reference: no call or construction (except standard + * library operations that cannot call back), tagged template, `await`, + * `yield`, user accessor, user iteration or user conversion hook, and no + * store to a property of the same name through a different reference. + * A loop around the use that starts inside that span contributes its + * whole body, since its back edge reaches the use again. + * + * TypeScript never carries a property narrowing into a nested function, + * and every narrowing (an assignment, test, predicate or assertion of the + * reference) is an occurrence of the reference, so a narrowed use always + * has one earlier in its own function. Spurious occurrences only move the + * span start earlier, which keeps the answer conservative. */ +export class NarrowingStability { + private files: readonly ts.SourceFile[] | null = null; + private programFacts: ProgramFacts | null = null; + private readonly facts = new Map(); + private readonly verdicts = new Map(); + private readonly effects = new Map(); + private readonly capturedMutable = new Map(); + private readonly identifierWrites = new Map>(); + private readonly widened = new Map(); + private readonly plainContainers = new Map(); + + constructor(private readonly lowerer: Lowerer) {} + + setFiles(files: readonly ts.SourceFile[]): void { + this.files = files; + this.programFacts = null; + } + + /** The declared type a narrowed read in an absence or type test (or in a + * slot that accepts that declared type) must observe instead of the + * checker's stale narrowing, or null to keep the checker's type. */ + widenedType(node: ts.Node): ts.Type | null { + if (!ts.isPropertyAccessExpression(node) && !ts.isIdentifier(node)) return null; + // Program-level queries before the program's files are split concern + // declarations, never narrowed reads in function bodies. + if (this.files === null) return null; + const position = widePosition(node); + if (position === null) return null; + const cached = this.widened.get(node); + if (cached !== undefined) return cached; + let result: ts.Type | null = null; + try { + result = this.computeWidened(node, position); + } finally { + this.widened.set(node, result); + } + return result; + } + + /** The checker narrows this reference below its declared type, and the + * narrowing may be stale at runtime: its read must check the stored + * value instead of trusting the narrowed type. */ + untrusted(node: ts.Node, narrowed: IrType): boolean { + // Explicit assertions (`x!`, `x as T`) are the program's own claim and + // keep their established stance; only flow narrowing is in question. + if (this.files === null) return false; + if (ts.isPropertyAccessExpression(node)) { + const declared = this.declaredPropertyType(node); + if (declared === null) return false; + const declaredIr = this.lowerer.mapTypeOf(declared); + if (declaredIr === null || typeEquals(declaredIr, narrowed)) return false; + return !this.trusted(node); + } + if (ts.isIdentifier(node)) { + const symbol = this.bindingOf(node); + if (!symbol || !this.isCapturedMutable(symbol)) return false; + return !this.trusted(node); + } + return false; + } + + private bindingOf(node: ts.Identifier): ts.Symbol | null { + const symbol = this.lowerer.resolveValueSymbol(node); + if (symbol && symbol.flags & ts.SymbolFlags.Alias) + return this.lowerer.checker.getAliasedSymbol(symbol); + return symbol; + } + + private computeWidened( + node: ts.PropertyAccessExpression | ts.Identifier, + position: WidePosition, + ): ts.Type | null { + const checker = this.lowerer.checker; + let declared: ts.Type | null; + if (ts.isPropertyAccessExpression(node)) { + declared = this.declaredPropertyType(node); + } else { + const symbol = this.bindingOf(node); + declared = symbol && this.isCapturedMutable(symbol) ? checker.getTypeOfSymbol(symbol) : null; + } + if (declared === null) return null; + const narrowedTs = checker.getTypeAtLocation(node); + if (narrowedTs === declared) return null; + const declaredIr = this.lowerer.mapTypeOf(declared); + const narrowedIr = this.lowerer.mapTypeOf(narrowedTs); + if (declaredIr === null || narrowedIr === null || typeEquals(declaredIr, narrowedIr)) + return null; + // A union narrowed to some of its arms, or a class narrowed to a + // subclass by instanceof (whose members dispatch on the instance). + const classNarrowing = declaredIr.kind === "object" && narrowedIr.kind === "object"; + if (declaredIr.kind !== "union" && !classNarrowing) return null; + if (position === "member") { + // A member the declared type itself supports (every arm has it, so + // no arm is nullish) reads the current value's member, as Node does. + // Calls dispatch only through a single class. + const member = memberUse(node); + if (member === null || (member.call && !classNarrowing)) return null; + if (!checker.getPropertyOfType(declared, member.access.name.text)) return null; + } else if (position === "chain") { + if (classNarrowing) return null; + // A chain body is lowered for the checker's present receiver type: + // only a narrowing that removed nothing but null/undefined can be + // restored to the guarded declared receiver. + const present = this.lowerer.mapTypeOf(checker.getNonNullableType(declared)); + if (present === null || !typeEquals(present, narrowedIr)) return null; + } else if (position === "context") { + const contextual = checker.getContextualType(node); + if (contextual === undefined) return null; + if ( + !(contextual.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) && + !checker.isTypeAssignableTo(declared, contextual) + ) + return null; + } + return this.trusted(node) ? null : declared; + } + + /** The type of the accessed property as declared on the receiver's + * (instantiated) type, before any flow narrowing of this reference. */ + private declaredPropertyType(node: ts.PropertyAccessExpression): ts.Type | null { + const checker = this.lowerer.checker; + const receiver = checker.getTypeAtLocation(node.expression); + const property = + checker.getPropertyOfType(receiver, node.name.text) ?? checker.getSymbolAtLocation(node.name); + if (!property) return null; + return checker.getTypeOfSymbol(property); + } + + private trusted(node: ts.Expression): boolean { + const cached = this.verdicts.get(node); + if (cached !== undefined) return cached; + const verdict = this.computeTrusted(node); + this.verdicts.set(node, verdict); + return verdict; + } + + private computeTrusted(node: ts.Expression): boolean { + const chain = referenceChain(node); + if (chain === null) return true; + const program = this.program(); + // A getter answers a fresh value on every read: neither its own result + // nor anything read through it keeps a narrowing. + for (const link of chain.links) { + if (!program.accessors.has(link.name)) continue; + const symbol = this.lowerer.checker.getSymbolAtLocation( + ts.isPropertyAccessExpression(link.node) ? link.node.name : link.node, + ); + if ( + !symbol || + (symbol.flags & (ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor)) !== 0 + ) + return false; + } + const rootStable = + chain.root.kind === ts.SyntaxKind.ThisKeyword || + (ts.isIdentifier(chain.root) && !this.rootCapturedMutable(chain.root)); + if ( + rootStable && + chain.links.length > 0 && + chain.links.every((link) => this.constructionOnly(link.name)) + ) + return true; + if (chain.links.length === 0 && rootStable) return true; + return this.currentSinceNarrowing(node, chain); + } + + /** The root binding can change between the narrowing and the use, or + * names a namespace whose exported bindings are assigned as variables + * (invisible to the member-store census). */ + private rootCapturedMutable(root: ts.Identifier): boolean { + const symbol = this.bindingOf(root); + if (symbol === null) return true; + if (symbol.flags & (ts.SymbolFlags.Module | ts.SymbolFlags.Enum)) return true; + return this.isCapturedMutable(symbol); + } + + /** No intervening code between the reference's earliest occurrence in + * the use's function and the use can change it. */ + private currentSinceNarrowing(node: ts.Expression, chain: ReferenceChain): boolean { + const boundary = flowBoundary(node); + const facts = this.functionFacts(boundary); + const last = chain.links[chain.links.length - 1]; + const refKey = last ? `.${last.name}` : (chain.root as ts.Identifier).text; + const candidates = facts.refs.get(refKey) ?? []; + const useStart = node.getStart(); + let start = -1; + for (const candidate of candidates) { + if (candidate === node) continue; + const candidateStart = candidate.getStart(); + if (candidateStart >= useStart) break; + if (referenceKey(candidate) !== chain.key) continue; + start = candidateStart; + // An assignment narrows once it completes: code its right side runs + // happens before the stored value exists. + const parent = candidate.parent; + if ( + ts.isBinaryExpression(parent) && + parent.left === candidate && + parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && + parent.end <= useStart + ) + start = parent.end; + break; + } + if (start < 0) return false; + // A loop around the use that starts after the narrowing reaches the + // use again through its back edge: its whole body (and header) runs in + // between. + let end = useStart; + for (const loop of facts.loops) { + const loopStart = loop.getStart(); + if (loopStart >= start && loopStart <= useStart && loop.end >= node.end) + end = Math.max(end, loop.end); + } + // Effects and stores are ordered by where they take effect (a call + // after its arguments, a store after its right side). Code enclosing + // the use takes effect after it unless a loop brings the use around. + for (const { node: effect } of between(facts.effects, start, end)) { + if (this.isEffect(effect)) return false; + } + if (chain.links.length === 0) return true; + const names = new Set(chain.links.map((link) => link.name)); + for (const { node: write } of between(facts.writes, start, end)) { + const name = accessName(write); + if (name === null) { + if (!this.isPlainContainerWrite(write)) return false; + continue; + } + if (!names.has(name)) continue; + const key = referenceKey(write); + // A store through the same reference (or a prefix of it) is a flow + // assignment the checker already accounts for. + if (key !== null && (key === chain.key || chain.key.startsWith(`${key}.`))) continue; + return false; + } + return true; + } + + private isPlainContainerWrite(write: ts.Expression): boolean { + if (!ts.isElementAccessExpression(write)) return false; + const cached = this.plainContainers.get(write); + if (cached !== undefined) return cached; + const checker = this.lowerer.checker; + const type = checker.getTypeAtLocation(write.expression); + const plain = isPlainContainerType(checker, type); + this.plainContainers.set(write, plain); + return plain; + } + + private constructionOnly(name: string): boolean { + const program = this.program(); + return !program.wildcard && !program.mutable.has(name) && !program.accessors.has(name); + } + + /** A `let`/`var`/parameter binding assigned from a function other than + * the one that declares it: any call may change it. */ + private isCapturedMutable(symbol: ts.Symbol): boolean { + const cached = this.capturedMutable.get(symbol); + if (cached !== undefined) return cached; + let result = false; + try { + const decl = this.lowerer.checker.valueDeclarationOf(symbol); + const mutableBinding = + decl !== undefined && + ((ts.isVariableDeclaration(decl) && + ts.isVariableDeclarationList(decl.parent) && + (decl.parent.flags & ts.NodeFlags.Const) === 0) || + ts.isParameter(decl)); + if (decl && mutableBinding) { + const home = flowBoundary(decl); + const writes = this.writesIn(decl.getSourceFile()).get(symbol.name) ?? []; + for (const write of writes) { + if (flowBoundary(write) === home) continue; + if (this.lowerer.resolveValueSymbol(write) === symbol) { + result = true; + break; + } + } + } + } finally { + this.capturedMutable.set(symbol, result); + } + return result; + } + + private writesIn(file: ts.SourceFile): Map { + let writes = this.identifierWrites.get(file); + if (writes) return writes; + const found = new Map(); + writes = found; + this.identifierWrites.set(file, found); + const add = (target: ts.Node): void => { + forEachWriteTarget(target, (t) => { + if (!ts.isIdentifier(t)) return; + let list = found.get(t.text); + if (!list) found.set(t.text, (list = [])); + list.push(t); + }); + }; + ts.walkPreorder(file, (node) => { + const target = writeTargetOf(node); + if (target) add(target); + }); + return writes; + } + + private program(): ProgramFacts { + if (this.programFacts) return this.programFacts; + if (this.files === null) { + throw new InternalCompilerError("narrowing stability queried before the program files"); + } + const facts: ProgramFacts = { + mutable: new Set(), + accessors: new Set(), + wildcard: this.lowerer.dynamic, + conversion: false, + iteration: false, + }; + this.programFacts = facts; + for (const file of this.files) { + if (file.isDeclarationFile) continue; + ts.walkPreorder(file, (node) => { + if (ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node)) { + const name = memberName(node.name); + if (name !== null) facts.accessors.add(name); + else facts.wildcard = true; + } + if ( + ts.isMethodDeclaration(node) || + ts.isPropertyDeclaration(node) || + ts.isPropertyAssignment(node) || + ts.isGetAccessorDeclaration(node) + ) { + const name = memberName(node.name); + if (name === "toString" || name === "valueOf" || name === "toJSON") + facts.conversion = true; + if (ts.isComputedPropertyName(node.name)) { + const text = node.name.expression.getText(); + if (text.includes("toPrimitive")) facts.conversion = true; + if (text.includes("iterator") || text.includes("asyncIterator")) facts.iteration = true; + } + } + if ( + (ts.isFunctionDeclaration(node) || + ts.isFunctionExpression(node) || + ts.isMethodDeclaration(node)) && + node.asteriskToken + ) { + facts.iteration = true; + } + if (ts.isCallExpression(node) && reflectiveStore(node)) facts.wildcard = true; + const target = writeTargetOf(node); + if (target) { + forEachWriteTarget(target, (t) => { + if (ts.isIdentifier(t)) return; + const name = accessName(t); + if (name === null) { + if (!this.isPlainContainerWrite(t)) facts.wildcard = true; + return; + } + if (isConstructorThisStore(t)) return; + facts.mutable.add(name); + }); + } + }); + } + return facts; + } + + private functionFacts(boundary: ts.Node): FunctionFacts { + let facts = this.facts.get(boundary); + if (facts) return facts; + const program = this.program(); + const found: FunctionFacts = { effects: [], writes: [], loops: [], refs: new Map() }; + facts = found; + this.facts.set(boundary, found); + const addRef = (key: string, node: ts.Expression): void => { + let list = found.refs.get(key); + if (!list) found.refs.set(key, (list = [])); + list.push(node); + }; + const effect = (node: ts.Node, at = node.end): void => { + found.effects.push({ node, at }); + }; + ts.walkPreorder(boundary, (node) => { + if (node !== boundary && isFlowBoundary(node)) return "skip"; + if (ts.isClassLikeDeclaration(node) && node !== boundary) { + effect(node); + return "skip"; + } + switch (node.kind) { + case ts.SyntaxKind.CallExpression: + case ts.SyntaxKind.NewExpression: + case ts.SyntaxKind.TaggedTemplateExpression: + case ts.SyntaxKind.Decorator: + case ts.SyntaxKind.AwaitExpression: + case ts.SyntaxKind.YieldExpression: + case ts.SyntaxKind.SpreadElement: + effect(node); + break; + case ts.SyntaxKind.ForOfStatement: + // The iterator steps between the iterable and the body. + effect(node, (node as ts.ForOfStatement).expression.end); + found.loops.push(node); + break; + case ts.SyntaxKind.ForStatement: + case ts.SyntaxKind.ForInStatement: + case ts.SyntaxKind.WhileStatement: + case ts.SyntaxKind.DoStatement: + found.loops.push(node); + break; + case ts.SyntaxKind.ArrayBindingPattern: + case ts.SyntaxKind.ArrayLiteralExpression: + if (program.iteration) effect(node, node.parent?.end ?? node.end); + break; + case ts.SyntaxKind.TemplateSpan: + if (program.conversion) effect(node, (node as ts.TemplateSpan).expression.end); + break; + case ts.SyntaxKind.BinaryExpression: + if (program.conversion) effect(node); + break; + } + if (ts.isPropertyAccessExpression(node)) { + addRef(`.${node.name.text}`, node); + if (program.accessors.has(node.name.text)) effect(node); + } else if (ts.isElementAccessExpression(node)) { + const name = accessName(node); + if (name !== null) { + addRef(`.${name}`, node); + if (program.accessors.has(name)) effect(node); + } + } else if (ts.isIdentifier(node) && isValueIdentifier(node)) { + addRef(node.text, node); + } + const target = writeTargetOf(node); + if (target) { + forEachWriteTarget(target, (t) => { + if (ts.isPropertyAccessExpression(t) || ts.isElementAccessExpression(t)) + found.writes.push({ node: t, at: node.end }); + }); + } + return undefined; + }); + found.effects.sort((a, b) => a.at - b.at); + found.writes.sort((a, b) => a.at - b.at); + return facts; + } + + /** Whether evaluating this candidate can run code other than standard + * library operations that cannot call back into the program. */ + private isEffect(node: ts.Node): boolean { + const cached = this.effects.get(node); + if (cached !== undefined) return cached; + let result = true; + try { + result = this.computeEffect(node); + } finally { + this.effects.set(node, result); + } + return result; + } + + private computeEffect(node: ts.Node): boolean { + const checker = this.lowerer.checker; + if (ts.isCallExpression(node)) return !this.isInertLibraryCall(node); + if (ts.isNewExpression(node)) return !this.isInertConstruction(node); + if (ts.isForOfStatement(node)) { + if (node.awaitModifier) return true; + return this.program().iteration && !this.isBuiltinIterable(node.expression); + } + if (ts.isSpreadElement(node)) return !this.isBuiltinIterable(node.expression); + if (ts.isArrayBindingPattern(node)) { + const owner = node.parent; + return !( + ts.isVariableDeclaration(owner) && + owner.initializer !== undefined && + this.isBuiltinIterable(owner.initializer) + ); + } + if (ts.isArrayLiteralExpression(node)) { + const parent = node.parent; + if ( + !ts.isBinaryExpression(parent) || + parent.left !== node || + parent.operatorToken.kind !== ts.SyntaxKind.EqualsToken + ) + return false; + return !this.isBuiltinIterable(parent.right); + } + if (ts.isTemplateSpan(node)) return !this.isPrimitive(node.expression); + if (ts.isBinaryExpression(node)) { + if (!CONVERTING_OPERATORS.has(node.operatorToken.kind)) return false; + return !this.isPrimitive(node.left) || !this.isPrimitive(node.right); + } + if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) { + const symbol = checker.getSymbolAtLocation( + ts.isPropertyAccessExpression(node) ? node.name : node.argumentExpression, + ); + if (!symbol) return true; + return ( + (symbol.flags & (ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor)) !== 0 && + !this.lowerer.isStdlibSymbol(symbol) + ); + } + if (ts.isClassLikeDeclaration(node)) { + if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.Decorator)) return true; + for (const clause of node.heritageClauses ?? []) { + for (const heritage of clause.types) { + const e = heritage.expression; + if (!ts.isIdentifier(e) && !ts.isPropertyAccessExpression(e)) return true; + } + } + return node.members.some( + (member) => + ts.isClassStaticBlockDeclaration(member) || + (member.name !== undefined && ts.isComputedPropertyName(member.name)) || + member.modifiers?.some((m) => m.kind === ts.SyntaxKind.Decorator) === true || + (ts.isPropertyDeclaration(member) && + member.initializer !== undefined && + member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword) === true), + ); + } + return true; + } + + private isInertLibraryCall(call: ts.CallExpression): boolean { + if (call.expression.kind === ts.SyntaxKind.SuperKeyword) return false; + if (call.expression.kind === ts.SyntaxKind.ImportKeyword) return false; + if (!this.inertArguments(call.arguments)) return false; + const callee = skipOuter(call.expression); + if (ts.isIdentifier(callee)) { + if (!INERT_GLOBAL_FUNCTIONS.has(callee.text)) return false; + if (!this.lowerer.isStdlibGlobal(callee, callee.text)) return false; + return call.arguments.every((arg) => this.isPrimitive(arg)); + } + if (!ts.isPropertyAccessExpression(callee)) return false; + const method = callee.name.text; + const receiver = skipOuter(callee.expression); + if (ts.isIdentifier(receiver)) { + const members = INERT_NAMESPACE_MEMBERS.get(receiver.text); + if (members !== undefined && this.lowerer.isStdlibGlobal(receiver, receiver.text)) + return members === "*" || members.has(method); + } + const checker = this.lowerer.checker; + const type = checker.getTypeAtLocation(callee.expression); + if (type.flags & PRIMITIVE_FLAGS) return true; + if (checker.isArrayType(type) || checker.isTupleType(type)) + return !ARRAY_CONVERTING_METHODS.has(method); + const symbol = type.getSymbol(); + return ( + symbol !== undefined && + BUILTIN_COLLECTIONS.has(symbol.name) && + this.lowerer.isStdlibSymbol(symbol) + ); + } + + private isInertConstruction(node: ts.NewExpression): boolean { + const callee = skipOuter(node.expression); + if (!ts.isIdentifier(callee) || !INERT_CONSTRUCTORS.has(callee.text)) return false; + if (!this.lowerer.isStdlibGlobal(callee, callee.text)) return false; + const args = node.arguments ?? []; + if (!this.inertArguments(args)) return false; + return args.every((arg) => this.isPrimitive(arg) || this.isBuiltinIterable(arg)); + } + + /** No argument is a function the callee could invoke. */ + private inertArguments(args: readonly ts.Expression[]): boolean { + const checker = this.lowerer.checker; + for (const arg of args) { + const e = skipOuter(arg); + if (ts.isArrowFunction(e) || ts.isFunctionExpression(e)) return false; + if (ts.isSpreadElement(e)) continue; + if ( + ts.isStringLiteral(e) || + ts.isNumericLiteral(e) || + ts.isNoSubstitutionTemplateLiteral(e) || + e.kind === ts.SyntaxKind.TrueKeyword || + e.kind === ts.SyntaxKind.FalseKeyword + ) + continue; + const type = checker.getTypeAtLocation(e); + if (type.flags & PRIMITIVE_FLAGS) continue; + if (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return false; + if (checker.getCallSignatures(type).length > 0) return false; + if (this.program().conversion && !(type.flags & ts.TypeFlags.Object)) return false; + } + return true; + } + + private isPrimitive(node: ts.Expression): boolean { + return (this.lowerer.checker.getTypeAtLocation(node).flags & PRIMITIVE_FLAGS) !== 0; + } + + private isBuiltinIterable(node: ts.Expression): boolean { + const checker = this.lowerer.checker; + const type = checker.getTypeAtLocation(node); + if (type.flags & ts.TypeFlags.StringLike) return true; + return checker.isArrayType(type) || checker.isTupleType(type); + } +} + +interface ProgramFacts { + /** Property names stored anywhere outside a constructor's own `this`. */ + mutable: Set; + /** Names of user-declared accessors. */ + accessors: Set; + /** A computed or reflective store can reach any class instance field. */ + wildcard: boolean; + /** The program defines `toString`/`valueOf`/`toJSON`/`Symbol.toPrimitive`. */ + conversion: boolean; + /** The program defines generators or `Symbol.iterator` members. */ + iteration: boolean; +} + +/** A node and the source position at which its evaluation takes effect. */ +interface Timed { + node: T; + at: number; +} + +interface FunctionFacts { + /** Candidates that may run other code, ordered by `at`. */ + effects: Timed[]; + /** Member store targets, ordered by when the store happens. */ + writes: Timed[]; + loops: ts.Node[]; + /** References by final name (`.name` for members), in source order. */ + refs: Map; +} + +interface ReferenceChain { + key: string; + root: ts.Node; + links: { name: string; node: ts.PropertyAccessExpression | ts.ElementAccessExpression }[]; +} + +type WidePosition = "chain" | "member" | "test" | "context"; + +const PRIMITIVE_FLAGS = + ts.TypeFlags.StringLike | + ts.TypeFlags.NumberLike | + ts.TypeFlags.BooleanLike | + ts.TypeFlags.BigIntLike | + ts.TypeFlags.Undefined | + ts.TypeFlags.Null | + ts.TypeFlags.Void; + +const CONVERTING_OPERATORS = new Set([ + ts.SyntaxKind.PlusToken, + ts.SyntaxKind.MinusToken, + ts.SyntaxKind.AsteriskToken, + ts.SyntaxKind.SlashToken, + ts.SyntaxKind.PercentToken, + ts.SyntaxKind.AsteriskAsteriskToken, + ts.SyntaxKind.LessThanToken, + ts.SyntaxKind.GreaterThanToken, + ts.SyntaxKind.LessThanEqualsToken, + ts.SyntaxKind.GreaterThanEqualsToken, + ts.SyntaxKind.EqualsEqualsToken, + ts.SyntaxKind.ExclamationEqualsToken, + ts.SyntaxKind.AmpersandToken, + ts.SyntaxKind.BarToken, + ts.SyntaxKind.CaretToken, + ts.SyntaxKind.LessThanLessThanToken, + ts.SyntaxKind.GreaterThanGreaterThanToken, + ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken, + ts.SyntaxKind.PlusEqualsToken, + ts.SyntaxKind.MinusEqualsToken, + ts.SyntaxKind.AsteriskEqualsToken, + ts.SyntaxKind.SlashEqualsToken, + ts.SyntaxKind.PercentEqualsToken, +]); + +/** Global functions that never call back when given primitive arguments. */ +const INERT_GLOBAL_FUNCTIONS = new Set([ + "parseInt", + "parseFloat", + "isNaN", + "isFinite", + "encodeURIComponent", + "decodeURIComponent", + "encodeURI", + "decodeURI", + "String", + "Number", + "Boolean", +]); + +/** Standard namespaces whose listed members never call back into the + * program when given no function argument. */ +const INERT_NAMESPACE_MEMBERS = new Map | "*">([ + ["Math", "*"], + ["console", "*"], + [ + "Number", + new Set(["isInteger", "isFinite", "isNaN", "isSafeInteger", "parseFloat", "parseInt"]), + ], + ["String", new Set(["fromCharCode", "fromCodePoint"])], + [ + "Object", + new Set(["keys", "values", "entries", "hasOwn", "getPrototypeOf", "is", "getOwnPropertyNames"]), + ], + ["Array", new Set(["isArray"])], + ["Date", new Set(["now"])], +]); + +/** Array methods that convert their elements through user hooks. */ +const ARRAY_CONVERTING_METHODS = new Set([ + "join", + "toString", + "toLocaleString", + "sort", + "toSorted", +]); + +const BUILTIN_COLLECTIONS = new Set([ + "Map", + "Set", + "WeakMap", + "WeakSet", + "ReadonlyMap", + "ReadonlySet", +]); + +const INERT_CONSTRUCTORS = new Set([ + "Map", + "Set", + "WeakMap", + "WeakSet", + "Array", + "Error", + "TypeError", + "RangeError", + "SyntaxError", + "Date", + "RegExp", + "Uint8Array", + "Int8Array", + "Uint16Array", + "Int16Array", + "Uint32Array", + "Int32Array", + "Float32Array", + "Float64Array", + "BigInt64Array", + "BigUint64Array", +]); + +/** Where a stale narrowed read can keep its declared representation: the + * receiver of `?.`, an absence/type/truthiness test, or a slot whose + * contextual type may accept the declared type. */ +function widePosition(node: ts.Expression): WidePosition | null { + let child: ts.Node = node; + let parent = node.parent; + while (ts.isParenthesizedExpression(parent)) { + child = parent; + parent = parent.parent; + } + if ( + (ts.isPropertyAccessExpression(parent) || + ts.isElementAccessExpression(parent) || + ts.isCallExpression(parent)) && + parent.expression === child + ) { + if (parent.questionDotToken !== undefined) return "chain"; + return memberUse(node) !== null ? "member" : null; + } + if (ts.isBinaryExpression(parent)) { + switch (parent.operatorToken.kind) { + case ts.SyntaxKind.QuestionQuestionToken: + case ts.SyntaxKind.BarBarToken: + case ts.SyntaxKind.AmpersandAmpersandToken: + case ts.SyntaxKind.InstanceOfKeyword: + return parent.left === child ? "test" : null; + case ts.SyntaxKind.EqualsEqualsEqualsToken: + case ts.SyntaxKind.ExclamationEqualsEqualsToken: + case ts.SyntaxKind.EqualsEqualsToken: + case ts.SyntaxKind.ExclamationEqualsToken: + return "test"; + case ts.SyntaxKind.EqualsToken: + return parent.right === child ? "context" : null; + default: + return null; + } + } + if (ts.isPrefixUnaryExpression(parent)) + return parent.operator === ts.SyntaxKind.ExclamationToken ? "test" : null; + if (ts.isTypeOfExpression(parent)) return "test"; + if (ts.isTemplateSpan(parent)) return "test"; + if ( + (ts.isIfStatement(parent) || ts.isWhileStatement(parent) || ts.isDoStatement(parent)) && + parent.expression === child + ) + return "test"; + if (ts.isConditionalExpression(parent) && parent.condition === child) return "test"; + if (ts.isForStatement(parent) && parent.condition === child) return "test"; + if ( + (ts.isCallExpression(parent) || ts.isNewExpression(parent)) && + parent.arguments?.some((arg) => arg === child) + ) + return "context"; + // Only slots whose type IS the contextual type: an array or object + // literal (or an unannotated arrow body) infers its own type from the + // narrowed element instead. + if (ts.isReturnStatement(parent)) return "context"; + if (ts.isVariableDeclaration(parent) && parent.initializer === child && parent.type) + return "context"; + return null; +} + +/** The plain member read or method call `node` is the receiver of + * (`node.name`, `node.name(...)`; not a store target or optional step). */ +function memberUse( + node: ts.Expression, +): { access: ts.PropertyAccessExpression; call: boolean } | null { + let child: ts.Node = node; + let parent = node.parent; + while (ts.isParenthesizedExpression(parent)) { + child = parent; + parent = parent.parent; + } + if (!ts.isPropertyAccessExpression(parent) || parent.expression !== child) return null; + if (parent.questionDotToken !== undefined) return null; + const outer = parent.parent; + if (outer && writeTargetOf(outer) === parent) return null; + const call = outer !== undefined && ts.isCallExpression(outer) && outer.expression === parent; + if (call && (outer as ts.CallExpression).questionDotToken !== undefined) return null; + return { access: parent, call }; +} + +/** The function-like body, class member initializer or file whose flow + * contains `node`. */ +function flowBoundary(node: ts.Node): ts.Node { + let n: ts.Node | undefined = node.parent; + while (n && !isFlowBoundary(n)) n = n.parent; + return n ?? node.getSourceFile(); +} + +function isFlowBoundary(node: ts.Node): boolean { + return ( + ts.isFunctionLike(node) || + ts.isClassStaticBlockDeclaration(node) || + ts.isPropertyDeclaration(node) || + ts.isSourceFile(node) + ); +} + +function skipOuter(node: ts.Expression): ts.Expression { + let e = node; + while ( + ts.isParenthesizedExpression(e) || + ts.isNonNullExpression(e) || + ts.isAsExpression(e) || + ts.isTypeAssertion(e) || + ts.isSatisfiesExpression(e) + ) { + e = e.expression; + } + return e; +} + +/** A member access's name when it is static (`o.p`, `o["p"]`, `o[0]`). */ +function accessName(node: ts.Node): string | null { + if (ts.isPropertyAccessExpression(node)) return node.name.text; + if (ts.isElementAccessExpression(node)) { + const arg = node.argumentExpression; + if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) return arg.text; + if (ts.isNumericLiteral(arg)) return String(Number(arg.text)); + } + return null; +} + +/** The normalized spelling TypeScript's reference matching would equate: + * parentheses, non-null and type assertions erased, `o["p"]` as `o.p`. */ +function referenceKey(node: ts.Node): string | null { + const e = skipOuter(node as ts.Expression); + if (ts.isIdentifier(e)) return e.text; + if (e.kind === ts.SyntaxKind.ThisKeyword) return "this"; + if (ts.isPropertyAccessExpression(e) || ts.isElementAccessExpression(e)) { + const name = accessName(e); + if (name === null) return null; + const receiver = referenceKey(e.expression); + return receiver === null ? null : `${receiver}.${name}`; + } + return null; +} + +function referenceChain(node: ts.Expression): ReferenceChain | null { + const key = referenceKey(node); + if (key === null) return null; + const links: ReferenceChain["links"] = []; + let e = skipOuter(node); + while (ts.isPropertyAccessExpression(e) || ts.isElementAccessExpression(e)) { + links.unshift({ name: accessName(e)!, node: e }); + e = skipOuter(e.expression); + } + return { key, root: e, links }; +} + +function memberName(name: ts.Node): string | null { + if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text; + if (ts.isNumericLiteral(name)) return String(Number(name.text)); + if (ts.isPrivateIdentifier(name)) return name.text; + return null; +} + +/** An identifier that reads or declares a binding (not a member name). */ +function isValueIdentifier(node: ts.Identifier): boolean { + const parent = node.parent; + if (ts.isPropertyAccessExpression(parent) && parent.name === node) return false; + if ( + (ts.isPropertyAssignment(parent) || + ts.isPropertyDeclaration(parent) || + ts.isMethodDeclaration(parent) || + ts.isPropertySignature(parent) || + ts.isGetAccessorDeclaration(parent) || + ts.isSetAccessorDeclaration(parent)) && + parent.name === node + ) + return false; + return true; +} + +/** The store target expression of an assignment-like node. */ +function writeTargetOf(node: ts.Node): ts.Node | null { + if (ts.isBinaryExpression(node)) { + const op = node.operatorToken.kind; + if (op >= ts.SyntaxKind.FirstAssignment && op <= ts.SyntaxKind.LastAssignment) return node.left; + return null; + } + if ( + (ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) && + (node.operator === ts.SyntaxKind.PlusPlusToken || + node.operator === ts.SyntaxKind.MinusMinusToken) + ) + return node.operand; + if (ts.isDeleteExpression(node)) return node.expression; + if ( + (ts.isForOfStatement(node) || ts.isForInStatement(node)) && + !ts.isVariableDeclarationList(node.initializer) + ) + return node.initializer; + return null; +} + +/** Each stored-to reference in a target, through destructuring patterns. */ +function forEachWriteTarget(target: ts.Node, visit: (target: ts.Expression) => void): void { + const e = skipOuter(target as ts.Expression); + if (ts.isIdentifier(e) || ts.isPropertyAccessExpression(e) || ts.isElementAccessExpression(e)) { + visit(e); + return; + } + if (ts.isArrayLiteralExpression(e)) { + for (const element of e.elements) { + forEachWriteTarget(ts.isSpreadElement(element) ? element.expression : element, visit); + } + return; + } + if (ts.isObjectLiteralExpression(e)) { + for (const property of e.properties) { + if (ts.isPropertyAssignment(property)) forEachWriteTarget(property.initializer, visit); + else if (ts.isShorthandPropertyAssignment(property) && ts.isIdentifier(property.name)) + visit(property.name); + else if (ts.isSpreadAssignment(property)) forEachWriteTarget(property.expression, visit); + } + return; + } + if (ts.isBinaryExpression(e) && e.operatorToken.kind === ts.SyntaxKind.EqualsToken) { + // A destructuring default: `[a = 1] = xs`. + forEachWriteTarget(e.left, visit); + } +} + +/** `this.p = ...` directly in a constructor body, before the object can + * be observed by code that narrowed it. */ +function isConstructorThisStore(target: ts.Expression): boolean { + if (!ts.isPropertyAccessExpression(target) && !ts.isElementAccessExpression(target)) return false; + if (skipOuter(target.expression).kind !== ts.SyntaxKind.ThisKeyword) return false; + return ts.isConstructorDeclaration(flowBoundary(target)); +} + +/** `Object.assign(target, ...)` and similar reflective stores into an + * existing object. */ +function reflectiveStore(call: ts.CallExpression): boolean { + const callee = skipOuter(call.expression); + if (!ts.isPropertyAccessExpression(callee) || !ts.isIdentifier(callee.expression)) return false; + const owner = callee.expression.text; + const method = callee.name.text; + const reflective = + (owner === "Object" && + (method === "assign" || + method === "defineProperty" || + method === "defineProperties" || + method === "setPrototypeOf")) || + (owner === "Reflect" && + (method === "set" || + method === "defineProperty" || + method === "deleteProperty" || + method === "setPrototypeOf")); + if (!reflective) return false; + const target = call.arguments[0]; + return target === undefined || !ts.isObjectLiteralExpression(skipOuter(target)); +} + +function isPlainContainerType(checker: ts.TypeChecker, type: ts.Type): boolean { + if (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return false; + const parts = type.isUnionType() ? ts.constituentTypes(type) : [type]; + return parts.every((part) => { + if (part.flags & (ts.TypeFlags.Undefined | ts.TypeFlags.Null)) return true; + if (checker.isArrayType(part) || checker.isTupleType(part) || checker.isArrayLikeType(part)) + return true; + const symbol = part.getSymbol(); + if (symbol && symbol.flags & ts.SymbolFlags.Class) return false; + return checker.getIndexInfosOfType(part).length > 0; + }); +} + +/** Entries of an `at`-ordered list taking effect in `(start, end]`. */ +function between( + entries: readonly Timed[], + start: number, + end: number, +): Timed[] { + let lo = 0; + let hi = entries.length; + while (lo < hi) { + const mid = (lo + hi) >> 1; + if (entries[mid]!.at <= start) lo = mid + 1; + else hi = mid; + } + const out: Timed[] = []; + for (let i = lo; i < entries.length && entries[i]!.at <= end; i++) out.push(entries[i]!); + return out; +} diff --git a/packages/compiler/test/ts7/baselines/order-parity.json b/packages/compiler/test/ts7/baselines/order-parity.json index 7bf630618..bd4990121 100644 --- a/packages/compiler/test/ts7/baselines/order-parity.json +++ b/packages/compiler/test/ts7/baselines/order-parity.json @@ -15742,6 +15742,12 @@ "/tests/corpus/4596-tdz-nullable-forward-capture.ts" ], "diags": [] + }, + "/tests/corpus/4650-stale-property-narrowing.ts": { + "order": [ + "/tests/corpus/4650-stale-property-narrowing.ts" + ], + "diags": [] } } } diff --git a/tests/corpus/4650-stale-property-narrowing.ts b/tests/corpus/4650-stale-property-narrowing.ts new file mode 100644 index 000000000..6faa7c4cd --- /dev/null +++ b/tests/corpus/4650-stale-property-narrowing.ts @@ -0,0 +1,263 @@ +// TypeScript keeps a property's narrowing (and that of a binding a closure +// assigns) across calls: after `c.cb = fn` or `if (c.name !== undefined)`, +// a callback, method or getter that clears or replaces the property leaves +// later reads typed by the old value. Each read must observe the value the +// property holds now: optional calls and chains short-circuit, absence and +// type tests answer for the current value, other arms read their own +// members, and a member access on a cleared value throws Node's TypeError. +// Reads with no intervening code, or of construction-only fields, keep the +// narrowing. + +class Callbacks { + cb: ((s: string) => number) | undefined = undefined; + name: string | undefined = "named"; + count: string | number = 1; + item: Item | null = new Item(1); + clear(): void { + this.name = undefined; + this.count = "many"; + this.item = null; + } +} + +class Item { + v: number; + constructor(v: number) { + this.v = v; + } +} + +function message(e: unknown): string { + return e instanceof TypeError ? `TypeError: ${e.message}` : String(e); +} + +// The reported shape: the callback clears the field it was called through. +const c = new Callbacks(); +c.cb = (s: string): number => { + c.cb = undefined; + return s.length; +}; +console.log("optional calls:", c.cb?.("abc"), c.cb?.("abcd")); + +function inFunction(target: Callbacks): void { + target.cb = (s: string): number => { + target.cb = undefined; + return s.length * 10; + }; + const first = target.cb?.("ab"); + const second = target.cb?.("abc"); + console.log("in a function:", first, second); + target.cb = (s: string): number => { + target.cb = undefined; + return s.length + 100; + }; + console.log("direct call:", target.cb("x")); + try { + console.log(target.cb("y")); + } catch (e) { + console.log("second direct call:", message(e)); + } +} +inFunction(new Callbacks()); + +// A method clears fields narrowed by a test; every consumer sees the clear. +function afterMethod(): void { + const o = new Callbacks(); + if (o.name !== undefined) { + o.clear(); + console.log("chain:", o.name?.length, o.name?.toUpperCase()); + console.log("nullish:", o.name ?? "none", o.name || "falsy"); + console.log("tests:", o.name === undefined, o.name !== undefined, typeof o.name, !o.name); + console.log("condition:", o.name ? "present" : "absent"); + const kept: string | undefined = o.name; + console.log("value:", o.name, `${o.name}`, kept); + try { + console.log(o.name.length); + } catch (e) { + console.log("member read:", message(e)); + } + } + const p = new Callbacks(); + if (p.item !== null) { + p.clear(); + console.log("null arm:", p.item?.v, p.item === null); + try { + console.log(p.item.v); + } catch (e) { + console.log("member read:", message(e)); + } + } +} +afterMethod(); + +// A union narrowed by typeof is replaced by its other arm. +function otherArm(): void { + const o = new Callbacks(); + if (typeof o.count === "number") { + o.clear(); + console.log("typeof after replace:", typeof o.count, o.count); + } +} +otherArm(); + +// Interface (record) fields and a free function as the intervening call. +interface Options { + label?: string; + retries?: number; +} +const options: Options = {}; +function resetOptions(): void { + options.label = undefined; + options.retries = undefined; +} +options.label = "first"; +options.retries = 3; +resetOptions(); +console.log("record fields:", options.label?.length, options.label ?? "unset", options.retries ?? -1); + +// A getter is the intervening call; a narrowed getter reads afresh. +class Lazy { + data: string | undefined = "data"; + reads = 0; + get reset(): number { + this.data = undefined; + return 0; + } + get flip(): string | undefined { + this.reads++; + return this.reads % 2 === 1 ? "odd" : undefined; + } +} +const lazy = new Lazy(); +if (lazy.data) { + const z = lazy.reset; + console.log("getter clears:", z, lazy.data?.toUpperCase(), lazy.data ? "kept" : "gone"); +} +if (lazy.flip) { + console.log("narrowed getter:", lazy.flip?.length, typeof lazy.flip); +} + +// Callbacks run by library code (forEach) and a loop whose body clears the +// field after the read, reaching the read again through the back edge. +const forEachTarget = new Callbacks(); +forEachTarget.cb = (s: string): number => s.length * 2; +const doubled: (number | undefined)[] = []; +["a", "bb", "ccc"].forEach((s) => { + doubled.push(forEachTarget.cb?.(s)); + if (s === "bb") forEachTarget.cb = undefined; +}); +console.log("forEach:", doubled.join(" ")); +const looped = new Callbacks(); +const seen: string[] = []; +if (looped.item) { + for (let i = 0; i < 3; i++) { + seen.push(String(looped.item?.v)); + looped.clear(); + } +} +console.log("loop:", seen.join(" ")); + +// A store through another reference to the same object, with no call. +const aliased = new Callbacks(); +const alias = aliased; +if (aliased.name) { + alias.name = undefined; + console.log("alias store:", aliased.name?.length, aliased.name === undefined); +} + +// A discriminated union field replaced by another arm, and a subclass +// narrowed by instanceof replaced by its base class. +interface Circle { + kind: "circle"; + r: number; +} +interface Square { + kind: "square"; + side: number; +} +class Scene { + shape: Circle | Square = { kind: "square", side: 2 }; + morph(): void { + this.shape = { kind: "circle", r: 3 }; + } +} +const scene = new Scene(); +if (scene.shape.kind === "square") { + scene.morph(); + console.log("discriminant:", scene.shape.kind); +} +class Base { + name(): string { + return "base"; + } +} +class Derived extends Base { + name(): string { + return "derived"; + } +} +class Slot { + v: Base = new Derived(); + reset(): void { + this.v = new Base(); + } +} +const slot = new Slot(); +if (slot.v instanceof Derived) { + slot.reset(); + console.log("instanceof:", slot.v instanceof Derived, slot.v.name()); +} + +// A binding a closure assigns, as a value and as the root of a member read. +function closures(): void { + let text: string | undefined = "text"; + const drop = (): void => { + text = undefined; + }; + text = "again"; + drop(); + console.log("closure binding:", text?.length, text ?? "dropped"); + let holder = new Callbacks(); + const swap = (): void => { + holder = new Callbacks(); + holder.name = undefined; + }; + if (holder.name) { + swap(); + console.log("closure root:", holder.name?.length, holder.name ?? "swapped"); + } +} +closures(); + +// Narrowings that stay valid: no intervening call, only library calls, or +// construction-only fields across a user call. +class Tree { + parent: Tree | undefined; + label: string | undefined; + depth: number; + constructor(parent: Tree | undefined, label: string | undefined) { + this.parent = parent; + this.label = label; + this.depth = parent ? parent.depth + 1 : 0; + } +} +function visit(t: Tree): number { + return t.depth; +} +function stable(t: Tree, out: number[]): number { + let total = 0; + if (t.parent) { + visit(t); + total += t.parent.depth; + } + if (t.label !== undefined) { + out.push(Math.max(t.label.length, 1)); + total += t.label.length; + } + return total; +} +const leaf = new Tree(new Tree(new Tree(undefined, "root"), undefined), "leaf"); +const lengths: number[] = []; +let sum = 0; +for (let i = 0; i < 1000; i++) sum += stable(leaf, lengths); +console.log("stable:", sum, lengths.length); From 483166552441c48fd21f8a4ec3b640faca858313 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 11 Oct 2026 02:43:31 -0700 Subject: [PATCH 2/8] Restore present arms of stale narrowings in typed slots An assignment narrows a binding to the assigned arm, and TypeScript keeps that narrowing across a closure or method that stores another arm. After `if (acc !== null) return acc;` the checker still types the read as the old arm, the return slot rejects the declared `T | null`, and the checked extraction threw on the value the closure stored, where Node returns it. The compiler itself has this shape (lowerDynObjectLiteral), so the native compiler aborted with "a value of another type is not representable in the target union" and closure-nullable-union-return.ts diverged. A slot that accepts the declared type minus null/undefined now reads the stale reference as NonNullable, like a binding narrowed only by the absence test. Elements and properties of array and object literals are such slots when the literal itself sits in a typed slot (annotated declaration, argument, assignment, return of a function with a declared return type). Untyped literals keep the checked extraction. --- .../frontend/lowering/narrowing-stability.ts | 64 ++++++++- .../test/ts7/baselines/order-parity.json | 6 + .../4652-stale-closure-binding-narrowing.ts | 130 ++++++++++++++++++ 3 files changed, 197 insertions(+), 3 deletions(-) create mode 100644 tests/corpus/4652-stale-closure-binding-narrowing.ts diff --git a/packages/compiler/src/frontend/lowering/narrowing-stability.ts b/packages/compiler/src/frontend/lowering/narrowing-stability.ts index 954d9fee8..afeae5353 100644 --- a/packages/compiler/src/frontend/lowering/narrowing-stability.ts +++ b/packages/compiler/src/frontend/lowering/narrowing-stability.ts @@ -146,8 +146,22 @@ export class NarrowingStability { if ( !(contextual.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) && !checker.isTypeAssignableTo(declared, contextual) - ) - return null; + ) { + // A slot that takes the declared type minus null/undefined after an + // absence test (`if (acc !== null) return acc`): the checker's + // narrowing can also hold an arm an assignment chose before the + // call that stored another one. Restore every present arm, the way + // a binding narrowed only by the test reads. + if (classNarrowing) return null; + const present = checker.getNonNullableType(declared); + if ( + present === declared || + !checker.isTypeAssignableTo(narrowedTs, present) || + !checker.isTypeAssignableTo(present, contextual) + ) + return null; + return this.trusted(node) ? null : present; + } } return this.trusted(node) ? null : declared; } @@ -838,13 +852,57 @@ function widePosition(node: ts.Expression): WidePosition | null { return "context"; // Only slots whose type IS the contextual type: an array or object // literal (or an unannotated arrow body) infers its own type from the - // narrowed element instead. + // narrowed element instead, unless the literal itself sits in a typed + // slot (`const xs: Expr[] = [x]`, `{ value }` passed as a parameter). if (ts.isReturnStatement(parent)) return "context"; + if ( + (ts.isArrayLiteralExpression(parent) || + (ts.isPropertyAssignment(parent) && parent.initializer === child) || + ts.isShorthandPropertyAssignment(parent)) && + typedLiteral(parent) + ) + return "context"; if (ts.isVariableDeclaration(parent) && parent.initializer === child && parent.type) return "context"; return null; } +/** The array or object literal holding `parent` (an element's literal or a + * property assignment) is itself lowered against a declared slot type. */ +function typedLiteral( + parent: ts.ArrayLiteralExpression | ts.PropertyAssignment | ts.ShorthandPropertyAssignment, +): boolean { + let literal: ts.Node | undefined = ts.isArrayLiteralExpression(parent) ? parent : parent.parent; + while (literal) { + let slot: ts.Node | undefined = literal.parent; + while (slot && ts.isParenthesizedExpression(slot)) { + literal = slot; + slot = slot.parent; + } + if (!slot) return false; + if (ts.isVariableDeclaration(slot)) return slot.initializer === literal && !!slot.type; + if (ts.isCallExpression(slot) || ts.isNewExpression(slot)) + return slot.arguments?.some((arg) => arg === literal) ?? false; + if (ts.isBinaryExpression(slot)) + return slot.operatorToken.kind === ts.SyntaxKind.EqualsToken && slot.right === literal; + if (ts.isReturnStatement(slot)) { + let fn: ts.Node | undefined = slot.parent; + while (fn && !ts.isFunctionLike(fn)) fn = fn.parent; + return fn !== undefined && ts.isFunctionLike(fn) && fn.type !== undefined; + } + if (ts.isArrayLiteralExpression(slot)) { + literal = slot; + continue; + } + if (ts.isPropertyAssignment(slot) && slot.initializer === literal) { + literal = slot.parent; + continue; + } + return false; + } + return false; +} + /** The plain member read or method call `node` is the receiver of * (`node.name`, `node.name(...)`; not a store target or optional step). */ function memberUse( diff --git a/packages/compiler/test/ts7/baselines/order-parity.json b/packages/compiler/test/ts7/baselines/order-parity.json index bd4990121..79cc0ac78 100644 --- a/packages/compiler/test/ts7/baselines/order-parity.json +++ b/packages/compiler/test/ts7/baselines/order-parity.json @@ -15748,6 +15748,12 @@ "/tests/corpus/4650-stale-property-narrowing.ts" ], "diags": [] + }, + "/tests/corpus/4652-stale-closure-binding-narrowing.ts": { + "order": [ + "/tests/corpus/4652-stale-closure-binding-narrowing.ts" + ], + "diags": [] } } } diff --git a/tests/corpus/4652-stale-closure-binding-narrowing.ts b/tests/corpus/4652-stale-closure-binding-narrowing.ts new file mode 100644 index 000000000..18ba9924a --- /dev/null +++ b/tests/corpus/4652-stale-closure-binding-narrowing.ts @@ -0,0 +1,130 @@ +// An assignment narrows a `let` (or a property) to the assigned arm, and a +// later null test narrows away null. TypeScript keeps the assignment's +// narrowing across a call to a closure or method that stores another arm, +// so after `if (acc !== null)` the checker still types the read as the old +// arm. A slot that accepts the declared type minus null (a return, an +// argument, an annotated declaration, an assignment) must receive the value +// stored now, as Node passes it on. + +type Lit = { kind: "lit"; value: number }; +type Sum = { kind: "sum"; left: Expr; right: Expr }; +type Neg = { kind: "neg"; operand: Expr }; +type Expr = Lit | Sum | Neg; + +function show(e: Expr): string { + switch (e.kind) { + case "lit": + return String(e.value); + case "sum": + return `(${show(e.left)} + ${show(e.right)})`; + case "neg": + return `-${show(e.operand)}`; + } +} + +// The compiler's own shape: chunks flushed by a closure into an +// accumulator that the loop also wraps directly. +function fold(values: readonly (number | "neg")[]): Expr { + let pending: number[] = []; + let acc: Expr | null = null; + const flush = (): void => { + if (pending.length === 0) return; + let chunk: Expr = { kind: "lit", value: pending[0]! }; + for (const v of pending.slice(1)) chunk = { kind: "sum", left: chunk, right: { kind: "lit", value: v } }; + acc = acc === null ? chunk : { kind: "sum", left: acc, right: chunk }; + pending = []; + }; + for (const v of values) { + if (v === "neg") { + flush(); + acc ??= { kind: "lit", value: 0 }; + acc = { kind: "neg", operand: acc }; + continue; + } + pending.push(v); + } + flush(); + if (acc !== null) return acc; + return { kind: "lit", value: 0 }; +} + +console.log("fold:", show(fold([1, 2]))); +console.log("fold:", show(fold([1, "neg", 2, 3]))); +console.log("fold:", show(fold(["neg", 4]))); +console.log("fold:", show(fold([]))); + +function describe(e: Expr): string { + return `${e.kind} ${show(e)}`; +} + +// Argument, annotated declaration and assignment slots. +function slots(replace: boolean): string[] { + let current: Expr | null = null; + const reset = (): void => { + current = { kind: "lit", value: 7 }; + }; + current = { kind: "neg", operand: { kind: "lit", value: 1 } }; + if (replace) reset(); + const out: string[] = []; + if (current !== null) { + out.push(describe(current)); + const held: Expr = current; + out.push(held.kind); + let assigned: Expr = { kind: "lit", value: 0 }; + assigned = current; + out.push(show(assigned)); + } + return out; +} + +console.log("slots:", slots(false).join(" | ")); +console.log("slots:", slots(true).join(" | ")); + +// Elements and properties of literals that sit in typed slots. +function containers(): string[] { + let item: Expr | null = null; + const swap = (): void => { + item = { kind: "lit", value: 3 }; + }; + item = { kind: "neg", operand: { kind: "lit", value: 2 } }; + swap(); + const out: string[] = []; + if (item !== null) { + const list: Expr[] = [item, { kind: "lit", value: 4 }]; + const box: { value: Expr; label: string } = { value: item, label: "box" }; + const nested: { items: Expr[] } = { items: [item] }; + const shorthand: { item: Expr } = { item }; + out.push(list.map(show).join(","), show(box.value), show(nested.items[0]!), show(shorthand.item)); + } + return out; +} + +console.log("containers:", containers().join(" | ")); + +// The same through a property a method replaces. +class Holder { + expr: Expr | null = null; + replace(): void { + this.expr = { kind: "lit", value: 42 }; + } +} + +function viaMember(h: Holder, replace: boolean): Expr { + h.expr = { kind: "neg", operand: { kind: "lit", value: 5 } }; + if (replace) h.replace(); + if (h.expr !== null) return h.expr; + return { kind: "lit", value: -1 }; +} + +console.log("member:", show(viaMember(new Holder(), false))); +console.log("member:", show(viaMember(new Holder(), true))); + +// No intervening call: the narrowing is current and the read keeps it. +function direct(): number { + let e: Expr | null = null; + e = { kind: "lit", value: 9 }; + if (e !== null) return e.value; + return 0; +} + +console.log("direct:", direct()); From bc899558595871d010add31c96f56da13e5bf55a Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 11 Oct 2026 08:17:00 -0700 Subject: [PATCH 3/8] Keep stale narrowings in specialized standard-library arguments A stale narrowing read in a call argument whose parameter accepts the declared type read as declared, so the callee's lowering tests the stored value. For standard-library callees that lowering is often specialized to the argument types programs pass: after `combo.p = {...}; combo()` the argument of `JSON.stringify(combo.p)` became `T | undefined` (SC1090), and after `ci(slow)` the handle of `timers.clearInterval(fast)` became `number | null` (SC2020), so 2072-expando-function-members.ts and 1804-timers-module.ts stopped compiling. Call and construction arguments (directly or inside literal arguments) now read as declared only where the callee lowers any value of the parameter type: user callees, console methods, and standard-library parameters typed by a type parameter (`push(...items: T[])`, `Map.set`). Other standard-library arguments keep the checker's narrowing and the checked extraction. --- .../lowering/narrowing-stability.test.ts | 40 ++++++++++++ .../frontend/lowering/narrowing-stability.ts | 65 +++++++++++++++++++ 2 files changed, 105 insertions(+) diff --git a/packages/compiler/src/frontend/lowering/narrowing-stability.test.ts b/packages/compiler/src/frontend/lowering/narrowing-stability.test.ts index 81bea782c..577356fc6 100644 --- a/packages/compiler/src/frontend/lowering/narrowing-stability.test.ts +++ b/packages/compiler/src/frontend/lowering/narrowing-stability.test.ts @@ -113,3 +113,43 @@ test("narrowed reads after code that can clear the field check it with Node's Ty expect(thrownMessages(module, "methodCall")).toContain(read); expect(thrownMessages(module, "loopBackEdge")).toContain(read); }); + +test("standard-library arguments read as declared only where the lowering is generic", async () => { + // JSON.stringify and clearInterval lower only the narrowed argument types; + // console methods and type-parameter slots take the declared value. + const module = await lower(` +interface Opts { + p?: { [k: string]: number }; +} +function touch(): number { + return 1; +} +let handle: ReturnType | null = null; +const stop = (): void => { + handle = null; +}; +function specialized(o: Opts): string { + o.p = { a: 1 }; + touch(); + return JSON.stringify(o.p); +} +function clearAfterCall(): void { + if (handle !== null) { + touch(); + clearInterval(handle); + } +} +function formatted(o: Opts, out: (Opts["p"])[]): void { + o.p = { a: 2 }; + touch(); + console.log(o.p); + out.push(o.p); +} +handle = setInterval(() => {}, 1000); +console.log(specialized({})); +clearAfterCall(); +stop(); +formatted({}, []); +`); + expect(thrownMessages(module, "formatted")).toEqual([]); +}); diff --git a/packages/compiler/src/frontend/lowering/narrowing-stability.ts b/packages/compiler/src/frontend/lowering/narrowing-stability.ts index afeae5353..a1585a24b 100644 --- a/packages/compiler/src/frontend/lowering/narrowing-stability.ts +++ b/packages/compiler/src/frontend/lowering/narrowing-stability.ts @@ -141,6 +141,7 @@ export class NarrowingStability { const present = this.lowerer.mapTypeOf(checker.getNonNullableType(declared)); if (present === null || !typeEquals(present, narrowedIr)) return null; } else if (position === "context") { + if (!this.argumentSlotIsGeneric(node)) return null; const contextual = checker.getContextualType(node); if (contextual === undefined) return null; if ( @@ -166,6 +167,48 @@ export class NarrowingStability { return this.trusted(node) ? null : declared; } + /** A read in a call or construction argument (directly or inside a literal + * argument) reaches the callee's own lowering with the declared type. User + * callees coerce any value of their parameter type, and so do the + * standard library's generic slots: a parameter typed by a type parameter + * (`push(...items: T[])`, `Map.set(key: K, value: V)`) and the console + * methods, which format any value. Other standard-library lowerings are + * specialized to the argument types programs pass and can refuse the + * declared union (`JSON.stringify` of a possibly-undefined value, + * `clearInterval` of a nullable handle). Those arguments keep the checker's + * narrowing, and maybeNarrow reads them through the checked extraction. */ + private argumentSlotIsGeneric(node: ts.Expression): boolean { + const slot = enclosingArgument(node); + if (slot === null) return true; + const { call, argument } = slot; + const checker = this.lowerer.checker; + const signature = checker.getResolvedSignature(call); + const declaration = signature ? checker.signatureDeclaration(signature) : undefined; + if (!declaration || !this.lowerer.isStdlibFile(declaration.getSourceFile())) return true; + const callee = skipOuter(call.expression); + if ( + ts.isPropertyAccessExpression(callee) && + this.lowerer.isStdlibGlobal(skipOuter(callee.expression), "console") + ) + return true; + const index = call.arguments?.indexOf(argument) ?? -1; + const params = declaration.parameters ?? []; + if (index < 0 || params.length === 0) return false; + const param = params[Math.min(index, params.length - 1)]!; + if (index >= params.length && param.dotDotDotToken === undefined) return false; + return param.type !== undefined && this.mentionsTypeParameter(param.type); + } + + private mentionsTypeParameter(node: ts.Node): boolean { + if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName)) { + const symbol = this.lowerer.checker.getSymbolAtLocation(node.typeName); + if (symbol && symbol.flags & ts.SymbolFlags.TypeParameter) return true; + } + return ( + ts.forEachChild(node, (child) => this.mentionsTypeParameter(child) || undefined) ?? false + ); + } + /** The type of the accessed property as declared on the receiver's * (instantiated) type, before any flow narrowing of this reference. */ private declaredPropertyType(node: ts.PropertyAccessExpression): ts.Type | null { @@ -867,6 +910,28 @@ function widePosition(node: ts.Expression): WidePosition | null { return null; } +/** The call or construction whose argument holds `node`, directly or as an + * element or property of literal arguments, with that argument. */ +function enclosingArgument( + node: ts.Expression, +): { call: ts.CallExpression | ts.NewExpression; argument: ts.Expression } | null { + let child: ts.Node = node; + let parent = node.parent; + while ( + ts.isParenthesizedExpression(parent) || + ts.isArrayLiteralExpression(parent) || + ts.isObjectLiteralExpression(parent) || + ts.isShorthandPropertyAssignment(parent) || + (ts.isPropertyAssignment(parent) && parent.initializer === child) + ) { + child = parent; + parent = parent.parent; + } + if (!(ts.isCallExpression(parent) || ts.isNewExpression(parent))) return null; + const argument = parent.arguments?.find((arg) => arg === child); + return argument ? { call: parent, argument } : null; +} + /** The array or object literal holding `parent` (an element's literal or a * property assignment) is itself lowered against a declared slot type. */ function typedLiteral( From 767c33ebdb1f242c8b6aa0d4cdc1d7846239bef1 Mon Sep 17 00:00:00 2001 From: Malte Ubl Date: Sun, 11 Oct 2026 12:58:50 -0700 Subject: [PATCH 4/8] Give glibc's large blocks transparent huge pages Blocks above the small-object classes (array storage, hash tables, link pages, large strings) come from glibc, whose brk heap and per-block mappings stay on 4 KiB pages where THP is in madvise mode; glibc advises its own memory only under the glibc.malloc.hugetlb tunable, which a program cannot set for itself. Once the brk heap passes 32 MiB, every large allocation now advises the heap grown since the previous one (and the aligned interior of big blocks mapped outside it), and glibc's top pad is raised to 32 MiB so heap growth no longer leaves each 2 MiB range straddling the heap end when it is first touched; the mmap and trim thresholds are pinned to their adaptive maxima, which setting the pad would otherwise freeze at their defaults. Linux and glibc only. --- packages/runtime/src/scr_alloc.c | 105 +++++++++++++++++++++++++- packages/runtime/src/scr_alloc.test.c | 37 +++++++++ 2 files changed, 140 insertions(+), 2 deletions(-) diff --git a/packages/runtime/src/scr_alloc.c b/packages/runtime/src/scr_alloc.c index 32352d9dd..f8888e086 100644 --- a/packages/runtime/src/scr_alloc.c +++ b/packages/runtime/src/scr_alloc.c @@ -82,6 +82,101 @@ static char *scr_sa_extend(char *start, char *lim, char *end) { return end; } +/* Blocks above SCR_SA_MAX (array storage, hash tables, link pages, large + * strings) come from glibc, whose heap and per-block mappings use small + * pages where THP is in madvise mode (the common distribution default); + * in large compiler-like programs that is most of the page faults and a + * share of the TLB misses. glibc only advises huge pages for its own + * memory when the glibc.malloc.hugetlb tunable is set in the environment, + * which a program cannot do for itself. So once the brk heap has grown + * past SCR_SA_HEAP_HUGE_AFTER (small programs keep small pages and their + * RSS), every large allocation advises the heap grown since the previous + * one, and the aligned interior of a block mapped outside the heap. + * glibc grows the heap by its top pad beyond each request; the default + * (128 KiB) is smaller than a huge page, so every 2 MiB range would be + * first touched while it still straddles the heap end, where it can only + * get small pages. The policy therefore raises the top pad. Setting it + * fixes glibc's otherwise adaptive mmap and trim thresholds, so they are + * set to the adaptive maxima the heap of such a program reaches anyway. */ +#if defined(SCR_SA_THP) && defined(__GLIBC__) +#include +#include +#include +#include +#include +#define SCR_SA_HEAP_HUGE_AFTER ((uintptr_t)32 << 20) +#define SCR_SA_HEAP_TOP_PAD (32 << 20) +#define SCR_SA_HEAP_MMAP_THRESHOLD (32 << 20) /* glibc's adaptive maximum */ +#define SCR_SA_HEAP_TRIM_THRESHOLD (64 << 20) /* twice that, as glibc keeps it */ +/* 0 = undecided, 1 = following, 2 = off (THP not in madvise mode). */ +static _Atomic(int) scr_sa_heap_state; +static _Atomic(uintptr_t) scr_sa_heap_lo; /* heap start seen at the first large block */ +static _Atomic(uintptr_t) scr_sa_heap_hi; /* end of the advised heap prefix */ +static _Atomic(uintptr_t) scr_sa_heap_page; /* the page size, read with the mode */ + +static bool scr_sa_thp_madvise_mode(void) { + FILE *f = fopen("/sys/kernel/mm/transparent_hugepage/enabled", "r"); + if (!f) return false; + char buf[96] = {0}; + size_t n = fread(buf, 1, sizeof buf - 1, f); + fclose(f); + buf[n] = 0; + return strstr(buf, "[madvise]") != NULL; +} + +static void scr_sa_large_note(void *p, size_t n) { + int state = atomic_load_explicit(&scr_sa_heap_state, memory_order_relaxed); + if (state == 2 || !p) return; + uintptr_t top = (uintptr_t)sbrk(0); + if (state == 0) { + uintptr_t lo = atomic_load_explicit(&scr_sa_heap_lo, memory_order_relaxed); + if (!lo) { + long page = sysconf(_SC_PAGESIZE); + if (page <= 0 || !scr_sa_thp_madvise_mode()) { + atomic_store_explicit(&scr_sa_heap_state, 2, memory_order_relaxed); + return; + } + atomic_store_explicit(&scr_sa_heap_page, (uintptr_t)page, memory_order_relaxed); + lo = (top + (uintptr_t)page - 1) & ~((uintptr_t)page - 1); + uintptr_t none = 0; + if (!atomic_compare_exchange_strong(&scr_sa_heap_lo, &none, lo)) lo = none; + } + if (top < lo + SCR_SA_HEAP_HUGE_AFTER) return; + uintptr_t unset = 0; /* the whole heap seen so far gets the advice */ + (void)atomic_compare_exchange_strong(&scr_sa_heap_hi, &unset, lo); + int undecided = 0; + if (atomic_compare_exchange_strong(&scr_sa_heap_state, &undecided, 1)) { + (void)mallopt(M_MMAP_THRESHOLD, SCR_SA_HEAP_MMAP_THRESHOLD); + (void)mallopt(M_TRIM_THRESHOLD, SCR_SA_HEAP_TRIM_THRESHOLD); + (void)mallopt(M_TOP_PAD, SCR_SA_HEAP_TOP_PAD); + } + } + /* The heap end moved since the last look: advise what it gained (pages + * already touched keep their small pages), or follow a trim down. */ + uintptr_t hi = atomic_load_explicit(&scr_sa_heap_hi, memory_order_relaxed); + if (!hi) return; /* another thread is switching the policy on */ + if (top > hi) { + if (atomic_compare_exchange_strong(&scr_sa_heap_hi, &hi, top)) { + /* madvise wants a page-aligned start */ + uintptr_t from = hi & ~(atomic_load_explicit(&scr_sa_heap_page, memory_order_relaxed) - 1); + (void)madvise((void *)from, top - from, MADV_HUGEPAGE); + } + } else if (top < hi) { + (void)atomic_compare_exchange_strong(&scr_sa_heap_hi, &hi, top); + } + /* A block glibc mapped by itself (or carved from a thread's heap). */ + uintptr_t a = (uintptr_t)p, lo = atomic_load_explicit(&scr_sa_heap_lo, memory_order_relaxed); + if ((a < lo || a >= top) && n >= 2 * SCR_SA_HUGE_PAGE) { + uintptr_t s = (a + SCR_SA_HUGE_PAGE - 1) & ~(uintptr_t)(SCR_SA_HUGE_PAGE - 1); + uintptr_t e = (a + n) & ~(uintptr_t)(SCR_SA_HUGE_PAGE - 1); + if (e > s) (void)madvise((void *)s, e - s, MADV_HUGEPAGE); + } +} +#define SCR_SA_LARGE_NOTE(p, n) scr_sa_large_note((p), (n)) +#else +#define SCR_SA_LARGE_NOTE(p, n) ((void)0) +#endif + #ifdef SCR_WORKERS #include #include @@ -547,7 +642,9 @@ __attribute__((cold, noinline)) void *scr_sa_slow(size_t n, bool zero) { scr_sa.bump[c] = p; } /* Large or zero-sized, an exhausted slice, or no reservation. */ - return zero ? calloc(1, n) : malloc(n); + void *q = zero ? calloc(1, n) : malloc(n); + if (n > SCR_SA_MAX) SCR_SA_LARGE_NOTE(q, n); + return q; } void *scr_mem_realloc(void *p, size_t n) { @@ -560,7 +657,11 @@ void *scr_mem_realloc(void *p, size_t n) { /* Another arena's block: move it into this thread's allocator. */ } #endif - else return realloc(p, n); + else { + void *q = realloc(p, n); + if (n > SCR_SA_MAX) SCR_SA_LARGE_NOTE(q, n); + return q; + } if (n && n <= have) return p; /* still fits its block */ void *q = scr_mem_alloc(n ? n : 1); if (!q) return NULL; diff --git a/packages/runtime/src/scr_alloc.test.c b/packages/runtime/src/scr_alloc.test.c index 9978c819e..ec4f38277 100644 --- a/packages/runtime/src/scr_alloc.test.c +++ b/packages/runtime/src/scr_alloc.test.c @@ -154,6 +154,40 @@ static void check_slice_growth(void) { assert(scr_mem_alloc(SZ) == first); scr_mem_free(first); } + +#if defined(__linux__) && defined(__GLIBC__) +#include +/* Blocks above SCR_SA_MAX come from glibc; once its brk heap has grown past + * 32 MiB, the heap is advised huge pages where THP is in madvise mode. */ +static void check_heap_huge_pages(void) { + enum { N = 1024, SZ = 64 << 10 }; + static unsigned char *block[N]; + uintptr_t start = (uintptr_t)sbrk(0); + for (size_t i = 0; i < N; i++) { + block[i] = scr_mem_alloc(SZ); + assert(block[i] && !owned(block[i])); + block[i][0] = (unsigned char)i; + } + uintptr_t top = (uintptr_t)sbrk(0); + char mode[96] = {0}; + FILE *thp = fopen("/sys/kernel/mm/transparent_hugepage/enabled", "r"); + if (thp) { + size_t n = fread(mode, 1, sizeof mode - 1, thp); + mode[n] = '\0'; + fclose(thp); + } + /* Only where glibc's heap served them (a sanitizer may replace malloc). */ + if (top - start >= ((size_t)48 << 20) && strstr(mode, "[madvise]")) { + char flags[256]; + vm_flags(block[N - 1], flags, sizeof flags); + assert(strstr(flags, " hg")); + } + for (size_t i = 0; i < N; i++) { + assert(block[i][0] == (unsigned char)i); + scr_mem_free(block[i]); + } +} +#endif #endif #if defined(SCR_WORKERS) && SCR_SMALL_ALLOC @@ -310,6 +344,9 @@ int main(void) { check_realloc(); check_system_pointers(); check_churn(); +#if SCR_SMALL_ALLOC && defined(__linux__) && defined(__GLIBC__) + check_heap_huge_pages(); +#endif #if defined(SCR_WORKERS) && SCR_SMALL_ALLOC check_threads(); #ifdef __linux__ From 4184028663d5842583c0f6ad774972c65059c1c8 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Sun, 11 Oct 2026 23:39:43 -0500 Subject: [PATCH 5/8] Keep self-hosting emission tests from blocking the test worker --- tests/harness/self-hosting-emission.test.ts | 33 +++++++++----- .../self-hosting-native-toolchain.test.ts | 22 +++++----- tests/harness/spawn-result.ts | 44 +++++++++++++++++++ 3 files changed, 76 insertions(+), 23 deletions(-) create mode 100644 tests/harness/spawn-result.ts diff --git a/tests/harness/self-hosting-emission.test.ts b/tests/harness/self-hosting-emission.test.ts index 2105d5b4e..79985e6ac 100644 --- a/tests/harness/self-hosting-emission.test.ts +++ b/tests/harness/self-hosting-emission.test.ts @@ -1,4 +1,3 @@ -import { spawnSync } from "node:child_process"; import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; @@ -9,6 +8,7 @@ import { emitLlvmModule } from "../../packages/compiler/src/backend/llvm/emitter import { scalarizeNumericRecords } from "../../packages/compiler/src/ir/scalar-records.js"; import { everyStmtList } from "../../packages/compiler/src/ir/traverse.js"; import { type IrModule } from "../../packages/compiler/src/ir/ir.js"; +import { spawnResult } from "./spawn-result.js"; import { moduleUsesCopying, moduleUsesDynInvoke, @@ -83,14 +83,23 @@ for (const backend of ["llvm"] as const) { if (!built.ok) throw new Error(built.diagnostics.map((d) => `${d.code}: ${d.message}`).join("\n")); expect(built.backend).toBe(backend); - const run = (mod: IrModule, request: EmissionRequest, name: string, status = 0): string => { + const run = async ( + mod: IrModule, + request: EmissionRequest, + name: string, + status = 0, + ): Promise => { const input = join(dir, "input.json"); const config = join(dir, "config.json"); writeFileSync(input, serializeModule(mod)); writeFileSync(config, JSON.stringify(request)); const args = [input, config]; - const oracle = spawnSync(process.execPath, ["--import", "tsx", entry, ...args], options); - const native = spawnSync(built.binaryPath, args, options); + const oracle = await spawnResult( + process.execPath, + ["--import", "tsx", entry, ...args], + options, + ); + const native = await spawnResult(built.binaryPath, args, options); for (const result of [oracle, native]) { expect(result.error, name).toBeUndefined(); expect(result.signal, `${name}: ${result.stderr}`).toBeNull(); @@ -106,7 +115,7 @@ for (const backend of ["llvm"] as const) { }; for (const item of emissionCases()) { - const text = run(item.module, item.request, item.name); + const text = await run(item.module, item.request, item.name); const emitted = JSON.parse(text) as Emission; const definitions = [ ...emitted.declarations, @@ -143,12 +152,12 @@ for (const backend of ["llvm"] as const) { loc: { file: invalid.sourceFile, start: 0, end: 0 }, }, ]; - expect(run(invalid, emissionRequest(), "missing base", 1)).toContain( + expect(await run(invalid, emissionRequest(), "missing base", 1)).toContain( "undeclared base class Missing", ); const absent = emissionRequest(); absent.classObjects = ["Missing"]; - expect(run(emissionModule(), absent, "missing class object", 1)).toContain( + expect(await run(emissionModule(), absent, "missing class object", 1)).toContain( "class object for unknown class Missing", ); @@ -176,7 +185,7 @@ for (const backend of ["llvm"] as const) { }, ]; for (const { request, message } of invalidRequests) { - expect(run(emissionModule(), request, message, 1)).toContain(message); + expect(await run(emissionModule(), request, message, 1)).toContain(message); } const unsupported = emissionModule(); unsupported.unions = [ @@ -186,7 +195,7 @@ for (const backend of ["llvm"] as const) { }, ]; expect( - run( + await run( unsupported, { ...emissionRequest(), joinUnions: ["containers"] }, "unsupported union join", @@ -225,7 +234,7 @@ for (const backend of ["llvm"] as const) { return true; }, }); - const native = JSON.parse(run(mod, request, source)) as Emission; + const native = JSON.parse(await run(mod, request, source)) as Emission; // Splice the native-generated sections into the real program. The // full emitter still runs on Node; these type and helper definitions // are supplied by the compiled production stage under test. @@ -256,8 +265,8 @@ for (const backend of ["llvm"] as const) { regex: moduleUsesRegex(mod), copying: moduleUsesCopying(mod), }); - const oracle = spawnSync(process.execPath, [sourcePath], options); - const program = spawnSync(outPath, [], options); + const oracle = await spawnResult(process.execPath, [sourcePath], options); + const program = await spawnResult(outPath, [], options); for (const result of [oracle, program]) { expect(result.error, source).toBeUndefined(); expect(result.signal, `${source}: ${result.stderr}`).toBeNull(); diff --git a/tests/harness/self-hosting-native-toolchain.test.ts b/tests/harness/self-hosting-native-toolchain.test.ts index 43a230682..b00a46da7 100644 --- a/tests/harness/self-hosting-native-toolchain.test.ts +++ b/tests/harness/self-hosting-native-toolchain.test.ts @@ -1,10 +1,10 @@ -import { spawnSync } from "node:child_process"; import { createHash } from "node:crypto"; import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { expect, test } from "vitest"; import { analyzeInChild, compileInChild } from "./self-hosting-compiler-process.js"; +import { spawnResult } from "./spawn-result.js"; import { nativeCodegenTarget } from "../../packages/compiler/src/backend/targets.js"; import type { NativeLinkFeatures } from "../../packages/compiler/src/backend/native-link-info.js"; import type { RuntimePackManifest } from "../../packages/compiler/src/backend/runtime-pack-core.js"; @@ -143,7 +143,7 @@ for (const backend of ["llvm"] as const) { default_target: target.helper.defaultTarget, data_layout: target.helper.defaultDataLayout, }; - const check = ( + const check = async ( status: number, message: string, action = "stage", @@ -153,11 +153,11 @@ for (const backend of ["llvm"] as const) { input, JSON.stringify({ toolchain, stage, features, action, version: helperVersion }), ); - const options = { cwd: root, timeout: 30_000, maxBuffer: 1024 * 1024 }; + const options = { cwd: root, timeout: 30_000 }; const results = []; for (const native of [false, true]) { rmSync(stage, { recursive: true, force: true }); - const result = spawnSync( + const result = await spawnResult( native ? built.binaryPath : process.execPath, native ? [input] : ["--import", "tsx", entry, input], native ? { ...options, env: { ...process.env, PATH: "" } } : options, @@ -171,24 +171,24 @@ for (const backend of ["llvm"] as const) { expect(results[1]!.stdout).toEqual(results[0]!.stdout); expect(results[1]!.stderr).toEqual(results[0]!.stderr); }; - check(0, "base.o"); + await check(0, "base.o"); expect(readFileSync(join(stage, artifact.path))).toEqual(bytes); // A later replacement of the installed input cannot change staged bytes. writeFileSync(join(pack, artifact.path), Buffer.from("changed")); expect(readFileSync(join(stage, artifact.path))).toEqual(bytes); - check(1, "hash mismatch"); + await check(1, "hash mismatch"); expect(existsSync(join(stage, artifact.path))).toBe(false); writeFileSync(join(pack, artifact.path), bytes); rmSync(join(pack, "license.txt")); - check(1, "license payload is incomplete"); + await check(1, "license payload is incomplete"); writeFileSync(join(pack, "license.txt"), "license"); rmSync(join(pack, artifact.path)); - check(1, "artifact is missing"); + await check(1, "artifact is missing"); writeFileSync(join(pack, artifact.path), bytes); writeFileSync(toolchain, JSON.stringify({ ...config, compiler_version: "other" })); - check(1, "version mismatch"); + await check(1, "version mismatch"); writeFileSync(toolchain, JSON.stringify(config)); - check(0, "1 1.2.3 22.1.8", "helper"); + await check(0, "1 1.2.3 22.1.8", "helper"); for (const [field, value] of Object.entries({ protocol_version: "2", llvm_version: "0", @@ -199,7 +199,7 @@ for (const backend of ["llvm"] as const) { data_layout: "other", host_triple: null, })) { - check(1, field, "helper", { ...version, [field]: value }); + await check(1, field, "helper", { ...version, [field]: value }); } } finally { rmSync(directory, { recursive: true, force: true }); diff --git a/tests/harness/spawn-result.ts b/tests/harness/spawn-result.ts new file mode 100644 index 000000000..3de656fe6 --- /dev/null +++ b/tests/harness/spawn-result.ts @@ -0,0 +1,44 @@ +import { spawn } from "node:child_process"; + +export interface SpawnResult { + error: Error | undefined; + signal: NodeJS.Signals | null; + status: number | null; + stdout: Buffer; + stderr: Buffer; +} + +/** spawnSync's result without blocking the worker: a test that runs child + * processes back to back with spawnSync starves Vitest's worker RPC, which + * fails the run with an unhandled timeout even when every test passes. */ +export function spawnResult( + file: string, + args: readonly string[], + options: { cwd: string; timeout: number; env?: NodeJS.ProcessEnv }, +): Promise { + return new Promise((resolve) => { + const stdout: Buffer[] = []; + const stderr: Buffer[] = []; + let error: Error | undefined; + const child = spawn(file, args, { + cwd: options.cwd, + env: options.env, + timeout: options.timeout, + stdio: ["ignore", "pipe", "pipe"], + }); + child.stdout.on("data", (chunk: Buffer) => stdout.push(chunk)); + child.stderr.on("data", (chunk: Buffer) => stderr.push(chunk)); + child.on("error", (cause) => { + error = cause; + }); + child.on("close", (status, signal) => + resolve({ + error, + signal, + status, + stdout: Buffer.concat(stdout), + stderr: Buffer.concat(stderr), + }), + ); + }); +} From 0874739c028b9969172d83473f32514e06f3669e Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Mon, 12 Oct 2026 00:07:55 -0500 Subject: [PATCH 6/8] Run the frontend services test's compiler and processes off the test worker --- .../self-hosting-frontend-services.test.ts | 62 ++++++++++--------- 1 file changed, 34 insertions(+), 28 deletions(-) diff --git a/tests/harness/self-hosting-frontend-services.test.ts b/tests/harness/self-hosting-frontend-services.test.ts index 8216c3aa0..d294f5cdd 100644 --- a/tests/harness/self-hosting-frontend-services.test.ts +++ b/tests/harness/self-hosting-frontend-services.test.ts @@ -1,12 +1,12 @@ -import { execFileSync, spawnSync } from "node:child_process"; import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs"; import { tmpdir } from "node:os"; import { join } from "node:path"; -import { analyze, compile } from "@scriptc/compiler"; import { expect, test } from "vitest"; import { ts7Executable } from "../../packages/compiler/src/frontend/ts7/rpc-api.js"; import { npmFetchCases } from "../../packages/compiler/test/npm-fetch-cases.js"; +import { analyzeInChild, compileInChild } from "./self-hosting-compiler-process.js"; +import { spawnResult } from "./spawn-result.js"; const root = join(import.meta.dirname, "../.."); const entry = join(root, "tests/fixtures/self-hosting/frontend-services.ts"); @@ -69,17 +69,23 @@ for (const backend of ["llvm"] as const) { ); try { const object = join(directory, "process.o"); - execFileSync("clang", [ - "-std=c11", - "-Wall", - "-Wextra", - "-Werror", - ...(sanitize ? ["-fsanitize=address"] : []), - "-c", - join(nativeSources, "ts7-process.c"), - "-o", - object, - ]); + const clang = await spawnResult( + "clang", + [ + "-std=c11", + "-Wall", + "-Wextra", + "-Werror", + ...(sanitize ? ["-fsanitize=address"] : []), + "-c", + join(nativeSources, "ts7-process.c"), + "-o", + object, + ], + { cwd: root, timeout: 120_000 }, + ); + expect(clang.error).toBeUndefined(); + expect(clang.status, clang.stderr.toString()).toBe(0); const profile = join(directory, "ffi.json"); writeFileSync( profile, @@ -88,13 +94,13 @@ for (const backend of ["llvm"] as const) { libraries: [object], }), ); - const { coverage } = analyze(entry, { dynamic: false, ffiProfilePath: profile }); + const coverage = await analyzeInChild(entry, { dynamic: false, ffiProfilePath: profile }); expect(coverage.preflightFailed, JSON.stringify(coverage.diagnostics)).toBe(false); expect(coverage.diagnostics).toEqual([]); expect(coverage.stats.statementsFailed).toBe(0); expect(coverage.stats.statementsIsland).toBe(0); expect(coverage.stats.functionsSkipped).toBe(0); - const built = await compile(entry, { + const built = await compileInChild(entry, { backend, dynamic: false, optimization: "dev", @@ -108,25 +114,25 @@ for (const backend of ["llvm"] as const) { const request = join(directory, "request.json"); writeFileSync(request, JSON.stringify(input(directory))); const expected = join(directory, "node.json"); - const node = spawnSync( + const node = await spawnResult( process.execPath, ["--import", "tsx", oracle, ts7Executable(), request, expected], - { encoding: "utf8", timeout: 45_000 }, + { cwd: root, timeout: 45_000 }, ); - expect(node.error, node.stderr).toBeUndefined(); - expect(node.status, node.stderr).toBe(0); - expect(node.stdout).toBe(""); - expect(node.stderr).toBe(""); + expect(node.error, node.stderr.toString()).toBeUndefined(); + expect(node.status, node.stderr.toString()).toBe(0); + expect(node.stdout.toString()).toBe(""); + expect(node.stderr.toString()).toBe(""); const report = join(directory, "native.json"); - const run = spawnSync(built.binaryPath, [ts7Executable(), request, report], { - encoding: "utf8", + const run = await spawnResult(built.binaryPath, [ts7Executable(), request, report], { + cwd: root, timeout: 45_000, }); - expect(run.error, run.stderr).toBeUndefined(); - expect(run.signal, run.stderr).toBeNull(); - expect(run.status, run.stderr).toBe(0); - expect(run.stdout).toBe(node.stdout); - expect(run.stderr).toBe(node.stderr); + expect(run.error, run.stderr.toString()).toBeUndefined(); + expect(run.signal, run.stderr.toString()).toBeNull(); + expect(run.status, run.stderr.toString()).toBe(0); + expect(run.stdout.toString()).toBe(node.stdout.toString()); + expect(run.stderr.toString()).toBe(node.stderr.toString()); const result = JSON.parse(readFileSync(report, "utf8")); expect(result).toEqual(JSON.parse(readFileSync(expected, "utf8"))); expect(result.fetch).toEqual( From 2933ebc985c8ac0305ec4bedd21f9b73d3bd6fae Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Mon, 12 Oct 2026 00:08:53 -0500 Subject: [PATCH 7/8] Store order-parity baselines one file per fixture --- packages/compiler/src/frontend/program.ts | 2 +- .../test/ts7/baselines/order-parity.json | 15912 ---------------- .../tests/corpus/001-hello.ts.json | 6 + .../tests/corpus/002-log-args.ts.json | 6 + .../tests/corpus/100-number-format.ts.json | 6 + .../corpus/1000-json-stringify-basics.ts.json | 6 + .../corpus/1001-json-escapes-unicode.ts.json | 6 + .../tests/corpus/1002-json-parse-cast.ts.json | 6 + .../corpus/1003-json-parse-unions.ts.json | 6 + .../corpus/1004-json-parse-errors.ts.json | 6 + .../tests/corpus/1005-json-nested.ts.json | 6 + .../tests/corpus/1006-json-fs-config.ts.json | 6 + .../tests/corpus/1007-json-rc-stress.ts.json | 6 + .../tests/corpus/1008-json-null-arms.ts.json | 6 + .../corpus/1009-json-optional-fields.ts.json | 6 + .../tests/corpus/101-arithmetic.ts.json | 6 + .../corpus/1010-json-stringify-space.ts.json | 6 + .../corpus/1011-json-unknown-typeof.ts.json | 6 + .../tests/corpus/102-comparisons.ts.json | 6 + .../tests/corpus/1020-async-basics.ts.json | 6 + .../tests/corpus/1021-async-ordering.ts.json | 6 + .../corpus/1022-async-exceptions.ts.json | 6 + .../tests/corpus/1023-async-rc-stress.ts.json | 6 + .../corpus/1024-async-pending-exit.ts.json | 6 + .../corpus/1025-async-promise-capture.ts.json | 6 + .../tests/corpus/1026-throw-promise.ts.json | 6 + .../corpus/1027-async-return-promise.ts.json | 6 + .../1028-async-return-record-literals.ts.json | 6 + .../corpus/1029-async-eager-chains.ts.json | 6 + .../tests/corpus/103-ternary.ts.json | 6 + .../corpus/104-ternary-empty-arrays.ts.json | 6 + .../tests/corpus/1050-comptime-tables.ts.json | 6 + .../corpus/1051-comptime-strings.ts.json | 6 + .../corpus/1052-comptime-records.ts.json | 6 + .../tests/corpus/1053-comptime-json.ts.json | 6 + .../corpus/1054-comptime-modules/main.ts.json | 7 + .../tests/corpus/110-number-radix.ts.json | 6 + .../corpus/1100-island-eval-basics.ts.json | 6 + .../1101-island-marshal-unicode.ts.json | 6 + .../corpus/1102-island-rc-stress.ts.json | 6 + .../tests/corpus/111-record-entries.ts.json | 6 + .../tests/corpus/1110-math-members.ts.json | 6 + .../tests/corpus/1111-math-random.ts.json | 6 + .../tests/corpus/1112-number-methods.ts.json | 6 + .../tests/corpus/1113-string-methods.ts.json | 6 + .../corpus/1114-string-unicode-island.ts.json | 6 + .../tests/corpus/1115-parse-globals.ts.json | 6 + .../corpus/1116-island-static-mix.ts.json | 6 + .../corpus/1117-typeof-static-union.ts.json | 6 + .../1118-object-spread-conditional.ts.json | 6 + .../tests/corpus/1119-switch-union.ts.json | 6 + .../corpus/112-class-descriptor-key.js.json | 6 + .../corpus/1120-web-globals-encoders.ts.json | 6 + .../1121-infinity-number-tostring.ts.json | 6 + .../tests/corpus/1122-any-captures.ts.json | 6 + .../1123-any-conditional-spread.ts.json | 6 + .../corpus/1124-union-narrowed-retag.ts.json | 6 + .../corpus/113-promise-checked-exits.ts.json | 6 + .../corpus/114-live-record-delete.ts.json | 6 + .../tests/corpus/115-array-compound.js.json | 6 + .../corpus/116-text-decoder-runtime.js.json | 6 + .../tests/corpus/117-weak-cache-cycle.js.json | 6 + .../corpus/118-fs-stored-callbacks.cjs.json | 6 + .../tests/corpus/119-native-patterns.js.json | 6 + .../corpus/1200-regex-test-basics.ts.json | 6 + .../tests/corpus/1201-regex-replace.ts.json | 6 + .../corpus/1202-regex-substitutions.ts.json | 6 + .../tests/corpus/1203-regex-split.ts.json | 6 + .../corpus/1204-regex-empty-unicode.ts.json | 6 + .../tests/corpus/1205-regex-rc-stress.ts.json | 6 + .../corpus/1206-regex-dynamic-mix.ts.json | 6 + .../tests/corpus/1300-errors-basics.ts.json | 6 + .../tests/corpus/1301-errors-subclass.ts.json | 6 + .../corpus/1302-errors-typed-catch.ts.json | 6 + .../corpus/1303-errors-rc-stress.ts.json | 6 + .../tests/corpus/1304-errors-uncaught.ts.json | 6 + .../1305-errors-async-rejections.ts.json | 6 + .../1306-errors-runtime-instances.ts.json | 6 + .../corpus/1350-path-normalize-join.ts.json | 6 + .../tests/corpus/1351-path-parts.ts.json | 6 + .../corpus/1352-path-resolve-relative.ts.json | 6 + .../tests/corpus/1353-os-basics.ts.json | 6 + .../1354-builtin-bare-specifiers.ts.json | 6 + .../tests/corpus/1355-url-parse.ts.json | 6 + .../tests/corpus/1356-url-file-bridge.ts.json | 6 + .../tests/corpus/1357-fsp-roundtrip.ts.json | 6 + .../tests/corpus/1358-crypto-random.ts.json | 6 + .../corpus/1359-json-module/main.ts.json | 6 + .../tests/corpus/1360-spawn-sync.ts.json | 6 + .../tests/corpus/1361-spawn-events.ts.json | 6 + .../tests/corpus/1362-spawn-timers.ts.json | 6 + .../corpus/1363-spawn-unhandled-error.ts.json | 6 + .../corpus/1364-union-truthiness.ts.json | 6 + .../tests/corpus/1365-union-logical.ts.json | 6 + .../tests/corpus/1366-union-equality.ts.json | 6 + .../tests/corpus/1367-destructuring.ts.json | 6 + .../corpus/1368-constructor-functions.ts.json | 6 + .../tests/corpus/1369-promise-union.ts.json | 6 + .../tests/corpus/1370-spread.ts.json | 6 + .../1371-union-template-tostring.ts.json | 6 + .../corpus/1372-loose-null-tests.ts.json | 6 + .../corpus/1373-union-array-arms.ts.json | 6 + .../corpus/140-bitwise-operators.ts.json | 6 + .../corpus/1400-typedarray-basics.ts.json | 6 + .../corpus/1401-typedarray-slice-set.ts.json | 6 + .../corpus/1402-buffer-encodings.ts.json | 6 + .../tests/corpus/1403-buffer-fs.ts.json | 6 + .../corpus/1404-zlib-crypto-bytes.ts.json | 6 + .../corpus/1405-bytes-unions-arrays.ts.json | 6 + .../tests/corpus/1406-dataview-mp4.ts.json | 6 + .../tests/corpus/1407-dataview-bounds.ts.json | 6 + .../tests/corpus/1408-string-indexing.ts.json | 6 + .../1409-typedarray-integer-loops.ts.json | 6 + .../tests/corpus/1420-number-statics.ts.json | 6 + .../corpus/1421-number-parse-dynamic.ts.json | 6 + .../tests/corpus/1422-date-iso.ts.json | 6 + .../tests/corpus/1423-text-codec.ts.json | 6 + .../tests/corpus/1424-fs-options.ts.json | 6 + .../tests/corpus/1425-stdin-tty.ts.json | 6 + .../tests/corpus/1426-stdin-read.ts.json | 6 + .../1427-fromcharcode-lastindexof.ts.json | 6 + .../corpus/1428-settled-await-order.ts.json | 6 + .../corpus/1429-promise-catch-finally.ts.json | 6 + .../tests/corpus/1430-promise-race.ts.json | 6 + .../tests/corpus/1431-caught-tostring.ts.json | 6 + .../corpus/1432-destructured-params.ts.json | 6 + .../tests/corpus/1433-filter-narrow.ts.json | 6 + .../tests/corpus/1434-async-never.ts.json | 6 + .../tests/corpus/1435-math-spread.ts.json | 6 + .../corpus/1436-default-undef-param.ts.json | 6 + .../tests/corpus/1437-pad-default.ts.json | 6 + .../tests/corpus/1438-promise-all.ts.json | 6 + .../tests/corpus/1440-interval-basics.ts.json | 6 + .../corpus/1441-interval-clear-cross.ts.json | 6 + .../tests/corpus/1442-interval-throw.ts.json | 6 + .../tests/corpus/1443-signal-handlers.ts.json | 6 + .../tests/corpus/1444-exit-listeners.ts.json | 6 + .../corpus/1445-exit-process-exit.ts.json | 6 + .../tests/corpus/1446-exit-uncaught.ts.json | 6 + .../corpus/1447-stdin-closed-events.ts.json | 6 + .../tests/corpus/1448-stream-columns.ts.json | 6 + .../corpus/1450-incdec-expression.ts.json | 6 + ...1451-instanceof-uint8array-unknown.ts.json | 6 + .../1452-return-through-finally.ts.json | 6 + .../tests/corpus/1453-pmap-settled.ts.json | 6 + .../1454-nonnull-narrow-and-fcc-bytes.ts.json | 6 + .../1455-lambda-union-return-adoption.ts.json | 6 + .../corpus/1460-console-error-warn.ts.json | 6 + .../1461-process-pid-getuid-kill.ts.json | 6 + .../tests/corpus/1462-exec-sync.ts.json | 6 + .../tests/corpus/1463-timeout-unref.ts.json | 6 + .../tests/corpus/1464-env-writes.ts.json | 6 + .../tests/corpus/1465-env-value.ts.json | 6 + .../corpus/1466-child-containers.ts.json | 6 + .../tests/corpus/1467-string-match.ts.json | 6 + .../tests/corpus/1468-exec-path.ts.json | 6 + .../tests/corpus/1469-remove-listener.ts.json | 6 + .../tests/corpus/1470-child-lifecycle.ts.json | 6 + .../tests/corpus/1471-child-unref.ts.json | 6 + .../tests/corpus/1472-errno-code.ts.json | 6 + .../corpus/1473-promisify-execfile.ts.json | 6 + .../tests/corpus/1474-string-decoder.ts.json | 6 + .../corpus/1475-readline-closed-stdin.ts.json | 6 + .../corpus/1476-assign-expression.ts.json | 6 + .../tests/corpus/1477-in-expressions.ts.json | 6 + .../tests/corpus/1478-promise-reject.ts.json | 6 + .../corpus/1479-destructuring-assign.ts.json | 6 + .../corpus/1480-os-network-interfaces.ts.json | 6 + .../corpus/1481-string-case-static.ts.json | 6 + .../tests/corpus/1482-spawnsync-error.ts.json | 6 + .../tests/corpus/1483-array-slice.ts.json | 6 + .../corpus/1520-fs-wider-surface.ts.json | 6 + .../corpus/1520-string-split-static.ts.json | 6 + .../tests/corpus/1521-fs-lstat-lock.ts.json | 6 + .../1521-string-trim-pad-static.ts.json | 6 + .../tests/corpus/1522-parseint-static.ts.json | 6 + .../corpus/1522-spawnsync-options.ts.json | 6 + .../corpus/1523-isnan-floor-static.ts.json | 6 + .../tests/corpus/1523-spawn-options.ts.json | 6 + .../corpus/1524-atomics-sleep-static.ts.json | 6 + .../tests/corpus/1524-catch-narrowing.ts.json | 6 + .../corpus/1525-child-exit-signal.ts.json | 6 + .../1525-unknown-typeof-validation.ts.json | 6 + .../tests/corpus/1526-set-spread.ts.json | 6 + .../1527-logical-mixed-operands.ts.json | 6 + .../corpus/1528-delete-records-env.ts.json | 6 + .../corpus/1529-class-with-statics.ts.json | 6 + .../corpus/1530-array-push-variadic.ts.json | 6 + .../1530-spread-override-completion.ts.json | 6 + .../1531-delete-optional-fields.ts.json | 6 + .../corpus/1531-process-arch-versions.ts.json | 6 + .../corpus/1532-array-splice-shift.ts.json | 6 + .../1532-union-shared-field-read.ts.json | 6 + .../tests/corpus/1533-bool-equality.ts.json | 6 + .../1533-path-platform-namespaces.ts.json | 6 + .../corpus/1534-crypto-hash-chain.ts.json | 6 + .../corpus/1534-union-as-arm-cast.ts.json | 6 + .../tests/corpus/1535-spawn-fd-stdio.ts.json | 6 + .../corpus/1535-union-param-defaults.ts.json | 6 + .../1536-destructuring-defaults.ts.json | 6 + .../corpus/1536-string-array-sweep.ts.json | 6 + .../corpus/1537-chalk-hybrid/main.ts.json | 7 + .../1537-os-release-spawnsync-stdio.ts.json | 6 + .../1538-await-promiselike-return.ts.json | 6 + .../corpus/1538-math-static-scalar.ts.json | 6 + .../corpus/1539-readonly-set-map.ts.json | 6 + .../corpus/1539-unknown-truthiness.ts.json | 6 + .../tests/corpus/1540-os-userinfo.ts.json | 6 + .../tests/corpus/1540-void-statement.ts.json | 6 + .../corpus/1541-fs-readdir-dirent.ts.json | 6 + .../corpus/1541-union-keyed-reads.ts.json | 6 + .../corpus/1542-map-promise-values.ts.json | 6 + .../1542-record-literal-into-union.ts.json | 6 + .../corpus/1543-rest-destructuring.ts.json | 6 + .../corpus/1543-set-server-handles.ts.json | 6 + .../tests/corpus/1544-dyn-json-reads.ts.json | 6 + .../tests/corpus/1544-string-matchall.ts.json | 6 + .../1545-spread-order-and-optional.ts.json | 6 + .../corpus/1546-union-element-reads.ts.json | 6 + .../corpus/1547-computed-key-fold.ts.json | 6 + .../1548-boolean-condition-forms.ts.json | 6 + .../corpus/1549-array-isarray-unions.ts.json | 6 + .../1550-param-defaults-func-set.ts.json | 6 + .../corpus/1551-dyn-receiver-methods.ts.json | 6 + .../corpus/1552-exec-options-record.ts.json | 6 + .../corpus/1553-truthy-hof-predicates.ts.json | 6 + .../corpus/1554-caught-into-unknown.ts.json | 6 + .../1555-index-spread-into-declared.ts.json | 6 + .../1556-union-retag-width-arms.ts.json | 6 + .../tests/corpus/1557-url-host.ts.json | 6 + .../1558-any-joins-and-dyn-validation.ts.json | 6 + ...559-conditional-spread-index-merge.ts.json | 6 + .../1560-forof-homogeneous-tuples.ts.json | 6 + .../tests/corpus/1561-forof-strings.ts.json | 6 + .../tests/corpus/1561-promise-then.ts.json | 6 + .../corpus/1562-optional-chain-tails.ts.json | 6 + .../1562-spawn-conditional-spread.ts.json | 6 + .../1563-forof-iterator-projections.ts.json | 6 + .../tests/corpus/1563-string-raw-fold.ts.json | 6 + .../tests/corpus/1564-fs-watch.ts.json | 6 + .../tests/corpus/1564-string-raw.ts.json | 6 + .../corpus/1565-spawn-pipe-streams.ts.json | 6 + .../corpus/1565-union-element-join.ts.json | 6 + .../corpus/1566-child-duck-interface.ts.json | 6 + .../corpus/1567-server-close-override.ts.json | 6 + .../corpus/1568-x509-fingerprint.ts.json | 6 + .../1569-fsp-mkdir-unlink-chmod.ts.json | 6 + .../1570-child-unref-kill-reffed.ts.json | 6 + .../1571-optional-call-tostring-tail.ts.json | 6 + .../1571-stdin-set-raw-mode-non-tty.ts.json | 6 + .../1572-promise-reject-all-tuple.ts.json | 6 + .../1572-x509-validity-date-gettime.ts.json | 6 + ...1573-promisify-execfile-env-spread.ts.json | 6 + .../1573-tdz-scalar-forward-capture.ts.json | 6 + ...74-dyn-optional-method-number-keys.ts.json | 6 + .../1574-promise-all-tuple-literal.ts.json | 6 + .../1575-unknown-assert-into-record.ts.json | 6 + .../tests/corpus/1576-width-coercions.ts.json | 6 + .../tests/corpus/1577-url-hostname.ts.json | 6 + .../corpus/1578-exec-input-optional.ts.json | 6 + .../tests/corpus/1579-matchall-index.ts.json | 6 + .../1580-exec-env-conditional-spread.ts.json | 6 + .../corpus/1581-declare-const-read.ts.json | 6 + .../corpus/1582-timer-sleep-resolve.ts.json | 6 + .../1583-loops-and-stream-captures.ts.json | 6 + .../1584-union-field-unassigned.ts.json | 6 + .../1585-union-field-conditional-ctor.ts.json | 6 + ...86-derived-field-before-super-init.ts.json | 6 + .../corpus/1587-any-field-unassigned.ts.json | 6 + .../tests/corpus/1590-js-unannotated.js.json | 6 + .../tests/corpus/1591-js-closures.js.json | 6 + .../tests/corpus/1592-js-classes.js.json | 6 + .../corpus/1593-js-jsdoc-records.js.json | 6 + .../tests/corpus/1594-js-async.js.json | 6 + .../corpus/1595-js-island-gap/main.js.json | 6 + .../corpus/1596-cjs-modules/main.js.json | 8 + .../tests/corpus/1597-mjs-graph/main.mjs.json | 8 + .../1598-cjs-builtin-require/main.js.json | 6 + .../corpus/1599-js-uncaught-throw.js.json | 6 + .../tests/corpus/1600-assert-passing.ts.json | 6 + .../corpus/1601-assert-fail-exit.ts.json | 6 + .../corpus/1602-assert-caught-error.ts.json | 6 + .../1603-assert-scalar-messages.ts.json | 6 + .../1604-assert-deep-structures.ts.json | 6 + .../corpus/1605-assert-import-forms.ts.json | 6 + .../corpus/1606-assert-strict-module.ts.json | 6 + .../corpus/1607-assert-throws-match.ts.json | 6 + .../tests/corpus/1608-cjs-assert/main.js.json | 6 + .../tests/corpus/1609-assert-async.ts.json | 6 + .../tests/corpus/1610-path-win32-full.ts.json | 6 + .../1611-url-file-bridge-neutral.ts.json | 6 + .../corpus/1612-cjs-module-globals.cjs.json | 6 + .../1613-cjs-esm-proxy-named/main.mjs.json | 7 + .../corpus/1614-js-fence-dodges.cjs.json | 6 + .../1615-cjs-export-shapes/main.cjs.json | 8 + .../main.mjs.json | 7 + .../1617-cjs-esm-lexer-visible/main.mjs.json | 11 + .../1618-cjs-esm-poisoned-tail/main.mjs.json | 7 + .../main.mjs.json | 8 + .../main.js.json | 8 + .../1621-cjs-require-cache-hit/main.js.json | 7 + .../1622-cjs-require-conditional/main.js.json | 8 + .../1623-cjs-require-diamond/main.js.json | 9 + .../main.js.json | 7 + .../1625-cjs-require-lazy-fn/main.js.json | 8 + .../corpus/1626-cjs-require-mjs/main.js.json | 8 + .../main.mjs.json | 8 + ...1628-checked-dynamic-builtin-args.cjs.json | 6 + .../1629-require-main-filename.cjs.json | 6 + .../tests/corpus/1630-inspect-scalars.ts.json | 6 + .../corpus/1630-rmsync-retry-options.cjs.json | 6 + .../tests/corpus/1631-inspect-arrays.ts.json | 6 + .../tests/corpus/1632-inspect-records.ts.json | 6 + .../tests/corpus/1633-inspect-map-set.ts.json | 6 + .../tests/corpus/1634-inspect-classes.ts.json | 6 + .../tests/corpus/1635-inspect-buffer.ts.json | 6 + .../tests/corpus/1636-util-format.ts.json | 6 + .../tests/corpus/1637-inspect-dyn.ts.json | 6 + .../tests/corpus/1638-inspect-cjs.cjs.json | 6 + .../1639-versions-openssl-probe.ts.json | 6 + .../tests/corpus/1640-fd-read-decode.ts.json | 6 + .../tests/corpus/1641-string-search.ts.json | 6 + .../1642-object-fromentries-rows.ts.json | 6 + .../corpus/1643-metadata-dyn-return.cjs.json | 6 + .../tests/corpus/1644-ee-basics.ts.json | 6 + .../tests/corpus/1645-ee-extends.ts.json | 6 + .../tests/corpus/1646-ee-once-remove.ts.json | 6 + .../tests/corpus/1647-ee-meta-events.ts.json | 6 + .../tests/corpus/1648-ee-error-event.ts.json | 6 + .../tests/corpus/1649-ee-names-counts.ts.json | 6 + .../tests/corpus/1650-ee-prepend.ts.json | 6 + .../corpus/1651-ee-max-listeners.ts.json | 6 + .../tests/corpus/1652-ee-snapshot.ts.json | 6 + .../tests/corpus/1653-ee-cjs.cjs.json | 6 + .../tests/corpus/1654-ee-namespace.ts.json | 6 + .../corpus/1655-spawnsync-neutral.ts.json | 6 + .../corpus/1656-execsync-neutral.ts.json | 6 + .../corpus/1657-spawn-async-neutral.ts.json | 6 + .../corpus/1660-buffer-read-write-num.ts.json | 6 + .../corpus/1661-buffer-encodings-full.ts.json | 6 + .../1662-string-decoder-encodings.ts.json | 6 + .../1663-buffer-compare-search-fill.ts.json | 6 + .../corpus/1664-dyn-fn-boundary.cjs.json | 6 + .../corpus/1665-dyn-fn-mustcall/main.cjs.json | 7 + .../tests/corpus/1666-dyn-fn-identity.ts.json | 6 + .../corpus/1667-dyn-fn-not-callable.cjs.json | 6 + .../tests/corpus/1668-dyn-fn-throws.cjs.json | 6 + .../tests/corpus/1669-symbol-identity.ts.json | 6 + .../tests/corpus/1670-symbol-registry.ts.json | 6 + .../tests/corpus/1671-symbol-typeof.ts.json | 6 + .../corpus/1672-symbol-containers.ts.json | 6 + .../tests/corpus/1673-symbol-cjs.cjs.json | 6 + .../tests/corpus/1674-symbol-inspect.ts.json | 6 + .../corpus/1676-func-array-surface.ts.json | 6 + .../corpus/1677-emitter-listeners.ts.json | 6 + .../1678-emitter-dyn-listeners.cjs.json | 6 + .../tests/corpus/1679-console-dyn.js.json | 6 + .../tests/corpus/1680-assert-bytes.ts.json | 6 + .../tests/corpus/1681-assert-funcs.ts.json | 6 + .../1685-stream-readable-basics.ts.json | 6 + .../1686-stream-readable-paused.ts.json | 6 + .../1687-stream-readable-flow-control.ts.json | 6 + .../1688-stream-writable-basics.ts.json | 6 + .../1689-stream-writable-async-drain.ts.json | 6 + .../tests/corpus/1690-stream-duplex.ts.json | 6 + .../corpus/1691-stream-transform.ts.json | 6 + .../tests/corpus/1692-stream-pipe.ts.json | 6 + .../1693-stream-pipe-backpressure.ts.json | 6 + .../tests/corpus/1694-stream-destroy.ts.json | 6 + .../tests/corpus/1695-stream-props.ts.json | 6 + .../1696-stream-read-inside-read.ts.json | 6 + .../corpus/1697-stream-tick-vs-timer.ts.json | 6 + .../corpus/1698-stream-uncaught-error.ts.json | 6 + .../1699-stream-callback-shapes.ts.json | 6 + .../corpus/1700-mustcall-common/main.cjs.json | 7 + .../1701-mustcall-exit-report/main.cjs.json | 7 + .../corpus/1702-dyn-proto-dispatch.cjs.json | 6 + .../corpus/1703-arguments-rest-props.cjs.json | 6 + .../corpus/1710-cjs-export-class/main.js.json | 7 + .../main.js.json | 11 + .../tests/corpus/1712-field-incdec.ts.json | 6 + .../tests/corpus/1713-js-dyn-fields.js.json | 6 + .../corpus/1720-assert-throws-shape.ts.json | 6 + .../1721-assert-throws-regex-class.ts.json | 6 + .../tests/corpus/1722-assert-rejects.ts.json | 6 + .../1723-assert-does-not-reject.ts.json | 6 + .../tests/corpus/1724-assert-iferror.ts.json | 6 + .../tests/corpus/1725-assert-symbols.ts.json | 6 + .../1726-promise-with-resolvers.ts.json | 6 + .../1727-assert-throws-shape-exit.ts.json | 6 + .../1730-countdown-symbol-keys/main.js.json | 8 + .../corpus/1731-symbol-field-shapes.cjs.json | 6 + .../main.js.json | 7 + .../1740-stream-extends-readable.ts.json | 6 + .../1741-stream-extends-writable.ts.json | 6 + ...42-stream-extends-duplex-transform.ts.json | 6 + .../1743-stream-extends-vt-dispatch.ts.json | 6 + .../corpus/1744-stream-set-encoding.ts.json | 6 + .../corpus/1745-stream-encoding-js.cjs.json | 6 + .../corpus/1746-stream-for-await.ts.json | 6 + .../corpus/1747-stream-for-await-js.cjs.json | 6 + .../corpus/1750-http-agent-options.ts.json | 6 + .../corpus/1751-options-record-stance.ts.json | 6 + .../corpus/1760-surplus-args-drop.cjs.json | 6 + .../1761-emitter-special-event-names.cjs.json | 6 + .../corpus/1770-assert-dyn-strict.ts.json | 6 + .../tests/corpus/1771-assert-dyn-deep.ts.json | 6 + .../tests/corpus/1772-assert-dyn-js.cjs.json | 6 + .../tests/corpus/1773-assert-dyn-exit.ts.json | 6 + .../corpus/1780-http-res-surface.ts.json | 6 + .../corpus/1781-http-server-shapes.cjs.json | 6 + .../corpus/1790-computed-key-folds.ts.json | 6 + .../corpus/1791-searchparams-core.ts.json | 6 + .../corpus/1792-searchparams-encoding.ts.json | 6 + .../1793-searchparams-iteration.ts.json | 6 + .../corpus/1794-searchparams-url-live.ts.json | 6 + .../corpus/1795-dyn-handle-request.cjs.json | 6 + .../corpus/1796-dyn-handle-body.cjs.json | 6 + .../corpus/1797-dyn-handle-socket.cjs.json | 6 + .../corpus/1798-dyn-handle-typed-box.ts.json | 6 + .../corpus/1800-immediate-basics.ts.json | 6 + .../corpus/1801-immediate-handle.ts.json | 6 + .../corpus/1802-immediate-unref-exit.ts.json | 6 + .../tests/corpus/1803-timeout-refresh.ts.json | 6 + .../tests/corpus/1804-timers-module.ts.json | 6 + .../corpus/1805-timer-callback-args.ts.json | 6 + .../corpus/1806-timer-delay-trunc.ts.json | 6 + .../1810-stream-options-const-record.ts.json | 6 + ...811-stream-option-value-callbacks.cjs.json | 6 + ...2-stream-super-options-forwarding.cjs.json | 6 + .../tests/corpus/1813-stream-finished.ts.json | 6 + .../corpus/1814-stream-pipeline.cjs.json | 6 + .../corpus/1815-stream-state-reads.cjs.json | 6 + .../corpus/1820-static-block-basics.ts.json | 6 + .../corpus/1821-static-block-order.ts.json | 6 + .../tests/corpus/1822-static-block-js.js.json | 6 + .../1823-static-instance-method-names.ts.json | 6 + ...1824-for-of-destructuring-defaults.ts.json | 6 + .../1825-exhaustive-typeof-switch.ts.json | 6 + ...1826-settimeout-arguments-callback.js.json | 6 + .../corpus/1830-enum-numeric-basics.ts.json | 6 + .../1831-enum-string-const-reverse.ts.json | 6 + .../corpus/1832-enum-modules/main.ts.json | 7 + .../tests/corpus/1835-var-basics.ts.json | 6 + .../corpus/1836-var-loop-capture.ts.json | 6 + .../1837-var-undefined-hoisting.ts.json | 6 + .../corpus/1838-var-modules/main.ts.json | 7 + .../tests/corpus/1839-var-js/main.cjs.json | 7 + .../1840-jsdoc-import-type-only/main.js.json | 6 + .../tests/corpus/1850-overload-basics.ts.json | 6 + .../1851-overload-return-narrowing.ts.json | 6 + .../1852-overload-class-members.ts.json | 6 + .../corpus/1853-overload-modules/main.ts.json | 7 + .../corpus/1854-ambient-declare-fn.ts.json | 6 + .../1855-ambient-declare-fn-uncaught.ts.json | 6 + .../corpus/1870-unit-type-values.ts.json | 6 + .../corpus/1871-empty-array-never.ts.json | 6 + .../1872-template-tostring-composite.ts.json | 6 + .../1880-json-declared-field-order.ts.json | 6 + .../corpus/1881-default-anon/main.ts.json | 8 + .../1882-default-cjs-interop/main.ts.json | 8 + .../corpus/1883-default-exports/main.ts.json | 11 + .../tests/corpus/1890-ns-imports/main.ts.json | 7 + .../corpus/1891-ns-reexport/main.ts.json | 10 + .../corpus/1940-class-values-basics.ts.json | 6 + .../corpus/1941-class-values-registry.ts.json | 6 + .../corpus/1942-class-expressions.ts.json | 6 + .../1943-class-statics-expanded.ts.json | 6 + .../1944-class-values-modules/main.ts.json | 7 + .../corpus/1950-generic-fn-values.ts.json | 6 + .../1951-generic-classes-basics.ts.json | 6 + .../1952-generic-class-statics-values.ts.json | 6 + .../1953-generic-class-hierarchy.ts.json | 6 + .../corpus/1954-generic-modules/main.ts.json | 7 + .../corpus/1960-namespace-basics.ts.json | 6 + .../corpus/1961-namespace-nested.ts.json | 6 + .../corpus/1962-namespace-classes.ts.json | 6 + .../corpus/1963-namespace-aliases.ts.json | 6 + .../corpus/1964-namespace-type-only.ts.json | 6 + .../corpus/1965-namespace-ambient.ts.json | 6 + .../1966-namespace-modules/main.ts.json | 7 + .../1967-namespace-alias-typeonly.ts.json | 6 + .../1968-namespace-import-eq-snapshot.ts.json | 6 + .../corpus/1970-decorators-basics.ts.json | 6 + .../corpus/1971-decorators-rebinding.ts.json | 6 + .../corpus/1972-decorators-throwing.ts.json | 6 + .../corpus/1973-decorators-ambient.ts.json | 6 + .../1980-primitive-proto-statics.ts.json | 6 + .../tests/corpus/1981-date-utc.ts.json | 6 + .../1982-freeze-resolve-passthrough.ts.json | 6 + .../corpus/1983-array-tuple-surfaces.ts.json | 6 + .../tests/corpus/1990-labels-basics.ts.json | 6 + .../tests/corpus/1991-for-in-loops.ts.json | 6 + .../tests/corpus/1992-small-syntax.ts.json | 6 + .../tests/corpus/200-strings.ts.json | 6 + .../corpus/2000-generic-methods-basic.ts.json | 6 + ...2001-generic-methods-generic-class.ts.json | 6 + .../2002-generic-methods-inheritance.ts.json | 6 + ...003-generic-methods-object-literal.ts.json | 6 + .../2004-generic-methods-statics.ts.json | 6 + .../tests/corpus/201-templates.ts.json | 6 + .../corpus/2010-generators-basics.ts.json | 6 + .../corpus/2011-generators-forof.ts.json | 6 + .../2012-generators-return-throw.ts.json | 6 + .../2013-generators-sent-values.ts.json | 6 + .../corpus/2014-generators-values.ts.json | 6 + .../corpus/2015-generators-yieldstar.ts.json | 6 + .../corpus/2016-generators-rc-stress.ts.json | 6 + .../corpus/2017-generators-async.ts.json | 6 + .../corpus/2018-generators-uncaught.ts.json | 6 + .../corpus/2019-generators-loops.ts.json | 6 + .../2020-generic-value-bindings.ts.json | 6 + .../main.ts.json | 7 + .../corpus/2022-width-index-capture.ts.json | 6 + .../tests/corpus/2023-width-readonly.ts.json | 6 + .../corpus/2024-width-array-elems.ts.json | 6 + .../corpus/2025-width-union-compose.ts.json | 6 + .../tests/corpus/2026-width-spread.ts.json | 6 + .../tests/corpus/2030-width-nested.ts.json | 6 + .../tests/corpus/2031-width-tuples.ts.json | 6 + .../main.cjs.json | 8 + ...3-property-assigned-class-extends.cjs.json | 6 + .../corpus/2035-ternary-array-retag.cjs.json | 6 + .../corpus/2036-evolving-array-decl.cjs.json | 6 + .../corpus/2037-fn-decl-hoisting.cjs.json | 6 + .../corpus/2038-evolving-array-js.cjs.json | 6 + .../tests/corpus/2040-any-bindings.ts.json | 6 + .../tests/corpus/2040-mixin-heritage.ts.json | 6 + .../corpus/2041-any-params-returns.ts.json | 6 + .../tests/corpus/2041-mixin-values.ts.json | 6 + .../tests/corpus/2042-any-flow-loops.ts.json | 6 + .../corpus/2042-mixin-modules/main.ts.json | 7 + .../tests/corpus/2043-any-dom-values.ts.json | 6 + .../tests/corpus/2043-mixin-rc-stress.ts.json | 6 + .../corpus/2044-vtable-sibling-slots.ts.json | 6 + .../2045-objlit-accessors-basic.ts.json | 6 + .../corpus/2045-parameter-properties.ts.json | 6 + .../corpus/2046-abstract-classes.ts.json | 6 + .../2046-objlit-accessors-effects.ts.json | 6 + .../2047-objlit-accessors-shapes.ts.json | 6 + .../corpus/2047-optional-class-fields.ts.json | 6 + .../main.ts.json | 6 + .../2051-dynamic-import-then/main.ts.json | 6 + .../corpus/2052-dynamic-import-self.ts.json | 6 + .../corpus/2053-typeof-static-fold.ts.json | 6 + .../2054-destructuring-island-source.ts.json | 6 + .../tests/corpus/2060-empty-tuple.ts.json | 6 + .../corpus/2070-computed-key-folds.ts.json | 6 + ...2071-integer-key-enumeration-order.ts.json | 6 + .../2072-expando-function-members.ts.json | 6 + .../2073-destructuring-assignment.ts.json | 6 + .../corpus/2074-island-destructuring.ts.json | 6 + .../2075-index-signature-runtime-keys.ts.json | 6 + .../2080-destructuring-defaults.ts.json | 6 + .../corpus/2081-destructuring-rest.ts.json | 6 + .../2082-destructuring-assignment.ts.json | 6 + .../2083-destructuring-island-decl.ts.json | 6 + ...84-destructuring-primitive-sources.ts.json | 6 + ...85-destructuring-heads-rest-params.ts.json | 6 + .../2086-destructuring-island-globals.ts.json | 6 + .../2087-destructuring-for-heads.ts.json | 6 + .../2090-index-signature-number-keys.ts.json | 6 + ...ndex-signature-string-intersection.ts.json | 6 + .../corpus/2092-package-imports/main.ts.json | 9 + .../tests/corpus/2093-timers-promises.ts.json | 6 + .../corpus/2094-diagnostics-channel.ts.json | 6 + .../corpus/2095-js-catch-unknown.js.json | 6 + .../tests/corpus/2096-os-type.ts.json | 6 + .../corpus/2097-js-evolving-globals.js.json | 6 + .../tests/corpus/210-string-methods.ts.json | 6 + .../corpus/2100-stream-default-hwm.ts.json | 6 + .../corpus/2101-dyn-param-defaults.ts.json | 6 + .../corpus/2102-empty-pattern-decls.ts.json | 6 + .../2103-optional-tuple-elements.ts.json | 6 + .../2104-computed-key-destructuring.ts.json | 6 + .../2105-computed-key-static-folds.ts.json | 6 + .../corpus/2106-comma-expressions.ts.json | 6 + .../tests/corpus/211-string-unicode.ts.json | 6 + .../corpus/2110-top-object-types.ts.json | 6 + .../2111-json-stringify-unknown.ts.json | 6 + .../corpus/2112-array-at-findlast.ts.json | 6 + .../corpus/2113-string-index-methods.js.json | 6 + .../corpus/212-string-aliasing-append.ts.json | 6 + .../2120-package-self-import/main.ts.json | 7 + .../main.ts.json | 7 + .../2122-import-refusal-crash/main.ts.json | 6 + .../2123-ambient-import-crash/main.ts.json | 6 + .../2124-imports-field-wildcard/main.ts.json | 7 + .../2130-overload-island-returns.ts.json | 6 + .../corpus/2140-uri-component-codecs.ts.json | 6 + .../corpus/2160-dc-tracing-channel.cjs.json | 6 + .../2161-js-object-literal-identity.cjs.json | 6 + .../corpus/2162-js-dyn-destructure.cjs.json | 6 + .../corpus/2163-js-selfref-const.cjs.json | 6 + .../corpus/2164-js-then-dyn-handler.cjs.json | 6 + .../tests/corpus/2165-js-throw-dyn.cjs.json | 6 + .../corpus/2166-cjs-getter-this/main.cjs.json | 7 + .../corpus/2170-island-array-exits.ts.json | 6 + .../corpus/2171-island-json-stringify.ts.json | 6 + .../2172-island-regexp-boundary.ts.json | 6 + ...190-new-object-and-string-wrappers.ts.json | 6 + .../tests/corpus/2191-uri-encoders.ts.json | 6 + .../2192-object-default-tostring.ts.json | 6 + .../2193-discarded-stdlib-reads.ts.json | 6 + .../corpus/2194-ambient-undef-chains.ts.json | 6 + .../main.mjs.json | 7 + .../2196-island-computed-key-chain.ts.json | 6 + .../corpus/2210-dyn-promise-crossing.cjs.json | 6 + .../corpus/2211-dc-trace-promise.cjs.json | 6 + ...2212-unhandled-rejection-listener.cjs.json | 6 + .../corpus/2213-async-local-storage.cjs.json | 6 + .../tests/corpus/2214-dc-bind-store.cjs.json | 6 + .../2215-process-emit-warning-exit.cjs.json | 6 + .../2240-width-class-into-record.ts.json | 6 + .../2241-width-record-into-class.ts.json | 6 + .../2242-width-statics-into-record.ts.json | 6 + ...2243-width-assert-satisfies-shapes.ts.json | 6 + .../corpus/2250-tagged-templates.ts.json | 6 + .../corpus/2251-tagged-templates-dyn.ts.json | 6 + .../tests/corpus/2252-class-iterators.ts.json | 6 + .../tests/corpus/2253-union-coercions.ts.json | 6 + .../corpus/2260-http2-constants.cjs.json | 6 + ...280-builtin-namespace-destructure.cjs.json | 6 + .../2281-domexception-atob-btoa.cjs.json | 6 + .../corpus/2282-queue-microtask.cjs.json | 6 + .../corpus/2283-structured-clone.cjs.json | 6 + .../corpus/2284-regexp-constructor.cjs.json | 6 + .../tests/corpus/2285-iferror-dyn.cjs.json | 6 + .../corpus/2286-dyn-object-walks.cjs.json | 6 + ...yn-record-spread-and-keyed-access.cjs.json | 6 + .../2301-cjs-export-table-dom-attach.cjs.json | 6 + .../corpus/2310-process-next-tick.ts.json | 6 + .../2311-next-tick-js-callbacks.js.json | 6 + .../2312-stream-underscore-assign.ts.json | 6 + .../2313-stream-underscore-assign-js.cjs.json | 6 + .../corpus/2314-process-introspection.ts.json | 6 + .../tests/corpus/2320-await-unit.ts.json | 6 + .../2321-emitter-static-setmax.cjs.json | 6 + .../tests/corpus/2322-dyn-array-sort.cjs.json | 6 + .../2323-timer-callback-returns.ts.json | 6 + .../2330-tls-server-runtime-options.cjs.json | 6 + .../2331-tls-server-options-typed.ts.json | 6 + .../tests/corpus/2350-nan-global.ts.json | 6 + .../tests/corpus/2351-async-methods.ts.json | 6 + .../tests/corpus/2352-void-coercions.ts.json | 6 + .../2353-decorators-member-ambient.ts.json | 6 + ...2354-decorators-expression-ambient.ts.json | 6 + .../tests/corpus/2360-tuple-to-array.ts.json | 6 + .../corpus/2361-assign-index-record.ts.json | 6 + .../corpus/2362-execsync-inherit.ts.json | 6 + .../tests/corpus/2363-nullish-retag.ts.json | 6 + .../tests/corpus/2364-in-runtime-key.ts.json | 6 + .../tests/corpus/2365-dyn-into-island.ts.json | 6 + .../corpus/2366-string-well-formed.ts.json | 6 + .../tests/corpus/2367-regexp-escape.ts.json | 6 + .../tests/corpus/2368-set-methods.ts.json | 6 + .../tests/corpus/2369-promise-try.ts.json | 6 + .../tests/corpus/2370-group-by.ts.json | 6 + .../corpus/2371-iterator-helpers.ts.json | 6 + .../2380-buffer-module-named-import.ts.json | 6 + .../2381-builtin-default-imports.js.json | 6 + .../corpus/2382-cycle-two-decl/main.ts.json | 8 + .../corpus/2383-cycle-assertdoc/main.js.json | 9 + .../2384-cycle-mixed-bindings/main.ts.json | 8 + .../2385-builtin-reexport-facade/main.ts.json | 7 + .../tests/corpus/2386-string-to-chars.ts.json | 6 + .../tests/corpus/2387-tonumber-argv.ts.json | 6 + .../corpus/2388-tonumber-grammar-zoo.ts.json | 6 + .../corpus/2389-tonumber-unary-plus.ts.json | 6 + .../corpus/2390-dot-requires/main.cjs.json | 9 + .../2391-default-builtin-imports/main.ts.json | 6 + .../2392-block-guard-alias-scope.ts.json | 6 + .../2393-loop-exit-guard-narrow.ts.json | 6 + .../2394-loop-narrow-containment.ts.json | 6 + .../corpus/2395-while-cond-guard.ts.json | 6 + .../corpus/2396-born-narrowed-decl.ts.json | 6 + .../corpus/2397-branch-kill-merge.ts.json | 6 + .../tests/corpus/2398-switch-arm-kill.ts.json | 6 + .../2399-reassign-kill-polarity.ts.json | 6 + .../tests/corpus/240-stdout-write.ts.json | 6 + .../corpus/2400-kill-return-edge.ts.json | 6 + .../corpus/2401-kill-break-staging.ts.json | 6 + .../corpus/2402-labeled-break-kill.ts.json | 6 + .../2403-kill-continue-backedge.ts.json | 6 + .../corpus/2404-kill-throw-catch.ts.json | 6 + .../corpus/2405-sibling-arm-narrow.ts.json | 6 + .../2406-switch-clause-sibling-narrow.ts.json | 6 + .../corpus/2407-infinite-loop-seal.ts.json | 6 + .../2408-loop-terminality-reopen.ts.json | 6 + ...2409-loop-body-return-not-terminal.ts.json | 6 + .../2410-stacked-cases-terminality.ts.json | 6 + ...2411-exhaustive-switch-terminality.ts.json | 6 + .../2412-dowhile-guard-trailing-test.ts.json | 6 + .../corpus/2413-dowhile-kill-renarrow.ts.json | 6 + .../corpus/2414-dowhile-continue-kill.ts.json | 6 + .../2415-dowhile-break-trailing-test.ts.json | 6 + .../2416-spread-ternary-positions.ts.json | 6 + .../2417-ternary-local-inference.ts.json | 6 + .../corpus/2418-wrapped-ternary-arms.ts.json | 6 + .../2419-selector-ternary-union.ts.json | 6 + .../corpus/2420-nullish-null-identity.ts.json | 6 + .../corpus/2421-float-lane-inference.ts.json | 6 + .../corpus/2422-ieee-div-rem-corners.ts.json | 6 + .../corpus/2423-param-null-reassign.ts.json | 6 + .../2424-ternary-miss-first-narrowing.ts.json | 6 + .../2425-elseif-head-exit-narrow.ts.json | 6 + .../main.ts.json | 8 + .../tests/corpus/2427-perf-hooks-now.ts.json | 6 + .../2428-field-redeclare-inherited.ts.json | 6 + .../2429-destructure-class-instance.ts.json | 6 + .../2430-empty-literal-unknown-field.js.json | 6 + .../corpus/2431-primitive-ctor-values.ts.json | 6 + .../2432-generic-member-fields-async.ts.json | 6 + .../2433-as-const-command-tables.ts.json | 6 + .../corpus/2434-deferred-init-fields.ts.json | 6 + .../2435-loose-same-kind-equality.ts.json | 6 + .../corpus/2440-console-inspect-args.ts.json | 6 + .../corpus/2441-console-process-argv.ts.json | 6 + .../2442-union-literal-arm-widening.ts.json | 6 + ...443-union-literal-shadow-narrowing.ts.json | 6 + .../2444-union-literal-reducer-spread.ts.json | 6 + .../corpus/2445-math-minmax-nary.ts.json | 6 + .../corpus/2446-performance-global.ts.json | 6 + .../2447-island-boundary-slots/main.ts.json | 6 + ...448-entries-null-arms-regex-arrays.ts.json | 6 + .../corpus/2449-js-dyn-worlds/main.js.json | 7 + .../2450-private-instance-methods.ts.json | 6 + .../tests/corpus/2451-private-fields.ts.json | 6 + .../tests/corpus/2452-private-statics.ts.json | 6 + .../corpus/2453-private-accessors.ts.json | 6 + .../2454-private-generator-methods.ts.json | 6 + .../corpus/2455-private-brand-checks.ts.json | 6 + .../corpus/2456-private-async-methods.ts.json | 6 + .../tests/corpus/2457-private-members.js.json | 6 + .../corpus/2460-qs-parse-grammar.ts.json | 6 + .../corpus/2461-qs-parse-options.ts.json | 6 + .../tests/corpus/2462-qs-stringify.ts.json | 6 + .../corpus/2463-qs-escape-unescape.ts.json | 6 + .../corpus/2464-qs-require-forms.cjs.json | 6 + .../corpus/2470-mockable-module-shape.js.json | 6 + .../2471-record-keyed-write-hasown.js.json | 6 + .../corpus/2472-string-regexp-union.ts.json | 6 + .../corpus/2473-option-table-widths.js.json | 6 + .../corpus/2474-island-literal-forms.ts.json | 6 + .../2475-variadic-wrapper-island.js.json | 6 + .../corpus/2476-map-regex-values.ts.json | 6 + .../corpus/2480-recursive-record-tree.ts.json | 6 + .../2481-mutual-recursive-records.ts.json | 6 + .../corpus/2482-recursive-union-tree.ts.json | 6 + .../2483-recursive-record-cycles.ts.json | 6 + .../2484-json-stringify-circular.ts.json | 6 + .../corpus/2485-inspect-circular-refs.ts.json | 6 + .../2486-recursive-record-boundaries.ts.json | 6 + .../corpus/2487-recursive-deep-equal.ts.json | 6 + .../tests/corpus/2488-ast-walker.ts.json | 6 + .../2490-find-miss-null-compare.ts.json | 6 + .../2491-strict-unit-compare-no-arm.ts.json | 6 + .../2492-loose-null-compare-unions.ts.json | 6 + .../corpus/2493-switch-unit-cases.ts.json | 6 + .../2494-no-arm-compare-effects.ts.json | 6 + .../corpus/2500-net-autosel-timeout.ts.json | 6 + .../2510-dyn-evolving-array-map.ts.json | 6 + ...-dyn-evolving-array-filter-foreach.ts.json | 6 + ...2512-dyn-evolving-array-mixed-push.ts.json | 6 + .../2513-dyn-evolving-array-derived.ts.json | 6 + ...0-private-statics-class-name-calls.ts.json | 6 + ...1-private-statics-class-expression.ts.json | 6 + .../2522-private-statics-decorated.ts.json | 6 + ...2523-private-statics-aliased-class.ts.json | 6 + .../2530-object-destructuring-decl.ts.json | 6 + ...531-array-tuple-destructuring-decl.ts.json | 6 + .../2532-param-destructuring-options.ts.json | 6 + .../corpus/2533-forof-destructuring.ts.json | 6 + .../corpus/2534-object-rest-decl.ts.json | 6 + .../2535-destructuring-assign-basics.ts.json | 6 + .../2536-destructuring-assign-nested.ts.json | 6 + ...estructuring-assign-member-targets.ts.json | 6 + ...-destructuring-assign-class-source.ts.json | 6 + .../corpus/2539-class-instance-rest.ts.json | 6 + ...40-accessor-destructuring-defaults.ts.json | 6 + .../2541-destructuring-eval-order.ts.json | 6 + .../corpus/2550-generics-keyof-pick.ts.json | 6 + .../2551-generics-value-aliases.ts.json | 6 + .../2552-generics-iface-methods.ts.json | 6 + .../2553-generics-signature-bindings.ts.json | 6 + .../corpus/2554-generics-frontier-mix.ts.json | 6 + .../corpus/2555-generics-keyof-writes.ts.json | 6 + .../corpus/2556-crypto-introspection.ts.json | 6 + .../corpus/2556-width-hybrid-shapes.ts.json | 6 + .../tests/corpus/2557-tls-ca-store.ts.json | 6 + .../corpus/2557-width-field-lifts.ts.json | 6 + .../2558-index-signature-func-values.ts.json | 6 + .../corpus/2558-rejection-events.cjs.json | 6 + ...9-index-signature-container-values.ts.json | 6 + .../2560-arraybuffer-dataview-set.ts.json | 6 + .../tests/corpus/2561-object-is.ts.json | 6 + .../2562-intl-numberformat-en-us.ts.json | 6 + .../2563-stream-promises-pipeline.ts.json | 6 + .../2564-stream-promises-finished.ts.json | 6 + .../corpus/2565-stream-promises-js.cjs.json | 6 + .../2566-promise-reject-dyn-reason.js.json | 6 + .../corpus/2567-rest-spread-forward.js.json | 6 + .../2568-rest-spread-forward-dynamic.js.json | 6 + .../tests/corpus/2569-upcast-identity.ts.json | 6 + .../2570-buffer-arg-validation.cjs.json | 6 + .../2571-searchparams-arg-validation.cjs.json | 6 + ...72-readable-emitted-readable-flag.cjs.json | 6 + .../corpus/2573-fs-url-arg-ladders.cjs.json | 6 + ...574-emitter-max-listeners-ladders.cjs.json | 6 + .../2575-string-destructuring-decl.ts.json | 6 + .../2576-string-destructuring-assign.ts.json | 6 + .../2577-builtin-global-destructuring.js.json | 6 + .../2578-jsval-into-unknown-rows.ts.json | 6 + .../2579-jsval-object-param-crossing.js.json | 6 + .../2580-jsval-routed-keyed-ops.js.json | 6 + .../corpus/2581-jsval-routed-calls.js.json | 6 + .../corpus/2582-jsval-object-statics.js.json | 6 + .../2582-jsval-routed-keyed-ops.js.json | 6 + .../corpus/2583-dyn-nullish-coalesce.js.json | 6 + .../corpus/2583-jsval-routed-calls.js.json | 6 + .../corpus/2584-jsval-object-statics.js.json | 6 + .../corpus/2584-union-dyn-collapse.ts.json | 6 + .../corpus/2585-dyn-nullish-coalesce.js.json | 6 + .../tests/corpus/2585-unknown-array.ts.json | 6 + .../corpus/2586-object-assign-spread.js.json | 6 + .../corpus/2587-array-entries-forof.ts.json | 6 + .../corpus/2588-array-entries-chains.ts.json | 6 + .../corpus/2589-object-create-null.cjs.json | 6 + .../corpus/2590-object-create-dynamic.js.json | 6 + .../corpus/2591-ambient-generic-traps.ts.json | 6 + .../corpus/2592-ambient-trap-uncaught.ts.json | 6 + .../2593-generic-inert-bindings.ts.json | 6 + .../2594-nullish-generic-bindings.ts.json | 6 + .../tests/corpus/2595-fs-arg-ladders.cjs.json | 6 + .../corpus/2596-net-arg-ladders.cjs.json | 6 + .../corpus/2597-dgram-send-ladders.cjs.json | 6 + .../corpus/2598-tls-arg-ladders.cjs.json | 6 + .../corpus/2599-stream-arg-ladders.cjs.json | 6 + .../2600-dyn-keyed-write-harness.js.json | 6 + .../corpus/2601-dyn-keyed-write-ops.js.json | 6 + .../corpus/2602-dyn-array-destructure.js.json | 6 + .../2603-island-keyed-write-dyn.js.json | 6 + .../2604-cycle-classes-mutual/main.ts.json | 8 + .../2605-cycle-three-module/main.ts.json | 9 + .../2606-dynamic-import-cycle/main.ts.json | 6 + .../corpus/2608-regex-named-groups.ts.json | 6 + .../corpus/2609-regex-named-replace.ts.json | 6 + .../corpus/2610-regex-named-matchall.ts.json | 6 + .../2611-regex-named-groups-js.cjs.json | 6 + .../2613-for-init-uninitialized-let.ts.json | 6 + .../2614-trap-binding-later-writes.ts.json | 6 + .../2615-nullish-field-record-binding.ts.json | 6 + .../2616-js-collect-probe-defers.js.json | 6 + .../main.ts.json | 7 + .../corpus/2618-ee-emit-override.ts.json | 6 + .../corpus/2619-ee-override-chain.ts.json | 6 + .../2620-ee-override-once-order.ts.json | 6 + .../2621-ee-override-error-throw.ts.json | 6 + .../corpus/2622-ee-override-filter.ts.json | 6 + .../tests/corpus/2623-ee-job-queue.ts.json | 6 + .../tests/corpus/2624-ee-override-js.cjs.json | 6 + .../tests/corpus/2625-bytes-views.ts.json | 6 + .../corpus/2626-stream-event-names.ts.json | 6 + .../2627-stream-ticks-are-nextticks.ts.json | 6 + .../2628-stream-push-encodings.cjs.json | 6 + .../corpus/2629-stream-consumers.ts.json | 6 + .../2630-stream-consumers-errors.ts.json | 6 + .../corpus/2631-create-require/main.ts.json | 6 + .../corpus/2632-dyn-jsval-iterate.js.json | 6 + .../2633-island-promise-crossing.js.json | 6 + .../2634-stream-pipeline-arg-ladders.cjs.json | 6 + ...35-trap-binding-unmappable-written.ts.json | 6 + ...rap-binding-ambient-rooted-rewrite.ts.json | 6 + .../2637-create-require-bare/main.ts.json | 6 + .../corpus/2638-http-dyn-res-compat.cjs.json | 6 + .../corpus/2639-http-dyn-req-pause.cjs.json | 6 + .../2640-net-dyn-socket-compat.cjs.json | 6 + .../corpus/2641-http-agent-surface.cjs.json | 6 + .../2642-http-agent-maxsockets.cjs.json | 6 + .../corpus/2643-or-default-retag.ts.json | 6 + .../2644-http-client-url-argument.ts.json | 6 + .../2645-https-client-url-argument.ts.json | 6 + .../tests/corpus/2646-top-level-await.ts.json | 6 + .../2647-top-level-await-modules/main.ts.json | 10 + .../2648-top-level-await-rejection.ts.json | 6 + .../2649-top-level-await-pending.ts.json | 6 + .../2650-top-level-await-self-import.ts.json | 6 + ...-top-level-await-pending-unhandled.ts.json | 6 + .../2652-top-level-await-dynamic/main.ts.json | 6 + ...p-level-await-rejection-stops-loop.ts.json | 6 + ...op-level-await-unrelated-rejection.ts.json | 6 + .../2655-top-level-await-cycle/main.ts.json | 7 + .../main.ts.json | 7 + .../main.ts.json | 7 + .../main.ts.json | 7 + .../main.ts.json | 6 + .../main.ts.json | 6 + .../main.ts.json | 6 + .../main.ts.json | 9 + .../main.ts.json | 9 + ...el-await-same-checkpoint-rejection.ts.json | 6 + ...-await-unhandled-listener-liveness.ts.json | 6 + .../tests/corpus/2666-array-to-sorted.ts.json | 6 + .../corpus/2667-array-to-sorted-any.ts.json | 6 + .../2668-stored-number-array-iterator.ts.json | 6 + .../corpus/2669-array-copying-methods.ts.json | 6 + .../2670-uint8array-copy-iterate.ts.json | 6 + .../corpus/2671-array-copying-js.cjs.json | 6 + ...672-http-request-response-callback.ts.json | 6 + ...73-top-level-await-implicit-module.ts.json | 6 + ...op-level-for-await-implicit-module.ts.json | 6 + .../2675-create-require-nested-esm.js.json | 6 + .../corpus/2675-process-self-reexec.ts.json | 6 + .../2676-indexed-read-strict-equality.ts.json | 6 + .../2676-record-clone-overrides.ts.json | 6 + .../main.ts.json | 6 + .../2677-runtime-optional-closure.ts.json | 6 + .../main.ts.json | 8 + .../tests/corpus/2678-date-instances.ts.json | 6 + .../2678-large-string-sparse-index.ts.json | 6 + .../tests/corpus/2678-util-parseargs.ts.json | 6 + .../corpus/2679-util-parseargs-cjs.cjs.json | 6 + .../2680-util-parseargs-default.ts.json | 6 + .../2681-util-parseargs-dynamic.js.json | 6 + .../tests/corpus/2682-fs-rename.ts.json | 6 + .../2683-filter-truthy-predicate.ts.json | 6 + .../tests/corpus/2683-fs-rename-js.cjs.json | 6 + .../2684-filter-no-predicate-dyn.cjs.json | 6 + .../tests/corpus/2684-fs-rename-abort.ts.json | 6 + .../corpus/2685-array-unshift-reverse.ts.json | 6 + .../tests/corpus/2685-fs-write-sync.ts.json | 6 + .../tests/corpus/2686-fs-file-handle.ts.json | 6 + .../2687-fsp-write-file-options.ts.json | 6 + .../corpus/2687-process-write-args.ts.json | 6 + .../corpus/2688-fs-stats-disk-fields.ts.json | 6 + ...689-http-server-timeout-properties.ts.json | 6 + .../2690-https-server-timeout-option.ts.json | 6 + ...691-retained-lowering-record-order.ts.json | 6 + .../2692-inline-record-assert-index.ts.json | 6 + .../corpus/2692-string-accumulation.ts.json | 6 + .../tests/corpus/2693-math-constants.ts.json | 6 + .../corpus/2700-array-sort-complexity.ts.json | 6 + .../corpus/2700-http-static-trailers.ts.json | 6 + .../tests/corpus/2700-wasi-core.ts.json | 6 + .../corpus/2701-array-sort-snapshot.ts.json | 6 + .../2701-http-static-trailer-wire.ts.json | 6 + .../corpus/2701-import-meta/main.mjs.json | 7 + .../2702-http-static-trailer-end.ts.json | 6 + .../2702-type-import-link-static/main.ts.json | 7 + .../corpus/2702-uint8array-to-sorted.ts.json | 6 + .../corpus/2703-array-sparse-sort.ts.json | 6 + .../main.ts.json | 8 + .../2704-array-sparse-to-sorted.ts.json | 6 + .../main.ts.json | 7 + .../2705-array-sparse-sort-append.ts.json | 6 + .../main.ts.json | 7 + .../2706-array-search-missing-needle.ts.json | 6 + .../main.ts.json | 7 + .../2707-array-search-huge-sparse.ts.json | 6 + .../main.ts.json | 8 + .../main.ts.json | 6 + .../corpus/2720-array-read-parity.ts.json | 6 + ...2721-array-nested-missing-receiver.ts.json | 6 + .../2750-array-sparse-foundation.ts.json | 6 + .../2751-buffer-concat-sparse-list.ts.json | 6 + .../corpus/2752-array-optional-stores.ts.json | 6 + .../2753-array-optional-method-values.ts.json | 6 + .../2754-array-property-undefined.ts.json | 6 + ...-array-optional-literal-forwarding.ts.json | 6 + .../2780-array-parity-composition.ts.json | 6 + .../2781-array-missing-value-escape.ts.json | 6 + .../2782-array-sparse-callbacks.ts.json | 6 + .../corpus/2783-array-defaults-rest.ts.json | 6 + .../2784-array-reduce-missing-result.ts.json | 6 + .../2785-array-missing-destructuring.ts.json | 6 + .../2786-array-sparse-serialization.ts.json | 6 + ...87-array-missing-string-arithmetic.ts.json | 6 + ...-array-missing-builtin-conversions.ts.json | 6 + ...89-array-missing-optional-tostring.ts.json | 6 + ...array-missing-tagged-substitutions.ts.json | 6 + .../main.ts.json | 6 + .../corpus/2791-record-optional-keys.ts.json | 6 + ...792-record-optional-spread-entries.ts.json | 6 + ...-union-conversion-identity-capture.ts.json | 6 + ...2794-array-generic-callback-values.ts.json | 6 + ...5-array-optional-typedarray-source.ts.json | 6 + ...rray-sparse-class-value-instanceof.ts.json | 6 + .../2800-array-expression-consumers.ts.json | 6 + .../2801-array-switch-consumers.ts.json | 6 + ...820-array-missing-method-receivers.ts.json | 6 + ...array-optional-numeric-comparisons.ts.json | 6 + .../2830-cjs-require-self-name/main.cjs.json | 7 + .../corpus/2840-finally-completions.ts.json | 6 + .../tests/corpus/2841-using-sync.ts.json | 6 + .../tests/corpus/2842-await-using.ts.json | 6 + .../2843-using-suppressed-error.ts.json | 6 + .../2844-node-disposable-resources.ts.json | 6 + .../tests/corpus/2845-for-using-of.ts.json | 6 + .../tests/corpus/2846-generator-using.ts.json | 6 + .../2850-async-generators-protocol.ts.json | 6 + .../2851-async-generators-values.ts.json | 6 + .../2852-timers-promises-interval.ts.json | 6 + .../corpus/2854-leading-bom-literals.ts.json | 6 + .../2855-searchparams-sort-complexity.ts.json | 6 + .../2856-dynamic-any-local-operators.ts.json | 6 + .../corpus/2857-branded-primitives.ts.json | 6 + .../2858-import-meta-resolve/main.mjs.json | 6 + .../main.mjs.json | 6 + .../corpus/2860-require-resolve/main.cjs.json | 6 + .../2861-readable-iterator-close.ts.json | 6 + .../2862-web-readable-async-iteration.ts.json | 6 + .../corpus/2863-class-async-iterator.ts.json | 6 + .../2864-array-class-method-receivers.ts.json | 6 + .../corpus/2865-cjs-process-alias.cjs.json | 6 + .../tests/corpus/2866-dyn-switch.ts.json | 6 + .../corpus/2867-array-shift-length.js.json | 6 + ...2868-empty-record-promise-presence.js.json | 6 + .../corpus/2869-nullish-mixed-lazy.ts.json | 6 + .../2870-and-dropped-truthy-arm.ts.json | 6 + .../2871-optional-promise-to-unknown.ts.json | 6 + .../2872-unobserved-dynamic-event.ts.json | 6 + ...73-optional-receiver-loop-lifetime.js.json | 6 + ...2874-nullable-callback-field-cycle.js.json | 6 + ...875-evolving-let-read-before-write.js.json | 6 + .../2876-class-unknown-roundtrip.ts.json | 6 + .../2877-child-unknown-roundtrip.ts.json | 6 + .../2878-class-private-unknown.cjs.json | 6 + .../2880-cjs-module-graph/main.cjs.json | 9 + .../corpus/2890-crypto-static-utility.ts.json | 6 + .../2891-json-record-key-escapes.ts.json | 6 + .../2892-windows-console-unicode.ts.json | 6 + .../corpus/2893-child-stdin-duplex.ts.json | 6 + .../2894-child-stdin-backpressure.ts.json | 6 + .../2895-child-stdin-write-after-end.ts.json | 6 + ...896-child-stdin-write-after-finish.ts.json | 6 + .../corpus/2897-child-stdin-destroy.ts.json | 6 + .../2898-child-stdin-spawn-failure.ts.json | 6 + .../2899-nested-mutual-recursion.ts.json | 6 + .../corpus/2900-float64array-static.ts.json | 6 + .../2900-void-conditional-arrow.ts.json | 6 + .../tests/corpus/2901-bigint-core.ts.json | 6 + .../tests/corpus/2902-bigint-bytes.ts.json | 6 + .../tests/corpus/2903-bigint-storage.ts.json | 6 + .../tests/corpus/2904-bigint-errors.ts.json | 6 + .../tests/corpus/2905-bigint-edges.ts.json | 6 + .../corpus/2906-bigint-wasi-width.ts.json | 6 + .../2910-overloaded-callable-alias.ts.json | 6 + .../corpus/2911-execfile-callback.ts.json | 6 + .../2912-execfile-callback-options.ts.json | 6 + .../corpus/2912-promisify-fs-readfile.ts.json | 6 + .../2913-builtin-callable-alias.ts.json | 6 + .../2914-fixed-tuple-call-spread.ts.json | 6 + .../corpus/2915-path-function-values.ts.json | 6 + .../2916-path-function-values-cjs.ts.json | 6 + .../2917-builtin-callable-widths.ts.json | 6 + .../2918-builtin-callable-widths-cjs.ts.json | 6 + .../corpus/2919-fs-function-values.ts.json | 6 + .../2920-fs-promises-function-values.ts.json | 6 + .../tests/corpus/2921-zlib-callbacks.ts.json | 6 + .../corpus/2922-dyn-bitwise-not.cjs.json | 6 + .../2923-cjs-factory-export/main.cjs.json | 7 + .../corpus/2930-union-receiver-calls.ts.json | 6 + .../2931-union-dynamic-field-call.js.json | 6 + .../2932-create-require-program/main.ts.json | 9 + .../2933-static-dynamic-import/main.ts.json | 6 + .../corpus/2934-static-import-stored.ts.json | 6 + .../2935-module-namespace-values/main.ts.json | 7 + .../corpus/2936-static-loose-equality.ts.json | 6 + .../corpus/2937-bitwise-hot-loop.ts.json | 6 + .../corpus/2938-fs-sync-overloads.cjs.json | 6 + .../corpus/2939-child-shell-text.ts.json | 6 + .../tests/corpus/2940-date-parse.ts.json | 6 + .../tests/corpus/2940-fsp-realpath.ts.json | 6 + .../corpus/2941-fsp-lstat-identity.ts.json | 6 + .../corpus/2941-process-exit-code.ts.json | 6 + .../corpus/2942-fsp-readdir-dirent.ts.json | 6 + .../2942-process-exit-code-override.ts.json | 6 + .../2943-process-exit-code-invalid.ts.json | 6 + .../2944-process-exit-code-wrap.ts.json | 6 + .../corpus/2945-url-origin-username.ts.json | 6 + .../corpus/2946-child-fork-ipc/main.ts.json | 6 + .../tests/corpus/2946-url-port-hash.ts.json | 6 + .../corpus/2947-set-readonly-seeds.ts.json | 6 + .../2948-child-fork-eof-callback/main.ts.json | 6 + .../corpus/2948-stdio-callback-record.ts.json | 6 + .../2949-child-fork-default/main.mjs.json | 6 + .../tests/corpus/2949-url-password.ts.json | 6 + .../2950-fs-descriptor-publication.ts.json | 6 + .../corpus/2951-math-static-analytic.ts.json | 6 + .../corpus/2952-math-static-remaining.ts.json | 6 + .../2953-http-header-validation.ts.json | 6 + .../corpus/2954-http-outgoing-headers.ts.json | 6 + .../corpus/2955-http-static-state.ts.json | 6 + .../2956-http-static-informational.ts.json | 6 + ...2957-http-static-response-controls.ts.json | 6 + .../2961-emitter-computed-names.cjs.json | 6 + .../2962-emitter-computed-optional.ts.json | 6 + .../2963-child-fork-dispatch/main.ts.json | 6 + .../corpus/2964-indexed-compound.ts.json | 6 + .../2966-numeric-array-read-fusion.ts.json | 6 + .../2967-numeric-array-read-lifetime.ts.json | 6 + .../corpus/2968-numeric-array-borrow.ts.json | 6 + .../corpus/2969-scalar-record-results.ts.json | 6 + .../2970-constant-numeric-tables.ts.json | 6 + .../2971-constant-table-modules/main.ts.json | 7 + ...972-http-static-distinct-snapshots.ts.json | 6 + .../corpus/2972-math-receiver-borrow.ts.json | 6 + .../corpus/2973-http-static-agent.ts.json | 6 + .../2973-integer-bitwise-arithmetic.ts.json | 6 + .../2974-array-search-from-index.ts.json | 6 + .../2974-http-static-module-values.ts.json | 6 + .../corpus/2974-numeric-remainder.ts.json | 6 + .../corpus/2975-bigint-default-radix.ts.json | 6 + .../2975-http-static-client-controls.ts.json | 6 + .../2976-http-static-incoming-state.ts.json | 6 + .../2976-json-stringify-no-arguments.js.json | 6 + .../2977-http-static-incoming-timeout.ts.json | 6 + ...2977-nested-array-binding-defaults.js.json | 6 + .../2978-http-static-client-timeout.ts.json | 6 + .../2978-regexp-optional-subject.js.json | 6 + .../2979-array-search-mixed-needles.js.json | 6 + .../2979-http-static-server-timeout.ts.json | 6 + ...http-static-server-timeout-default.ts.json | 6 + .../2980-string-position-arguments.js.json | 6 + .../corpus/2981-http-static-events.ts.json | 6 + .../2981-string-optional-positions.ts.json | 6 + .../corpus/2982-http-static-close-all.ts.json | 6 + ...982-string-position-coercion-order.js.json | 6 + .../2983-http-static-close-idle.ts.json | 6 + .../2984-http-static-close-upgrade.ts.json | 6 + .../2985-http-static-message-destroy.ts.json | 6 + ...6-http-static-client-socket-finish.ts.json | 6 + .../2987-http-static-timeout-errors.ts.json | 6 + .../2988-http-static-client-abort.ts.json | 6 + ...tp-static-response-timeout-handled.ts.json | 6 + ...ttp-static-request-timeout-handled.ts.json | 6 + .../2991-array-indexed-equality.ts.json | 6 + .../tests/corpus/2992-stream-rows.ts.json | 6 + .../corpus/2993-fiber-stack-lifetimes.ts.json | 6 + .../corpus/2994-fromcharcode-scalar.ts.json | 6 + .../tests/corpus/2995-math-hyperbolic.ts.json | 6 + .../tests/corpus/2996-math-near-one.ts.json | 6 + .../corpus/2997-math-integer-float.ts.json | 6 + .../tests/corpus/300-if-else.ts.json | 6 + .../corpus/3001-caught-typeof-object.js.json | 6 + .../corpus/3002-promise-then-two.ts.json | 6 + .../tests/corpus/301-while.ts.json | 6 + .../order-parity/tests/corpus/302-for.ts.json | 6 + .../3020-string-last-index-position.ts.json | 6 + .../3021-buffer-union-narrow-callback.ts.json | 6 + .../3022-string-affix-positions.ts.json | 6 + ...023-string-affix-position-coercion.js.json | 6 + .../3024-string-number-narrow-for-in.ts.json | 6 + ...25-string-search-position-coercion.js.json | 6 + .../corpus/3026-array-last-index-of.js.json | 6 + .../3027-array-last-index-of-records.ts.json | 6 + .../3028-string-search-dynamic-needle.js.json | 6 + .../3029-string-search-union-needle.js.json | 6 + .../tests/corpus/303-break-continue.ts.json | 6 + .../corpus/3030-array-search-no-arg.js.json | 6 + ...3031-array-relative-index-coercion.js.json | 6 + ...031-string-last-index-search-value.js.json | 6 + .../corpus/3032-string-search-value.js.json | 6 + ...3033-string-search-needle-coercion.js.json | 6 + .../3034-arguments-with-parameters.js.json | 6 + ...035-string-positioned-search-value.js.json | 6 + .../3036-string-object-search-value.js.json | 6 + .../3037-number-nullish-conversion.js.json | 6 + .../corpus/3038-number-scalar-unions.ts.json | 6 + .../corpus/3039-string-repeat-count.js.json | 6 + .../tests/corpus/304-compound-incdec.ts.json | 6 + .../corpus/3040-string-prototype-call.js.json | 6 + .../3041-string-prototype-object-call.js.json | 6 + .../3042-string-padding-coercion.js.json | 6 + .../3043-string-split-arguments.js.json | 6 + .../3044-array-slice-splice-positions.js.json | 6 + .../3045-array-indexed-mutation.js.json | 6 + .../3046-array-indexed-ref-identity.ts.json | 6 + .../corpus/3047-object-prototype-tag.js.json | 6 + .../corpus/3048-object-own-prototype.ts.json | 6 + .../corpus/3049-array-flat-depth.ts.json | 6 + .../tests/corpus/305-truthiness.ts.json | 6 + .../corpus/3050-array-splice-insert.ts.json | 6 + .../corpus/3051-array-join-default.ts.json | 6 + .../corpus/3052-array-construction.ts.json | 6 + .../corpus/3053-array-construction-js.js.json | 6 + .../corpus/3054-dynamic-abort-record.ts.json | 6 + .../main.ts.json | 6 + .../3056-default-builtin-bundler/main.ts.json | 6 + .../main.ts.json | 6 + .../3058-optional-array-chain-join.ts.json | 6 + .../3059-arguments-property-names.ts.json | 6 + .../corpus/3060-dynamic-host-global.ts.json | 6 + .../3061-concurrent-fiber-stacks.ts.json | 6 + ...062-runtime-optional-record-guards.ts.json | 6 + ...3063-runtime-optional-class-guards.ts.json | 6 + .../3064-installed-entry-imports/main.ts.json | 9 + .../3065-installed-entry-js/main.js.json | 8 + .../corpus/3066-source-debugging/main.ts.json | 7 + .../main.cjs.json | 9 + .../corpus/3068-debug-variables/main.ts.json | 7 + .../corpus/3068-url-checked-identity.ts.json | 6 + .../corpus/3069-set-checked-seed.js.json | 6 + .../tests/corpus/3069-tuple-spread.ts.json | 6 + .../3070-checked-object-accessors.js.json | 6 + .../corpus/3070-collection-views.ts.json | 6 + ...1-checked-specialization-narrowing.js.json | 6 + .../3071-map-contextual-record-seeds.ts.json | 6 + .../3072-optional-union-receivers.ts.json | 6 + .../corpus/3072-weak-process-streams.js.json | 6 + .../3073-optional-callable-module.js.json | 6 + .../corpus/3073-union-keyed-reads.ts.json | 6 + .../3074-discriminated-intersections.ts.json | 6 + ...3075-recursive-contextual-literals.ts.json | 6 + .../3076-nullish-record-defaults.ts.json | 6 + .../3077-optional-union-array-reads.ts.json | 6 + .../3078-forward-mutable-captures.ts.json | 6 + .../corpus/3079-forward-mutable-tdz.ts.json | 6 + .../3080-exhaustive-never-bindings.ts.json | 6 + .../3081-recursive-array-destinations.ts.json | 6 + .../corpus/3082-forward-write-unwind.ts.json | 6 + .../tests/corpus/3083-set-string-seed.ts.json | 6 + .../corpus/3084-record-own-membership.ts.json | 6 + ...85-conditional-record-construction.ts.json | 6 + .../3086-error-constructor-options.ts.json | 6 + .../3087-error-options-lifetime.ts.json | 6 + .../corpus/3088-array-wide-callbacks.ts.json | 6 + .../corpus/3089-array-find-narrowing.ts.json | 6 + .../3090-json-discriminated-records.ts.json | 6 + .../3091-json-recursive-discriminants.ts.json | 6 + .../3092-number-union-predicates.ts.json | 6 + .../corpus/3093-error-option-data.ts.json | 6 + .../3094-json-replacer-traversal.ts.json | 6 + .../3095-json-reviver-traversal.ts.json | 6 + .../3096-json-callback-nonfinite.ts.json | 6 + .../3097-json-callback-reentrancy.ts.json | 6 + .../corpus/3098-json-callback-space.ts.json | 6 + .../3099-json-callback-functions.ts.json | 6 + .../corpus/3100-json-callback-holder.js.json | 6 + .../corpus/3101-json-callback-bytes.ts.json | 6 + .../corpus/3102-json-unknown-fields.ts.json | 6 + ...-scalar-record-nested-control-flow.ts.json | 6 + .../3104-native-analysis-tables-loops.ts.json | 6 + .../corpus/3105-nullable-collections.ts.json | 6 + .../3106-mixed-insertion-spreads.ts.json | 6 + ...3107-nullable-collection-lifetimes.ts.json | 6 + .../corpus/3108-for-await-sync-arrays.js.json | 6 + .../corpus/3108-identity-map-keys.ts.json | 6 + ...109-destructuring-unknown-defaults.js.json | 6 + .../3109-identity-union-collections.ts.json | 6 + .../3110-builtin-error-families.ts.json | 6 + .../3110-identity-collection-mutation.ts.json | 6 + .../3111-identity-collection-cycles.ts.json | 6 + .../3112-union-switch-control-flow.ts.json | 6 + .../corpus/3113-union-array-removal.ts.json | 6 + .../3114-union-record-field-write.ts.json | 6 + ...115-zlib-static-compression-levels.ts.json | 6 + ...3116-sequence-expression-lifetimes.ts.json | 6 + .../3117-unknown-switch-control-flow.ts.json | 6 + .../3118-recursive-union-spread.ts.json | 6 + .../3119-runtime-optional-spread.ts.json | 6 + .../3120-dynamic-property-descriptors.js.json | 6 + ...120-generator-method-loop-bindings.ts.json | 6 + .../corpus/3120-ir-nonfinite-numbers.ts.json | 6 + .../3121-compound-assignment-values.js.json | 6 + .../3121-dynamic-accessor-descriptors.js.json | 6 + .../3122-dynamic-delete-descriptors.cjs.json | 6 + .../3122-dynamic-delete-descriptors.js.json | 6 + .../3122-js-async-class-methods.js.json | 6 + .../3123-destructured-global-tdz.js.json | 6 + .../3124-array-prototype-borrow.js.json | 6 + .../corpus/3125-regex-global-match.ts.json | 6 + .../corpus/3126-js-number-radix/main.ts.json | 7 + .../corpus/3127-spawn-runtime-options.ts.json | 6 + .../corpus/3128-regex-last-index.ts.json | 6 + .../corpus/3129-js-token-union/main.ts.json | 7 + .../corpus/3130-child-generic-streams.ts.json | 6 + .../corpus/3131-child-rest-listeners.js.json | 6 + ...32-child-generic-stream-completion.ts.json | 6 + .../3133-text-decoder-streaming.ts.json | 6 + .../tests/corpus/3134-fs-vectors.ts.json | 6 + .../3135-fs-file-handle-controls.ts.json | 6 + .../3136-fs-file-handle-options.ts.json | 6 + .../corpus/3137-fs-vector-callbacks.cjs.json | 6 + .../corpus/3138-array-large-storage.ts.json | 6 + ...139-regex-native-deep-alternatives.ts.json | 6 + .../corpus/3140-array-dense-access.ts.json | 6 + .../corpus/3141-map-string-key-hash.ts.json | 6 + .../corpus/3150-integer-remainder.ts.json | 6 + .../corpus/3151-array-push-writes.ts.json | 6 + .../3170-number-conversion-fast-paths.ts.json | 6 + .../3171-method-census-data-writes.ts.json | 6 + .../order-parity/tests/corpus/400-fib.ts.json | 6 + .../tests/corpus/401-mutual-recursion.ts.json | 6 + .../tests/corpus/402-string-functions.ts.json | 6 + .../tests/corpus/403-void-and-params.ts.json | 6 + .../4030-runtime-object-truthiness.ts.json | 6 + .../4031-event-emitter-long-tuples.ts.json | 6 + .../corpus/4032-inline-rc-fast-paths.ts.json | 6 + .../tests/corpus/404-rc-stress.ts.json | 6 + .../4040-adapted-function-identity.ts.json | 6 + .../4041-adapted-function-properties.ts.json | 6 + .../4042-object-is-union-subclass.ts.json | 6 + .../4043-nonnull-missing-element.ts.json | 6 + .../main.ts.json | 7 + .../4045-optional-element-projections.ts.json | 6 + .../4046-captured-parameter-values.ts.json | 6 + .../4047-captured-parameter-rebinding.ts.json | 6 + .../tests/corpus/405-params-optional.ts.json | 6 + .../tests/corpus/406-params-defaults.ts.json | 6 + .../4060-cycle-shared-instance/main.ts.json | 8 + .../corpus/4060-stack-union-reads.ts.json | 6 + .../4061-cycle-evaluation-order/main.ts.json | 9 + .../corpus/4061-nullable-ref-fields.ts.json | 6 + .../corpus/4062-cycle-tdz-read/main.ts.json | 8 + .../4063-cycle-hoisted-calls/main.ts.json | 8 + .../main.ts.json | 8 + .../4065-cycle-init-throws/main.ts.json | 8 + .../4066-cycle-top-level-tdz/main.ts.json | 8 + .../main.ts.json | 6 + .../tests/corpus/407-params-rest.ts.json | 6 + .../408-params-ctors-inheritance.ts.json | 6 + .../4080-optional-read-presence-tests.ts.json | 6 + .../corpus/4080-string-index-bounds.ts.json | 6 + .../corpus/4081-hoisted-function-tdz.ts.json | 6 + .../corpus/4081-string-index-unproven.ts.json | 6 + ...4082-hoisted-function-tdz-uncaught.ts.json | 6 + .../4083-dynamic-import-failure/main.ts.json | 7 + .../4084-record-optional-field-copies.ts.json | 6 + .../corpus/4085-generator-loop-close.ts.json | 6 + .../4086-optional-capture-defaults.ts.json | 6 + .../corpus/4088-class-static-tdz.ts.json | 6 + .../corpus/4089-class-wrapper-tdz.js.json | 6 + .../corpus/409-params-async-generics.ts.json | 6 + .../corpus/4090-computed-key-tdz.js.json | 6 + .../4091-class-evaluation-deferred.ts.json | 6 + .../tests/corpus/410-params-rc-stress.ts.json | 6 + .../4140-array-callback-split-visit.ts.json | 6 + .../main.ts.json | 9 + .../4142-array-callback-factories.ts.json | 6 + ...union-refinement-intersection-arms.ts.json | 6 + .../420-dead-strip-modules/main.ts.json | 8 + .../4290-acyclic-immutable-trees.ts.json | 6 + .../4291-acyclic-constructor-escapes.ts.json | 6 + .../4292-acyclic-readonly-bypass.ts.json | 6 + .../4293-acyclic-dynamic-writes.ts.json | 6 + .../corpus/4294-console-line-sizes.ts.json | 6 + .../4295-console-template-parts.ts.json | 6 + .../4296-console-glued-long-parts.ts.json | 6 + .../4410-inline-object-allocation.ts.json | 6 + .../corpus/4411-nullable-ref-values.ts.json | 6 + .../4412-nullable-record-values.ts.json | 6 + .../corpus/4413-cycle-old-late-death.ts.json | 6 + .../4413-nullable-null-and-undefined.ts.json | 6 + .../corpus/4414-cycle-old-weak-keys.ts.json | 6 + .../4414-nullable-string-values.ts.json | 6 + .../4415-identity-borrowed-operands.ts.json | 6 + .../4415-nullable-container-values.ts.json | 6 + .../4431-exception-pending-contexts.ts.json | 6 + .../4432-checked-downcast-failures.ts.json | 6 + .../corpus/4451-int32-field-storage.ts.json | 6 + .../4452-int32-field-dynamic-writes.ts.json | 6 + .../corpus/4453-int32-closed-locals.ts.json | 6 + .../4471-unassigned-field-reads.ts.json | 6 + .../4476-string-ascii-header-fact.ts.json | 6 + .../4477-buffer-write-ascii-runs.ts.json | 6 + .../4478-string-large-index-reads.ts.json | 6 + .../corpus/4481-array-optional-push.ts.json | 6 + ...2-instanceof-static-class-optional.ts.json | 6 + .../4483-array-splice-statement.ts.json | 6 + .../corpus/4484-array-length-reset.ts.json | 6 + .../4485-array-splice-optional-item.ts.json | 6 + .../4486-array-field-element-borrows.ts.json | 6 + ...4487-array-literal-optional-values.ts.json | 6 + .../4520-optional-guard-narrowing.ts.json | 6 + ...21-array-callback-element-presence.ts.json | 6 + .../4522-captured-parameter-lifetimes.ts.json | 6 + .../corpus/4523-array-pop-removal.ts.json | 6 + ...24-array-callback-supertype-params.ts.json | 6 + .../corpus/4541-nullable-wrap-borrows.ts.json | 6 + .../4542-preserving-call-borrows.ts.json | 6 + .../corpus/4543-walk-borrowed-locals.ts.json | 6 + .../corpus/4544-checked-cast-aliases.ts.json | 6 + .../corpus/4545-borrowed-returns.ts.json | 6 + .../4546-rebound-borrowed-params.ts.json | 6 + ...560-field-store-borrowed-receivers.ts.json | 6 + .../4561-virtual-borrowed-parameters.ts.json | 6 + .../4562-string-self-concat-move.ts.json | 6 + ...63-array-read-projection-receivers.ts.json | 6 + .../4564-literal-choice-strings.ts.json | 6 + .../corpus/4568-for-of-hole-elements.ts.json | 6 + .../4569-shorthand-missing-elements.ts.json | 6 + .../4570-map-lookup-default-record.ts.json | 6 + .../4591-weak-keys-union-records.ts.json | 6 + .../4592-cycle-const-from-import/main.ts.json | 10 + .../4593-weak-keys-empty-objects.ts.json | 6 + ...4594-union-class-field-mixed-types.ts.json | 6 + ...nion-class-field-optional-receiver.ts.json | 6 + .../4596-error-subclass-int-fields.ts.json | 6 + .../4596-tdz-nullable-forward-capture.ts.json | 6 + .../4597-callback-field-method-name.ts.json | 6 + ...4598-live-array-ref-element-access.ts.json | 6 + .../corpus/4598-map-set-clear-reuse.ts.json | 6 + .../4598-os-available-parallelism.ts.json | 6 + .../tests/corpus/4601-cycle-holders.ts.json | 6 + .../4602-constructor-escape-order.ts.json | 6 + .../corpus/4610-array-ext-dyn-refresh.ts.json | 6 + ...-optional-chain-borrowed-receivers.ts.json | 6 + .../4621-edge-preserving-callees/main.ts.json | 8 + .../4650-stale-property-narrowing.ts.json | 6 + .../corpus/4651-map-string-get-entry.ts.json | 6 + ...52-stale-closure-binding-narrowing.ts.json | 6 + .../4660-typed-rest-spread-forwarding.ts.json | 6 + .../4671-scoped-array-read-borrows.ts.json | 6 + .../4690-cycle-bypass-long-lived.ts.json | 6 + .../tests/corpus/500-array-basics.ts.json | 6 + .../tests/corpus/501-array-push-pop.ts.json | 6 + .../tests/corpus/502-array-for-of.ts.json | 6 + .../tests/corpus/503-array-functions.ts.json | 6 + .../tests/corpus/504-array-rc-stress.ts.json | 6 + .../510-array-map-filter-foreach.ts.json | 6 + .../corpus/511-array-indexof-includes.ts.json | 6 + .../corpus/512-array-join-chains.ts.json | 6 + .../513-array-methods-rc-stress.ts.json | 6 + .../corpus/514-array-find-some-every.ts.json | 6 + .../tests/corpus/515-array-flatmap.ts.json | 6 + .../tests/corpus/516-array-reduce.ts.json | 6 + .../corpus/517-array-hof-index-args.ts.json | 6 + .../tests/corpus/518-array-sort.ts.json | 6 + .../518-promise-void-union-callbacks.ts.json | 6 + .../corpus/519-array-from-length.ts.json | 6 + .../519-promise-union-await-values.ts.json | 6 + .../tests/corpus/520-map-basics.ts.json | 6 + .../tests/corpus/521-map-number-keys.ts.json | 6 + .../tests/corpus/522-map-foreach.ts.json | 6 + .../tests/corpus/523-map-ref-values.ts.json | 6 + .../tests/corpus/524-map-cycles.ts.json | 6 + .../tests/corpus/525-map-rc-stress.ts.json | 6 + .../tests/corpus/526-set-basics.ts.json | 6 + .../tests/corpus/527-set-foreach.ts.json | 6 + .../tests/corpus/528-set-seeded.ts.json | 6 + .../tests/corpus/529-map-seeded.ts.json | 6 + .../tests/corpus/530-record-arrays.ts.json | 6 + .../corpus/531-record-array-hofs.ts.json | 6 + .../532-record-arrays-rc-stress.ts.json | 6 + .../corpus/533-array-element-cycles.ts.json | 6 + .../corpus/534-record-width-subtyping.ts.json | 6 + .../tests/corpus/535-object-statics.ts.json | 6 + .../tests/corpus/536-map-seed-array.ts.json | 6 + .../tests/corpus/537-map-iter-drains.ts.json | 6 + .../tests/corpus/538-map-set-for-of.ts.json | 6 + .../tests/corpus/540-tuples-basics.ts.json | 6 + .../tests/corpus/541-ref-array-json.ts.json | 6 + .../corpus/542-union-element-arrays.ts.json | 6 + .../tests/corpus/600-closures-basic.ts.json | 6 + .../tests/corpus/601-closures-loops.ts.json | 6 + .../602-closures-identity-recursion.ts.json | 6 + .../corpus/603-closures-rc-stress.ts.json | 6 + .../tests/corpus/604-closures-for-of.ts.json | 6 + .../605-closures-forward-capture-tdz.ts.json | 6 + .../tests/corpus/700-classes-basic.ts.json | 6 + .../corpus/701-classes-composition.ts.json | 6 + .../corpus/702-classes-this-capture.ts.json | 6 + .../corpus/703-classes-rc-stress.ts.json | 6 + .../corpus/710-inheritance-basics.ts.json | 6 + .../corpus/711-inheritance-dispatch.ts.json | 6 + .../corpus/712-inheritance-instanceof.ts.json | 6 + .../corpus/713-inheritance-rc-stress.ts.json | 6 + .../tests/corpus/720-accessors-basics.ts.json | 6 + .../corpus/721-accessors-eval-order.ts.json | 6 + .../corpus/722-accessors-inheritance.ts.json | 6 + .../corpus/723-accessors-rc-stress.ts.json | 6 + .../corpus/750-cycle-closure-box.ts.json | 6 + .../corpus/751-cycle-records-mutual.ts.json | 6 + .../tests/corpus/752-cycle-classes.ts.json | 6 + .../corpus/753-cycle-owned-arrays.ts.json | 6 + .../corpus/754-cycle-external-ref.ts.json | 6 + .../corpus/755-cycle-async-promise.ts.json | 6 + .../corpus/756-cycle-inheritance.ts.json | 6 + .../corpus/757-cycle-cross-generation.ts.json | 6 + .../tests/corpus/760-any-arithmetic.ts.json | 6 + .../tests/corpus/761-any-objects.ts.json | 6 + .../tests/corpus/762-any-boundary.ts.json | 6 + .../tests/corpus/763-any-flow.ts.json | 6 + .../tests/corpus/764-any-async.ts.json | 6 + .../corpus/765-any-optional-chain.ts.json | 6 + .../corpus/766-any-union-boundary.ts.json | 6 + .../corpus/767-string-literal-keys.ts.json | 6 + .../corpus/768-any-uninitialized.ts.json | 6 + .../tests/corpus/800-switch-basics.ts.json | 6 + .../corpus/801-switch-lazy-tests.ts.json | 6 + .../tests/corpus/802-switch-loops.ts.json | 6 + .../tests/corpus/803-switch-rc-stress.ts.json | 6 + .../corpus/804-switch-braced-blocks.ts.json | 6 + .../tests/corpus/810-do-while.ts.json | 6 + .../tests/corpus/820-multi-decl.ts.json | 6 + .../corpus/830-let-uninitialized.ts.json | 6 + .../tests/corpus/900-records-basics.ts.json | 6 + .../corpus/901-records-eval-order.ts.json | 6 + .../902-records-functions-closures.ts.json | 6 + .../corpus/903-records-rc-stress.ts.json | 6 + .../904-records-optional-fields.ts.json | 6 + .../905-records-optional-rc-stress.ts.json | 6 + .../corpus/906-records-utility-types.ts.json | 6 + .../907-records-utility-generics.ts.json | 6 + .../908-records-index-signatures.ts.json | 6 + .../corpus/909-records-index-json.ts.json | 6 + .../910-records-index-rc-stress.ts.json | 6 + .../911-records-index-dot-access.ts.json | 6 + .../tests/corpus/912-unknown-slots.ts.json | 6 + .../913-records-index-iteration.ts.json | 6 + .../corpus/914-records-from-entries.ts.json | 6 + .../corpus/915-unknown-tostring-eq.ts.json | 6 + .../tests/corpus/916-unknown-bytes.ts.json | 6 + .../corpus/917-record-array-index-dot.ts.json | 6 + .../corpus/950-modules-basic/main.ts.json | 7 + .../corpus/951-modules-diamond/main.ts.json | 9 + .../corpus/952-modules-cross/main.ts.json | 8 + .../corpus/953-modules-default/main.ts.json | 9 + .../corpus/954-modules-reexport/main.ts.json | 9 + .../corpus/957-builtins-namespace.ts.json | 6 + .../tests/corpus/960-generics-basics.ts.json | 6 + .../corpus/961-generics-recursion.ts.json | 6 + .../corpus/962-generics-closures.ts.json | 6 + .../corpus/963-generics-modules/main.ts.json | 7 + .../corpus/964-generics-rc-stress.ts.json | 6 + .../tests/corpus/965-generics-async.ts.json | 6 + .../tests/corpus/965-unions-retag.ts.json | 6 + .../corpus/966-unions-retag-rc-stress.ts.json | 6 + .../corpus/967-record-field-widening.ts.json | 6 + .../tests/corpus/968-jsval-lift.ts.json | 6 + .../corpus/969-unions-arm-matrix.ts.json | 6 + .../tests/corpus/970-unions-basics.ts.json | 6 + .../tests/corpus/971-unions-switch.ts.json | 6 + .../tests/corpus/972-unions-nested.ts.json | 6 + .../tests/corpus/973-unions-rc-stress.ts.json | 6 + .../corpus/974-unions-modules/main.ts.json | 7 + .../tests/corpus/975-unions-undefined.ts.json | 6 + .../tests/corpus/976-unions-null.ts.json | 6 + .../corpus/977-unions-unit-rc-stress.ts.json | 6 + .../tests/corpus/978-unions-nullish.ts.json | 6 + .../979-unions-optional-chaining.ts.json | 6 + .../corpus/980-exceptions-basics.ts.json | 6 + .../corpus/981-exceptions-values.ts.json | 6 + .../corpus/982-exceptions-rc-stress.ts.json | 6 + .../983-exceptions-control-flow.ts.json | 6 + .../corpus/984-exceptions-finally.ts.json | 6 + .../corpus/985-exceptions-call-chains.ts.json | 6 + .../corpus/986-exceptions-uncaught.ts.json | 6 + .../987-exceptions-result-unions.ts.json | 6 + .../tests/corpus/990-process-basics.ts.json | 6 + .../tests/corpus/991-process-exit.ts.json | 6 + .../tests/corpus/992-fs-roundtrip.ts.json | 6 + .../tests/corpus/993-fs-readdir.ts.json | 6 + .../tests/corpus/994-fs-errors.ts.json | 6 + .../tests/corpus/995-fs-uncaught.ts.json | 6 + .../tests/corpus/996-fs-rc-stress.ts.json | 6 + .../tests/corpus/997-fs-modules/main.ts.json | 7 + .../tests/corpus/998-process-env.ts.json | 6 + .../corpus/abstract-property-dispatch.ts.json | 6 + .../corpus/arguments-arrow-capture.mjs.json | 6 + .../corpus/arguments-reexport/main.ts.json | 8 + .../array-argument-lifetimes-exits.ts.json | 6 + .../array-argument-lifetimes-mutation.ts.json | 6 + .../array-argument-lifetimes-strings.ts.json | 6 + .../array-argument-lifetimes-values.ts.json | 6 + .../corpus/array-buffer-conversions.js.json | 6 + .../tests/corpus/array-buffer-storage.ts.json | 6 + .../array-checked-callback-results.mjs.json | 6 + .../corpus/array-checked-constructor.js.json | 6 + .../corpus/array-concat-widening.ts.json | 6 + .../corpus/array-fill-unit-values.ts.json | 6 + .../tests/corpus/array-from-checked.js.json | 6 + .../tests/corpus/array-from-value.mjs.json | 6 + .../corpus/array-isarray-value/main.js.json | 6 + .../corpus/array-numeric-own-keys.ts.json | 6 + .../array-optional-number-write-index.ts.json | 6 + .../corpus/array-primitive-ordering.ts.json | 6 + .../corpus/array-read-helper-effects.ts.json | 6 + .../corpus/array-refined-storage.ts.json | 6 + .../tests/corpus/array-sort-runs.ts.json | 6 + .../array-sort-runtime-comparator.ts.json | 6 + .../array-sort-unknown-comparator.ts.json | 6 + .../corpus/array-storage-transitions.ts.json | 6 + .../tests/corpus/array-truncate-reuse.ts.json | 6 + .../corpus/async-backend-factory.mjs.json | 6 + .../corpus/async-local-typed-results.ts.json | 6 + .../corpus/atomics-integer-operations.ts.json | 6 + .../tests/corpus/bigint-checked-casts.ts.json | 6 + .../corpus/bigint-checked-storage.js.json | 6 + .../corpus/bigint-union-conversion.ts.json | 6 + .../corpus/boxed-error-rethrows.mjs.json | 6 + .../corpus/buffer-codec-boundaries.ts.json | 6 + .../corpus/buffer-primitive-predicate.ts.json | 6 + .../builtin-prototype-method-values.mjs.json | 6 + .../tests/corpus/byte-loop-bounds.ts.json | 6 + .../tests/corpus/byte-number-pipeline.ts.json | 6 + .../tests/corpus/byte-record-windows.ts.json | 6 + .../call-lifetimes-argument-order.ts.json | 6 + .../call-lifetimes-control-flow.ts.json | 6 + .../call-lifetimes-owned-boundaries.ts.json | 6 + .../corpus/call-lifetimes-projections.ts.json | 6 + .../call-lifetimes-union-values.ts.json | 6 + .../call-lifetimes-virtual-optionals.ts.json | 6 + .../corpus/callable-module-members.mjs.json | 6 + .../tests/corpus/callable-properties.mjs.json | 6 + .../corpus/callable-property-cycles.js.json | 6 + .../corpus/callable-reexport/main.ts.json | 8 + .../corpus/captured-class-refinement.ts.json | 6 + .../tests/corpus/catch-capture.ts.json | 6 + .../corpus/caught-class-identity.ts.json | 6 + .../corpus/caught-standalone-class.ts.json | 6 + .../corpus/caught-system-error-fields.ts.json | 6 + .../tests/corpus/checked-addition.js.json | 6 + .../tests/corpus/checked-any-addition.ts.json | 6 + .../corpus/checked-array-assignment.ts.json | 6 + .../corpus/checked-array-flat/main.ts.json | 7 + .../tests/corpus/checked-bitwise/main.js.json | 6 + .../corpus/checked-builder-cycles.js.json | 6 + .../corpus/checked-byte-storage/main.ts.json | 7 + .../corpus/checked-callback-options.ts.json | 6 + .../corpus/checked-class-descriptors.mjs.json | 6 + .../corpus/checked-class-factory.mjs.json | 6 + .../checked-collection-iterators.ts.json | 6 + .../checked-collection-symbol-methods.ts.json | 6 + .../checked-dispatch-input-lifetimes.js.json | 6 + .../corpus/checked-increment/main.js.json | 6 + .../corpus/checked-inherited-fields.ts.json | 6 + .../checked-iterator-consumption.js.json | 6 + .../corpus/checked-numeric-arithmetic.js.json | 6 + .../checked-object-module-alias.js.json | 6 + .../corpus/checked-optional-calls.mjs.json | 6 + .../corpus/checked-promise-recovery.ts.json | 6 + .../checked-proxy-callback/main.ts.json | 7 + .../corpus/checked-record-constructor.ts.json | 6 + .../corpus/checked-renderer-defaults.js.json | 6 + .../checked-rest-function-adapters.js.json | 6 + .../checked-storage-transitions.js.json | 6 + .../tests/corpus/checked-symbol-array.ts.json | 6 + .../checked-value-input-lifetimes.ts.json | 6 + .../class-accessor-returned-function.js.json | 6 + .../class-array-optional-return.ts.json | 6 + .../corpus/class-bracket-method-calls.js.json | 6 + .../tests/corpus/class-brand-overload.js.json | 6 + .../corpus/class-callback-replacement.js.json | 6 + .../corpus/class-callback-storage.ts.json | 6 + .../corpus/class-checked-composites.ts.json | 6 + .../tests/corpus/class-checked-upcast.ts.json | 6 + .../corpus/class-collection-insertion.ts.json | 6 + .../corpus/class-computed-presence.ts.json | 6 + .../corpus/class-computed-symbols.js.json | 6 + .../corpus/class-covariant-returns.ts.json | 6 + .../corpus/class-curried-factory.mjs.json | 6 + .../corpus/class-data-descriptors.js.json | 6 + .../class-factory-inherited-statics.mjs.json | 6 + .../class-factory-parameter-base.mjs.json | 6 + .../corpus/class-factory-record-base.mjs.json | 6 + .../class-factory-recursive-statics.mjs.json | 6 + .../class-factory-static-members.mjs.json | 6 + .../corpus/class-function-base/main.js.json | 7 + .../corpus/class-instance-constructor.js.json | 6 + .../corpus/class-interface-protocols.ts.json | 6 + .../class-interface-refinements.ts.json | 6 + .../tests/corpus/class-json-checked.ts.json | 6 + .../corpus/class-local-function-base.mjs.json | 6 + .../tests/corpus/class-method-spreads.ts.json | 6 + .../tests/corpus/class-narrowed-views.ts.json | 6 + .../class-property-call-values.mjs.json | 6 + .../tests/corpus/class-prototype-data.js.json | 6 + .../class-prototype-descriptor-copy.mjs.json | 6 + .../class-specialized-computed-base.mjs.json | 6 + .../tests/corpus/class-static-data.js.json | 6 + .../corpus/class-subclass-assertions.ts.json | 6 + .../class-super-surplus-spread.mjs.json | 6 + .../corpus/class-symbol-accessors.ts.json | 6 + .../tests/corpus/class-symbol-cache.mjs.json | 6 + ...class-value-constructor-exceptions.ts.json | 6 + .../closure-nullable-union-return.ts.json | 6 + .../tests/corpus/closure-union-locals.ts.json | 6 + .../corpus/collection-array-cycles.ts.json | 6 + .../corpus/collection-array-maps.ts.json | 6 + .../corpus/collection-array-missing.ts.json | 6 + .../corpus/collection-array-sets.ts.json | 6 + .../corpus/collection-copy-identities.ts.json | 6 + .../corpus/collection-data-unions.ts.json | 6 + .../collection-ingestion-mappers.ts.json | 6 + .../main.ts.json | 7 + .../collection-ingestion-references.ts.json | 6 + .../tests/corpus/collection-ingestion.ts.json | 6 + .../corpus/collection-storage-copies.ts.json | 6 + .../corpus/collection-value-keys.ts.json | 6 + .../corpus/compound-field-receivers.ts.json | 6 + .../corpus/compound-presence-guards.ts.json | 6 + .../conditional-tuple-destructuring.ts.json | 6 + .../tests/corpus/console-imports.cjs.json | 6 + .../tests/corpus/console-native-value.js.json | 6 + .../const-enum-module-cycle/main.ts.json | 9 + .../corpus/constant-callback-dispatch.ts.json | 6 + .../constant-module-globals/main.ts.json | 7 + .../corpus/constant-number-remainders.ts.json | 6 + .../contextual-array-union-write.ts.json | 6 + .../corpus/contextual-return-layouts.ts.json | 6 + .../tests/corpus/counted-loop-numbers.ts.json | 6 + .../tests/corpus/counted-loop-storage.ts.json | 6 + .../corpus/crypto-hash-optional-input.ts.json | 6 + .../cycle-generations-long-lived.ts.json | 6 + .../tests/corpus/cycle-growth-yield.ts.json | 6 + .../tests/corpus/date-checked-native.js.json | 6 + .../corpus/declared-index-spread.ts.json | 6 + .../corpus/deep-reference-teardown.ts.json | 6 + .../default-undefined-parameters.ts.json | 6 + .../corpus/deferred-field-updates.ts.json | 6 + .../corpus/deferred-registry-many.ts.json | 6 + .../corpus/derived-numeric-updates.ts.json | 6 + .../destructure-call-assignment.js.json | 6 + .../destructure-inferred-row-defaults.js.json | 6 + .../corpus/destructure-union-arrays.ts.json | 6 + .../dynamic-function-descriptors.js.json | 6 + .../tests/corpus/error-cause-writes.js.json | 6 + .../corpus/error-inherited-message.mjs.json | 6 + .../corpus/error-inherited-name.mjs.json | 6 + .../corpus/error-property-writes.mjs.json | 6 + .../corpus/error-prototype-tostring.js.json | 6 + .../tests/corpus/error-stack-frames.ts.json | 6 + .../tests/corpus/error-stack-limit.ts.json | 6 + .../corpus/error-tostring-overrides.ts.json | 6 + .../tests/corpus/error-values-inspect.ts.json | 6 + .../corpus/exact-index-round-trip.ts.json | 6 + .../corpus/expression-runtime-values.ts.json | 6 + .../tests/corpus/fiber-switch-stress.ts.json | 6 + .../corpus/fiberless-async-ordering.ts.json | 6 + .../corpus/fiberless-async-unhandled.ts.json | 6 + .../corpus/field-assignment-values.ts.json | 6 + .../tests/corpus/file-handle-values.ts.json | 6 + .../tests/corpus/file-read-storage.ts.json | 6 + .../corpus/file-url-percent-decoding.ts.json | 6 + .../tests/corpus/final-field-borrows.ts.json | 6 + .../corpus/for-multiple-bindings.ts.json | 6 + .../for-multiple-lexical-bindings.ts.json | 6 + .../corpus/for-of-checked-iterator.js.json | 6 + .../corpus/for-of-subclass-elements.ts.json | 6 + .../corpus/forward-generic-signatures.ts.json | 6 + .../corpus/fresh-array-union-layout.js.json | 6 + .../frozen-checked-dictionaries.mjs.json | 6 + .../tests/corpus/fs-native-realpath.ts.json | 6 + .../tests/corpus/fs-read-encodings.ts.json | 6 + .../tests/corpus/fs-remove-readonly.ts.json | 6 + .../fs-write-string-bytes-union.ts.json | 6 + .../corpus/function-apply-value.mjs.json | 6 + .../function-constructor-global.mjs.json | 6 + .../function-constructor-kinds/main.js.json | 7 + .../corpus/function-custom-prototype.js.json | 6 + .../corpus/function-custom-to-string.mjs.json | 6 + .../corpus/function-object-assign.js.json | 6 + .../function-own-prototype/main.js.json | 7 + .../corpus/generator-checked-protocol.ts.json | 6 + .../corpus/generator-checked-return.js.json | 6 + .../generator-custom-delegation/main.ts.json | 7 + .../generator-default-return-pattern.ts.json | 6 + .../generator-delegation-values.ts.json | 6 + .../corpus/generator-inferred-date.js.json | 6 + .../generator-mixed-checked-channels.ts.json | 6 + .../generator-untyped-consumer/main.ts.json | 7 + .../generic-base-specializations.ts.json | 6 + .../corpus/generic-binding-ownership.ts.json | 6 + .../generic-class-js-functions/main.ts.json | 7 + .../corpus/generic-class-recovery.ts.json | 6 + .../generic-namespace-factories/main.ts.json | 7 + .../generic-nullable-collections.ts.json | 6 + .../corpus/generic-pattern-bindings.ts.json | 6 + .../tests/corpus/generic-record-index.ts.json | 6 + .../tests/corpus/generic-visitor-void.ts.json | 6 + .../corpus/global-error-subclasses.ts.json | 6 + .../corpus/global-runtime-probes.js.json | 6 + .../tests/corpus/global-stored-probes.js.json | 6 + .../corpus/global-string-cache/main.js.json | 7 + .../corpus/global-symbol-cache/main.js.json | 7 + .../corpus/guarded-native-iterables.ts.json | 6 + .../tests/corpus/heap-input-aliases.ts.json | 6 + .../corpus/heap-input-collections.ts.json | 6 + .../corpus/in-array-runtime-index.ts.json | 6 + .../corpus/indexed-assignment-values.js.json | 6 + .../corpus/indexed-assignment-values.ts.json | 6 + .../indexed-element-field-reads.ts.json | 6 + .../inferred-array-assignment-values.mjs.json | 6 + .../corpus/inferred-class-default.mjs.json | 6 + .../corpus/inferred-compound-values.mjs.json | 6 + .../inferred-conditional-class.mjs.json | 6 + .../corpus/inferred-error-fields.js.json | 6 + .../corpus/inferred-map-patterns.mjs.json | 6 + .../corpus/inferred-method-override.js.json | 6 + .../inferred-partial-destructuring.mjs.json | 6 + .../inferred-primitive-properties.mjs.json | 6 + .../corpus/inferred-record-return.mjs.json | 6 + .../corpus/inferred-recursive-record.mjs.json | 6 + .../corpus/inferred-undefined-field.mjs.json | 6 + .../corpus/input-lifetime-intervals.ts.json | 6 + .../input-lifetimes-modules/main.ts.json | 8 + .../instanceof-class-record-union.ts.json | 6 + .../corpus/integer-flow-arithmetic.ts.json | 6 + .../tests/corpus/integer-loop-forms.ts.json | 6 + .../tests/corpus/integer-view-control.ts.json | 6 + .../tests/corpus/integer-view-numbers.ts.json | 6 + .../tests/corpus/integer-view-storage.ts.json | 6 + .../intl-grapheme-conformance/main.ts.json | 7 + .../tests/corpus/intl-grapheme.ts.json | 6 + .../corpus/iterator-typed-returns.ts.json | 6 + .../tests/corpus/js-abort-portable.js.json | 6 + .../tests/corpus/js-array-constructor.js.json | 6 + .../corpus/js-array-default-buffer.js.json | 6 + .../tests/corpus/js-array-iterators.js.json | 6 + .../tests/corpus/js-arrow-bind.cjs.json | 6 + .../corpus/js-buffer-callback-brand.cjs.json | 6 + .../tests/corpus/js-callable-proxy.js.json | 6 + .../corpus/js-chained-native-results.mjs.json | 6 + .../corpus/js-checked-array-iterator.js.json | 6 + .../corpus/js-checked-array-reference.js.json | 6 + .../js-checked-number-negation.mjs.json | 6 + .../corpus/js-checked-sort-result.js.json | 6 + .../corpus/js-child-error-listener.cjs.json | 6 + .../js-cjs-callable-snapshots/main.cjs.json | 7 + .../corpus/js-class-added-parameters.js.json | 6 + .../corpus/js-class-checked-overrides.js.json | 6 + .../corpus/js-class-computed-fields.js.json | 6 + .../tests/corpus/js-class-enumeration.js.json | 6 + .../js-class-field-accessor-override.js.json | 6 + .../corpus/js-class-fluent-overrides.js.json | 6 + .../js-class-late-method-values.js.json | 6 + .../corpus/js-class-member-dispatch.js.json | 6 + .../corpus/js-class-return-shapes.js.json | 6 + .../corpus/js-class-shadowed-methods.js.json | 6 + .../js-class-stored-method-receiver.js.json | 6 + .../js-class-subclass-properties.js.json | 6 + .../corpus/js-class-symbol-spread.cjs.json | 6 + .../js-computed-prototype-additions.js.json | 6 + .../js-constructor-returned-callable.js.json | 6 + .../corpus/js-constructor-spread.js.json | 6 + .../tests/corpus/js-dataview-dispatch.js.json | 6 + .../tests/corpus/js-declared-fields.cjs.json | 6 + .../js-default-listener-arguments.cjs.json | 6 + .../corpus/js-default-options/main.ts.json | 8 + .../js-deferred-field-initializers.js.json | 6 + .../js-deferred-registry-effects.js.json | 6 + .../js-derived-constructor-hoisting.js.json | 6 + .../corpus/js-dormant-array-write.js.json | 6 + .../tests/corpus/js-dormant-overrides.js.json | 6 + .../tests/corpus/js-expando-records.js.json | 6 + .../corpus/js-implicit-call-results.js.json | 6 + .../js-inferred-callback-exports/main.js.json | 8 + .../js-inferred-class-array-return.js.json | 6 + .../corpus/js-inferred-object-values.js.json | 6 + .../corpus/js-inherited-field-storage.js.json | 6 + .../corpus/js-inherited-parameter-abi.js.json | 6 + .../tests/corpus/js-iterable-spread.js.json | 6 + .../js-loose-dynamic-primitives.js.json | 6 + .../tests/corpus/js-map-object-seeds.js.json | 6 + .../tests/corpus/js-member-increment.js.json | 6 + .../corpus/js-module-function-values.js.json | 6 + .../corpus/js-mutable-null-members.js.json | 6 + .../js-nested-native-descriptors.js.json | 6 + .../corpus/js-normalize-dispatch.js.json | 6 + .../js-nullish-inherited-fields.mjs.json | 6 + .../corpus/js-object-receiver-storage.js.json | 6 + .../js-object-returning-constructors.mjs.json | 6 + .../corpus/js-object-shared-arrays.js.json | 6 + .../corpus/js-omitted-typed-arguments.js.json | 6 + .../corpus/js-open-binding-writes.js.json | 6 + .../corpus/js-optional-class-fields.js.json | 6 + .../corpus/js-optional-member-call.js.json | 6 + .../js-primitive-union-addition.js.json | 6 + .../corpus/js-promise-all-values.js.json | 6 + .../corpus/js-promise-catch-handler.js.json | 6 + .../corpus/js-promise-finally-order.js.json | 6 + .../js-promise-pending-reactions.js.json | 6 + .../corpus/js-prototype-host-boundary.js.json | 6 + .../tests/corpus/js-reflect-receivers.js.json | 6 + .../corpus/js-regex-record-captures.js.json | 6 + .../tests/corpus/js-scalar-iterables.js.json | 6 + .../corpus/js-shared-method-dispatch.js.json | 6 + .../js-specialized-field-method.js.json | 6 + .../tests/corpus/js-static-accessors.js.json | 6 + .../corpus/js-static-method-values.js.json | 6 + .../corpus/js-static-registries.cjs.json | 6 + .../js-super-accessor-initialization.js.json | 6 + .../js-uninitialized-native-fields.js.json | 6 + .../corpus/json-guarded-map-values.ts.json | 6 + .../tests/corpus/json-output-bulk.ts.json | 6 + .../corpus/json-runtime-options.mjs.json | 6 + .../tests/corpus/json-stringify-value.js.json | 6 + .../corpus/json-typed-parse-direct.ts.json | 6 + .../corpus/literal-switch-dispatch.ts.json | 6 + .../live-reference-shared-converters.ts.json | 6 + .../llvm-read-receiver-lifetime.ts.json | 6 + .../corpus/local-class-call-spreads.js.json | 6 + .../corpus/local-class-declaration.ts.json | 6 + .../corpus/local-class-evaluation.ts.json | 6 + .../corpus/local-class-inheritance.ts.json | 6 + .../corpus/local-class-lifetimes.ts.json | 6 + .../corpus/local-class-namespace/main.js.json | 7 + .../corpus/local-class-prototype-data.js.json | 6 + .../corpus/local-class-specialization.js.json | 6 + .../tests/corpus/local-class-unknown.ts.json | 6 + .../tests/corpus/local-class-values.ts.json | 6 + .../tests/corpus/local-union-storage.ts.json | 6 + .../corpus/locale-compare-root-order.ts.json | 6 + .../corpus/logical-assignment-dynamic.js.json | 6 + .../corpus/logical-assignment-values.ts.json | 6 + .../logical-runtime-optional-record.ts.json | 6 + .../corpus/loop-reference-lifetimes.ts.json | 6 + .../corpus/map-checked-boundary/main.ts.json | 7 + .../tests/corpus/map-checked-seed.js.json | 6 + .../corpus/map-number-keys-dense.ts.json | 6 + .../corpus/map-read-lifetimes-exits.ts.json | 6 + .../tests/corpus/map-read-lifetimes.ts.json | 6 + .../corpus/map-seeds-and-spreads.ts.json | 6 + .../corpus/map-typed-array-values.ts.json | 6 + .../tests/corpus/math-function-values.js.json | 6 + .../missing-read-lambda-results.ts.json | 6 + .../missing-read-narrowed-storage.ts.json | 6 + .../missing-read-number-conversions.ts.json | 6 + .../tests/corpus/module-byte-loops.ts.json | 6 + .../module-fallback-functions/main.js.json | 7 + .../corpus/narrowed-nullish-values.ts.json | 6 + .../native-array-borrowed-find-last.js.json | 6 + .../native-array-borrowed-slice.js.json | 6 + .../native-array-copying-methods.js.json | 6 + .../native-array-fill-copywithin.js.json | 6 + .../corpus/native-array-frozen-noops.js.json | 6 + .../native-array-index-boundaries.js.json | 6 + .../corpus/native-array-integrity.js.json | 6 + .../tests/corpus/native-array-length.js.json | 6 + .../native-array-named-properties.js.json | 6 + .../native-array-prototype/main.js.json | 6 + .../native-array-read-lifetimes.ts.json | 6 + .../native-array-reduce-find-last.js.json | 6 + .../native-array-search-from-index.js.json | 6 + .../native-array-splice-coercion.js.json | 6 + .../corpus/native-array-splice-flat.js.json | 6 + .../corpus/native-buffer-coercion.js.json | 6 + .../corpus/native-callback-dispatch.ts.json | 6 + .../native-class-array-boundaries.ts.json | 6 + .../tests/corpus/native-class-cache.js.json | 6 + .../corpus/native-class-properties.cjs.json | 6 + .../native-class-property-cycles.cjs.json | 6 + .../native-class-property-order.cjs.json | 6 + .../native-class-type-predicates.ts.json | 6 + .../corpus/native-factory-records.js.json | 6 + .../tests/corpus/native-method-values.js.json | 6 + .../tests/corpus/native-method-values.ts.json | 6 + .../corpus/native-object-descriptors.js.json | 6 + .../native-object-for-in-minimal.js.json | 6 + .../native-object-property-attributes.js.json | 6 + .../corpus/native-object-prototype.js.json | 6 + .../corpus/native-property-names.ts.json | 6 + .../tests/corpus/native-proxy-env.js.json | 6 + .../corpus/native-worker-arena-reuse.ts.json | 6 + .../native-worker-bounded-errors.ts.json | 6 + .../native-worker-buffer-consumers.ts.json | 6 + .../corpus/native-worker-cancel-hot.ts.json | 6 + .../corpus/native-worker-class-fields.ts.json | 6 + .../corpus/native-worker-clone-errors.ts.json | 6 + .../corpus/native-worker-commonjs.cjs.json | 6 + .../native-worker-delayed-messages.ts.json | 6 + .../corpus/native-worker-environment.ts.json | 6 + .../tests/corpus/native-worker-error.ts.json | 6 + .../native-worker-exception-state.ts.json | 6 + .../native-worker-exit-listeners.ts.json | 6 + .../tests/corpus/native-worker-io.ts.json | 6 + .../native-worker-loop-cancellation.ts.json | 6 + .../native-worker-message-graphs.ts.json | 6 + .../corpus/native-worker-messages.ts.json | 6 + .../native-worker-poll-exceptions.ts.json | 6 + .../native-worker-port-lifetime.ts.json | 6 + .../corpus/native-worker-process-exit.ts.json | 6 + .../native-worker-publish-classes.ts.json | 6 + .../native-worker-publish-refusals.ts.json | 6 + .../native-worker-published-graphs.ts.json | 6 + .../corpus/native-worker-references.ts.json | 6 + .../corpus/native-worker-roots/main.ts.json | 6 + .../corpus/native-worker-shared-views.ts.json | 6 + .../native-worker-stack-overflow.ts.json | 6 + ...e-worker-terminate-exception-state.ts.json | 6 + .../native-worker-terminate-loop.ts.json | 6 + .../native-worker-terminate-recursion.ts.json | 6 + .../native-worker-terminate-suspended.ts.json | 6 + ...tive-worker-terminate-tested-loops.ts.json | 6 + .../native-worker-terminate-wait.ts.json | 6 + .../corpus/native-worker-typed-arrays.ts.json | 6 + .../tests/corpus/nested-map-cycles.ts.json | 6 + .../tests/corpus/nested-map-values.ts.json | 6 + .../corpus/never-returning-calls.ts.json | 6 + .../corpus/next-tick-commonjs-entry.cjs.json | 6 + .../node24-buffer-encoding-errors.ts.json | 6 + .../corpus/node24-buffer-encoding.ts.json | 6 + .../corpus/node24-crypto-kdf-errors.ts.json | 6 + .../corpus/node24-crypto-kdf-options.ts.json | 6 + .../tests/corpus/node24-crypto-kdf.ts.json | 6 + .../tests/corpus/node24-crypto-sha2.ts.json | 6 + .../node24-deep-equality-properties.js.json | 6 + .../corpus/node24-deep-equality.cjs.json | 6 + .../tests/corpus/node24-deep-equality.ts.json | 6 + .../corpus/node24-env-files-errors.ts.json | 6 + .../tests/corpus/node24-env-files.ts.json | 6 + .../tests/corpus/node24-env-imports.cjs.json | 6 + .../corpus/node24-env-parse-errors.ts.json | 6 + .../tests/corpus/node24-env-parse.ts.json | 6 + .../corpus/node24-esm-metadata/main.mjs.json | 7 + .../corpus/node24-file-url-buffer.ts.json | 6 + .../corpus/node24-file-url-errors.js.json | 6 + .../corpus/node24-file-url-options.ts.json | 6 + .../corpus/node24-fs-links-callbacks.cjs.json | 6 + .../corpus/node24-fs-links-errors.cjs.json | 6 + .../corpus/node24-fs-links-options.cjs.json | 6 + .../node24-fs-links-promise-errors.cjs.json | 6 + .../corpus/node24-fs-links-promises.ts.json | 6 + .../tests/corpus/node24-fs-links.ts.json | 6 + .../node24-fs-statfs-callbacks.cjs.json | 6 + .../corpus/node24-fs-statfs-errors.cjs.json | 6 + .../corpus/node24-fs-statfs-options.cjs.json | 6 + .../tests/corpus/node24-fs-statfs.ts.json | 6 + .../node24-fs-timestamps-callbacks.cjs.json | 6 + .../node24-fs-timestamps-errors.cjs.json | 6 + .../node24-fs-timestamps-promises.ts.json | 6 + .../node24-fs-timestamps-symlinks.ts.json | 6 + .../tests/corpus/node24-fs-timestamps.ts.json | 6 + ...ode24-no-error-assertions-coercion.js.json | 6 + .../node24-no-error-assertions.cjs.json | 6 + .../corpus/node24-no-error-assertions.ts.json | 6 + .../tests/corpus/node24-parseargs.js.json | 6 + .../corpus/node24-string-decoder.ts.json | 6 + .../node24-style-text-environment.js.json | 6 + .../node24-style-text-validation.js.json | 6 + .../tests/corpus/node24-style-text.cjs.json | 6 + .../tests/corpus/node24-style-text.ts.json | 6 + .../node24-system-error-validation.js.json | 6 + .../corpus/node24-system-errors.cjs.json | 6 + .../tests/corpus/node24-system-errors.ts.json | 6 + .../node24-text-codec-properties.ts.json | 6 + .../corpus/node24-text-encode-into.ts.json | 6 + .../node24-text-utilities-coercion.js.json | 6 + .../node24-text-utilities-validation.js.json | 6 + .../corpus/node24-text-utilities.cjs.json | 6 + .../corpus/node24-text-utilities.ts.json | 6 + .../node24-url-authority-coercion.js.json | 6 + .../tests/corpus/node24-url-authority.ts.json | 6 + .../tests/corpus/node24-url-factories.ts.json | 6 + .../corpus/node24-url-factory-errors.ts.json | 6 + .../node24-url-mutation-coercion.js.json | 6 + .../tests/corpus/node24-url-mutation.ts.json | 6 + .../tests/corpus/node24-util-types.cjs.json | 6 + .../tests/corpus/node24-util-types.js.json | 6 + .../tests/corpus/node24-util-types.ts.json | 6 + .../corpus/non-null-class-iteration.ts.json | 6 + .../corpus/nonnull-element-arguments.ts.json | 6 + .../nonnull-forwarded-class-values.ts.json | 6 + .../corpus/nullable-object-extension.mjs.json | 6 + .../nullish-asserted-class-arms.ts.json | 6 + .../corpus/nullish-assignment-values.ts.json | 6 + .../tests/corpus/nullish-long-chain.ts.json | 6 + .../tests/corpus/number-parse-statics.ts.json | 6 + .../corpus/number-predicates-unknown.ts.json | 6 + .../numeric-call-specialization.ts.json | 6 + .../object-enumeration-array-reads.ts.json | 6 + .../object-from-checked-entries.js.json | 6 + .../corpus/object-inherited-to-string.js.json | 6 + .../tests/corpus/object-key-indexes.js.json | 6 + .../corpus/object-prototype-identity.mjs.json | 6 + .../tests/corpus/object-reexport/main.js.json | 9 + .../corpus/object-spread-computed.ts.json | 6 + .../tests/corpus/opentui-byte-queue.js.json | 6 + .../corpus/optional-callback-arity.ts.json | 6 + .../tests/corpus/optional-class-flows.ts.json | 6 + .../corpus/optional-element-defaults.ts.json | 6 + .../corpus/optional-flag-comparisons.ts.json | 6 + .../corpus/optional-native-callables.js.json | 6 + .../optional-node-list-iteration.ts.json | 6 + .../corpus/optional-string-index/main.ts.json | 6 + .../corpus/path-to-file-url-options.ts.json | 6 + .../tests/corpus/performance-presence.ts.json | 6 + ...primitive-and-function-descriptors.js.json | 6 + .../corpus/primitive-union-string.ts.json | 6 + .../corpus/process-builtin-values.js.json | 6 + .../corpus/process-env-computed-keys.js.json | 6 + .../tests/corpus/process-hrtime.js.json | 6 + .../corpus/process-named-signals.cjs.json | 6 + .../process-uncaught-handler-throws.cjs.json | 6 + .../corpus/process-uncaught-loop.cjs.json | 6 + .../corpus/process-uncaught-module.mjs.json | 6 + .../corpus/process-uncaught-monitor.cjs.json | 6 + .../process-uncaught-rejection.cjs.json | 6 + .../corpus/process-uncaught-sync.cjs.json | 6 + .../tests/corpus/process-version-pin.ts.json | 6 + .../corpus/process-versions-storage.ts.json | 6 + .../projected-collection-lifetimes.ts.json | 6 + .../corpus/promise-checked-rejections.ts.json | 6 + .../tests/corpus/promise-resolve-void.ts.json | 6 + .../prototype-method-overrides.mjs.json | 6 + .../prototype-named-data-records.ts.json | 6 + .../corpus/record-field-presence.ts.json | 6 + .../tests/corpus/record-key-order.ts.json | 6 + .../record-optional-json-presence.ts.json | 6 + .../corpus/record-presence-copies.ts.json | 6 + .../record-presence-delete-json.ts.json | 6 + .../record-unchecked-read-presence.ts.json | 6 + .../corpus/record-unknown-values.ts.json | 6 + .../tests/corpus/reflect-own-keys.mjs.json | 6 + .../corpus/reflect-record-union-keys.mjs.json | 6 + .../corpus/reflect-typed-record-keys.ts.json | 6 + .../regex-callback-replacements.ts.json | 6 + .../corpus/regex-callback-values.js.json | 6 + .../tests/corpus/regex-checked-casts.ts.json | 6 + .../corpus/regex-checked-storage.js.json | 6 + .../corpus/regex-exec-long-subject.ts.json | 6 + .../corpus/regex-input-lifetimes.ts.json | 6 + .../tests/corpus/regex-native-matcher.ts.json | 6 + .../corpus/regex-optional-captures.ts.json | 6 + .../corpus/regex-optional-templates.ts.json | 6 + .../tests/corpus/regex-split-captures.ts.json | 6 + .../tests/corpus/regex-text-paths.ts.json | 6 + .../corpus/regexp-constructor-repeat.ts.json | 6 + .../regexp-optional-constructor.ts.json | 6 + .../corpus/regexp-string-coercion.js.json | 6 + .../renderer-export-dictionaries.js.json | 6 + .../tests/corpus/renderer-null-state.js.json | 6 + .../corpus/renderer-specializations.js.json | 6 + .../repeat-and-typed-read-errors.ts.json | 6 + .../rest-optional-array-arguments.ts.json | 6 + .../corpus/rest-optional-elements.ts.json | 6 + .../return-void-through-finally.ts.json | 6 + .../runtime-optional-string-flows.ts.json | 6 + .../tests/corpus/scalar-string-slices.ts.json | 6 + .../tests/corpus/set-checked-methods.js.json | 6 + .../tests/corpus/set-checked-storage.ts.json | 6 + .../set-iterator-seed-references.ts.json | 6 + .../tests/corpus/set-iterator-seeds.ts.json | 6 + .../tests/corpus/set-optional-seeds.ts.json | 6 + .../small-collection-transitions.ts.json | 6 + .../corpus/stack-depth-async-bodies.ts.json | 6 + .../tests/corpus/stack-overflow-async.ts.json | 6 + .../corpus/stack-overflow-caught.ts.json | 6 + .../corpus/stack-overflow-finally.ts.json | 6 + .../corpus/stack-overflow-shapes.ts.json | 6 + .../corpus/stack-overflow-uncaught.ts.json | 6 + .../corpus/static-field-updates/main.ts.json | 7 + .../corpus/static-method-receivers.ts.json | 6 + .../tests/corpus/stdio-values.mjs.json | 6 + .../tests/corpus/stdio-write-errors.mjs.json | 6 + .../corpus/stdio-write-overrides.mjs.json | 6 + .../corpus/stored-native-builtins.js.json | 6 + .../corpus/stored-object-helpers.js.json | 6 + .../tests/corpus/string-code-points.ts.json | 6 + .../corpus/string-concat-number-parts.ts.json | 6 + .../corpus/string-construction-order.ts.json | 6 + .../string-lifetimes-boundaries.ts.json | 6 + .../string-lifetimes-evaluation.ts.json | 6 + .../corpus/string-lifetimes-iteration.ts.json | 6 + .../string-lifetimes-operations.ts.json | 6 + .../tests/corpus/string-normalize.ts.json | 6 + .../corpus/string-pattern-replacement.ts.json | 6 + .../string-split-checked-separator.mjs.json | 6 + .../corpus/string-split-traversal.ts.json | 6 + .../structural-class-properties.ts.json | 6 + .../corpus/structured-text-boundaries.js.json | 6 + .../corpus/structured-text-storage.ts.json | 6 + .../corpus/switch-integer-dispatch.ts.json | 6 + .../symbol-checked-boundary/main.ts.json | 7 + .../tests/corpus/symbol-class-fields.ts.json | 6 + .../corpus/symbol-class-fields/main.cjs.json | 7 + .../corpus/symbol-class-methods/main.ts.json | 7 + .../symbol-fields-deferred-factory.ts.json | 6 + .../corpus/symbol-fields-inferred.js.json | 6 + .../symbol-object-properties/main.js.json | 6 + .../synchronous-callback-lifetimes.ts.json | 6 + .../corpus/terminal-stream-properties.ts.json | 6 + .../corpus/text-codec-values/main.ts.json | 8 + .../tests/corpus/text-codec-var.ts.json | 6 + .../text-encode-into-boundaries.ts.json | 6 + .../tests/corpus/timers-clear-many.ts.json | 6 + .../corpus/tuple-and-string-search.ts.json | 6 + .../tests/corpus/tuple-array-union.ts.json | 6 + .../corpus/tuple-callback-visitation.ts.json | 6 + .../corpus/tuple-forof-visitation.ts.json | 6 + .../typed-array-bulk-conversion.mjs.json | 6 + .../tests/corpus/typed-array-byte-io.js.json | 6 + .../corpus/typed-array-checked-index.js.json | 6 + .../typed-array-constructor-alias.ts.json | 6 + .../typed-array-constructor-identity.js.json | 6 + .../typed-array-constructor-union.ts.json | 6 + .../typed-array-constructor-values.mjs.json | 6 + .../typed-array-dynamic-methods.js.json | 6 + .../corpus/typed-array-integer-widths.ts.json | 6 + .../typed-array-nan-coded-reads.ts.json | 6 + .../corpus/typed-array-numeric-import.ts.json | 6 + .../corpus/typed-array-present-reads.ts.json | 6 + .../typed-array-reversed-storage.ts.json | 6 + .../tests/corpus/typed-array-unknown.ts.json | 6 + ...ped-collection-iterator-references.ts.json | 6 + .../corpus/typed-collection-iterators.ts.json | 6 + .../typed-collection-views/main.ts.json | 7 + .../corpus/typed-index-arguments.ts.json | 6 + .../corpus/typed-prototype-methods.ts.json | 6 + .../tests/corpus/typed-rest-callables.ts.json | 6 + .../corpus/typed-rest-filtered-return.ts.json | 6 + .../corpus/typedarray-native-inputs.js.json | 6 + .../corpus/typeof-checked-comparison.js.json | 6 + .../corpus/uint8array-sort-domains.ts.json | 6 + .../tests/corpus/unicode-case-paths.ts.json | 6 + .../tests/corpus/unicode-process-argv.ts.json | 6 + .../corpus/union-discriminant-width.ts.json | 6 + ...union-literal-scalar-discriminants.ts.json | 6 + .../union-literal-slot-conversion.ts.json | 6 + .../union-nested-layout-discriminant.ts.json | 6 + .../union-optional-semantic-identity.ts.json | 6 + .../tests/corpus/union-record-clone.ts.json | 6 + .../union-record-structural-copy.ts.json | 6 + .../corpus/union-reference-comparison.ts.json | 6 + .../tests/corpus/unknown-array-holes.ts.json | 6 + .../tests/corpus/unknown-collections.ts.json | 6 + .../corpus/unknown-object-enumeration.ts.json | 6 + .../tests/corpus/unknown-record-views.ts.json | 6 + .../tests/corpus/url-runtime-base.ts.json | 6 + .../tests/corpus/utf8-span-decoding.ts.json | 6 + .../util-parseargs-wrapped/main.ts.json | 6 + .../corpus/weak-map-array-buffer.ts.json | 6 + .../tests/corpus/weak-map-fresh-array.js.json | 6 + .../tests/corpus/weak-map-native.js.json | 6 + .../corpus/weak-native-class-identity.ts.json | 6 + .../tests/corpus/weak-set-native.js.json | 6 + .../worker-class-instance-clone.ts.json | 6 + .../tests/diagnostics/accessors.ts.json | 6 + .../tests/diagnostics/any-unit-exit.ts.json | 6 + .../tests/diagnostics/any.ts.json | 6 + .../tests/diagnostics/arrow-bind.ts.json | 6 + .../tests/diagnostics/assert-fences.ts.json | 6 + .../async-iterator-handles.ts.json | 6 + .../tests/diagnostics/bigint-fences.ts.json | 16 + .../blocked-binding-cascade.ts.json | 6 + .../tests/diagnostics/catch-bindings.ts.json | 6 + .../checker-panic-infinity.ts.json | 6 + .../diagnostics/checker-panic-tuple.ts.json | 6 + .../tests/diagnostics/child-process.ts.json | 6 + .../main.js.json | 19 + .../cjs-module-mutation/main.ts.json | 6 + .../cjs-require-cycle/main.js.json | 20 + .../cjs-require-esm-type-link/main.js.json | 19 + .../diagnostics/cjs-require-tdz/main.js.json | 17 + .../diagnostics/class-decorators.ts.json | 6 + .../class-interface-refinements.ts.json | 6 + .../class-prototype-reflection.ts.json | 6 + .../tests/diagnostics/class-values.ts.json | 6 + .../collection-iterator-helpers.ts.json | 6 + .../diagnostics/collection-views.ts.json | 6 + .../diagnostics/component-fences.ts.json | 6 + .../tests/diagnostics/comptime.ts.json | 6 + .../tests/diagnostics/create-require.ts.json | 6 + .../cycle-class-early/main.ts.json | 8 + .../cycle-default-export/main.ts.json | 20 + .../cycle-namespace-import/main.ts.json | 20 + .../diagnostics/cycle-var-early/main.ts.json | 8 + .../tests/diagnostics/dataview.ts.json | 6 + .../tests/diagnostics/date-formatters.ts.json | 6 + .../diagnostics/date-union-fences.ts.json | 6 + .../diagnostics/deep-binary-nesting.ts.json | 6 + .../deep-nesting-preflight.ts.json | 6 + .../tests/diagnostics/default-export.ts.json | 27 + .../deferred-class-binding/main.ts.json | 7 + .../deferred-class-receiver/main.ts.json | 7 + .../tests/diagnostics/delete-fences.ts.json | 6 + .../diagnostics/destructuring-fences.ts.json | 6 + .../diagnostics/dynamic-import-static.ts.json | 6 + .../diagnostics/dynamic-import/main.ts.json | 7 + .../dynamic-representable-types.ts.json | 6 + .../tests/diagnostics/dynamic-surface.ts.json | 6 + .../diagnostics/ee-computed-internal.ts.json | 6 + .../diagnostics/ee-computed-listeners.ts.json | 6 + .../ee-computed-stream-internal.ts.json | 6 + .../ee-computed-unrestricted.ts.json | 6 + .../diagnostics/ee-emit-override.ts.json | 6 + .../tests/diagnostics/enums.ts.json | 6 + .../tests/diagnostics/es2025-fences.ts.json | 6 + .../esm-syntax-commonjs/main.js.json | 18 + .../tests/diagnostics/exceptions.ts.json | 6 + .../tests/diagnostics/fetch-static.ts.json | 6 + .../tests/diagnostics/filter-narrow.ts.json | 6 + .../filter-void-predicate-dyn.ts.json | 6 + .../filter-void-predicate-dynamic.ts.json | 6 + .../filter-void-predicate-island.ts.json | 6 + .../diagnostics/filter-void-predicate.ts.json | 6 + .../tests/diagnostics/function-forms.ts.json | 6 + .../tests/diagnostics/function-limits.ts.json | 6 + .../generator-method-overrides.ts.json | 6 + .../tests/diagnostics/generic-methods.ts.json | 6 + .../generic-signature-values.ts.json | 6 + .../generic-value-bindings.ts.json | 6 + .../tests/diagnostics/generics.ts.json | 6 + .../tests/diagnostics/http2-module.ts.json | 6 + .../http2-response-trailers.ts.json | 6 + .../identity-collection-keys.ts.json | 6 + .../import-defer-type/main.ts.json | 61 + .../diagnostics/import-defer/main.ts.json | 6 + .../diagnostics/import-equals-require.ts.json | 26 + .../diagnostics/import-forms/main.ts.json | 51 + .../diagnostics/import-meta-bare.ts.json | 6 + .../diagnostics/import-meta-computed.ts.json | 6 + .../import-meta-destructure.ts.json | 6 + .../diagnostics/import-meta-rest.ts.json | 6 + .../diagnostics/import-meta-write.ts.json | 6 + .../tests/diagnostics/imports.ts.json | 27 + .../index-signature-values.ts.json | 6 + .../tests/diagnostics/inheritance.ts.json | 6 + .../diagnostics/intersection-values.ts.json | 6 + .../tests/diagnostics/intl-segmenter.ts.json | 6 + .../tests/diagnostics/intl.ts.json | 6 + .../invalid-package-config/main.ts.json | 18 + .../diagnostics/island-boundary-slots.ts.json | 6 + .../tests/diagnostics/island.ts.json | 6 + .../diagnostics/iterator-slot-fences.ts.json | 6 + .../diagnostics/jsdoc-import-require.js.json | 25 + .../tests/diagnostics/json-dyn.ts.json | 6 + .../json-module-comment/main.ts.json | 6 + .../diagnostics/json-modules/main.ts.json | 18 + .../tests/diagnostics/json-shape/main.ts.json | 6 + .../local-class-boundaries.ts.json | 6 + .../local-require-binding-esm.js.json | 17 + .../tests/diagnostics/maps-surface.ts.json | 6 + .../tests/diagnostics/maps.ts.json | 6 + .../merged-namespace-collect-probe.ts.json | 6 + .../tests/diagnostics/mixed-compare.ts.json | 25 + .../tests/diagnostics/mixins.ts.json | 6 + .../diagnostics/module-out-of-scope.ts.json | 127 + .../module-resolution-introspection.ts.json | 6 + .../tests/diagnostics/multiple-errors.ts.json | 6 + .../tests/diagnostics/namespaces.ts.json | 6 + .../new-target-field-initializer.ts.json | 6 + .../no-error-assertion-fences.ts.json | 6 + .../diagnostics/node-fallback-fence.ts.json | 6 + .../diagnostics/npm-imports/main.ts.json | 6 + .../diagnostics/ns-import-object/main.ts.json | 7 + .../nullish-class-defaults.ts.json | 6 + .../diagnostics/object-create-fences.ts.json | 6 + .../tests/diagnostics/optional-fields.ts.json | 6 + .../tests/diagnostics/options-record.ts.json | 6 + .../tests/diagnostics/outside-world.ts.json | 25 + .../tests/diagnostics/overload-fences.ts.json | 6 + .../overloaded-function-values.ts.json | 6 + .../pkg-import-fences/main.ts.json | 40 + .../tests/diagnostics/private-members.ts.json | 6 + .../diagnostics/promise-all-fences.ts.json | 6 + .../tests/diagnostics/record-width.ts.json | 6 + .../tests/diagnostics/regex.ts.json | 6 + .../retained-generic-rest-order.ts.json | 6 + .../runtime-optional-capture-chain.ts.json | 6 + .../runtime-optional-refined-union.ts.json | 6 + .../self-returning-function.ts.json | 6 + .../tests/diagnostics/sets.ts.json | 6 + .../tests/diagnostics/spi-off/main.ts.json | 6 + .../tests/diagnostics/spread-fences.ts.json | 6 + .../spread-runtime-optional.ts.json | 6 + .../tests/diagnostics/statements.ts.json | 6 + .../tests/diagnostics/static-blocks.ts.json | 6 + .../tests/diagnostics/stdlib-fence.ts.json | 6 + .../tests/diagnostics/stdlib.ts.json | 6 + .../diagnostics/text-codec-value.ts.json | 6 + .../diagnostics/text-decoder-label.ts.json | 6 + .../top-level-await-commonjs/main.ts.json | 18 + ...ait-implicit-module-nested-require.js.json | 17 + .../top-level-await-module-leak/main.ts.json | 18 + .../tests/diagnostics/tuples.ts.json | 6 + .../diagnostics/unassigned-fields.ts.json | 6 + .../union-clone-override-width.ts.json | 6 + .../tests/diagnostics/unions.ts.json | 6 + .../unrelated-class-assertion.ts.json | 6 + .../url-mutation-object-plus.ts.json | 6 + .../diagnostics/url-mutation-operator.ts.json | 6 + .../url-mutation-runtime-key.ts.json | 6 + .../tests/diagnostics/utility-types.ts.json | 6 + .../tests/diagnostics/var-fences.ts.json | 6 + .../fixtures/node-types/argv-env.ts.json | 6 + .../node-types/child-execfile.ts.json | 6 + .../node-types/child-stdin-fences.ts.json | 6 + .../fixtures/node-types/child-stdin.ts.json | 6 + .../fixtures/node-types/crypto-kdf.ts.json | 6 + .../fixtures/node-types/deep-equality.ts.json | 6 + .../fixtures/node-types/env-files.ts.json | 6 + .../tests/fixtures/node-types/fenced.ts.json | 6 + .../fixtures/node-types/fetch-static.ts.json | 6 + .../node-types/file-url-conversion.ts.json | 6 + .../fixtures/node-types/fs-links.ts.json | 6 + .../fixtures/node-types/fs-statfs.ts.json | 6 + .../fixtures/node-types/fs-timestamps.ts.json | 6 + .../fixtures/node-types/import-fences.ts.json | 18 + .../node-types/no-error-assertions.ts.json | 6 + .../tests/fixtures/node-types/path-os.ts.json | 6 + .../node-types/stream-capture.ts.json | 6 + .../fixtures/node-types/style-text.ts.json | 6 + .../fixtures/node-types/system-errors.ts.json | 6 + .../node-types/terminal-error-fields.ts.json | 6 + .../fixtures/node-types/text-encoding.ts.json | 6 + .../node-types/text-utilities.ts.json | 6 + .../fixtures/node-types/url-factories.ts.json | 6 + .../fixtures/node-types/url-getters.ts.json | 6 + .../fixtures/node-types/url-mutation.ts.json | 6 + .../fixtures/node-types/util-types.ts.json | 6 + .../npm/cases/2465-getter-table/main.ts.json | 16 + .../npm/cases/2466-getter-star/main.ts.json | 6 + .../npm/cases/2467-star-barrel/main.ts.json | 6 + .../2468-defineprop-exports/main.ts.json | 6 + .../cases/2469-bundle-offender/main.ts.json | 6 + .../cases/2556-toesm-external/main.ts.json | 6 + .../npm/cases/2557-toesm-drift/main.ts.json | 6 + .../npm/cases/abandoned-handles/main.ts.json | 6 + .../npm/cases/any-chaining/main.ts.json | 6 + .../npm/cases/assert-shims/main.ts.json | 6 + .../npm/cases/buffer-shims/main.ts.json | 6 + .../npm/cases/builtin-shims/main.ts.json | 6 + .../npm/cases/bytes-exit/main.ts.json | 6 + .../fixtures/npm/cases/callbacks/main.ts.json | 6 + .../fixtures/npm/cases/chain/main.ts.json | 6 + .../npm/cases/cjs-esm-named/main.ts.json | 6 + .../npm/cases/cjs-lexer-aligned/main.ts.json | 6 + .../cases/cjs-lexer-invisible/main.ts.json | 6 + .../fixtures/npm/cases/cjs-named/main.ts.json | 6 + .../npm/cases/class-construct/main.ts.json | 6 + .../npm/cases/create-require/main.ts.json | 6 + .../npm/cases/crypto-shims/main.ts.json | 6 + .../fixtures/npm/cases/dotfolder/main.ts.json | 6 + .../npm/cases/dual-entry/main.ts.json | 6 + .../npm/cases/dual-package-kinds/main.ts.json | 6 + .../cases/dynamic-import-local/main.ts.json | 6 + .../npm/cases/dynamic-import/main.ts.json | 6 + .../npm/cases/esbuild-require/main.ts.json | 6 + .../npm/cases/esm-entries/main.ts.json | 6 + .../cases/esm-missing-default/main.ts.json | 6 + .../npm/cases/esm-missing-export/main.ts.json | 6 + .../npm/cases/fetch-destructure/main.ts.json | 6 + .../fixtures/npm/cases/fs-shims/main.ts.json | 6 + .../npm/cases/hoisted-workspace/main.ts.json | 6 + .../npm/cases/import-refusal/main.ts.json | 6 + .../npm/cases/island-array-exits/main.ts.json | 6 + .../island-instanceof-regexp/main.ts.json | 6 + .../cases/island-json-stringify/main.ts.json | 6 + .../npm/cases/island-registry/main.ts.json | 6 + .../npm/cases/island-timers/main.ts.json | 6 + .../cases/island-web-plumbing/main.ts.json | 6 + .../npm/cases/jsval-into-dyn/main.ts.json | 6 + .../npm/cases/jsval-iterate/main.ts.json | 6 + .../npm/cases/lazy-traps/main.ts.json | 6 + .../npm/cases/misc-shims/main.ts.json | 6 + .../fixtures/npm/cases/namespace/main.ts.json | 6 + .../cases/node24-async-events/main.ts.json | 6 + .../node24-commonjs-metadata/main.ts.json | 6 + .../npm/cases/node24-crypto-kdf/main.ts.json | 6 + .../cases/node24-deep-equality/main.ts.json | 6 + .../node24-diagnostics-async/main.ts.json | 6 + .../main.ts.json | 6 + .../node24-diagnostics-tracing/main.ts.json | 6 + .../main.ts.json | 6 + .../npm/cases/node24-env/main.ts.json | 6 + .../cases/node24-esm-metadata/main.ts.json | 6 + .../cases/node24-event-emitter/main.ts.json | 6 + .../node24-file-url-conversion/main.ts.json | 6 + .../cases/node24-fs-descriptors/main.ts.json | 6 + .../npm/cases/node24-mime-errors/main.ts.json | 6 + .../npm/cases/node24-mime/main.ts.json | 6 + .../node24-no-error-assertions/main.ts.json | 6 + .../npm/cases/node24-parseargs/main.ts.json | 6 + .../cases/node24-promise-timers/main.ts.json | 6 + .../cases/node24-string-decoder/main.ts.json | 6 + .../npm/cases/node24-style-text/main.ts.json | 6 + .../cases/node24-system-errors/main.ts.json | 6 + .../cases/node24-text-encoding/main.ts.json | 6 + .../cases/node24-text-utilities/main.ts.json | 6 + .../cases/node24-timers-unref/main.ts.json | 6 + .../cases/node24-url-authority/main.ts.json | 6 + .../cases/node24-url-factories/main.ts.json | 6 + .../cases/node24-url-mutation/main.ts.json | 6 + .../cases/node24-util-adapters/main.ts.json | 6 + .../npm/cases/node24-util-types/main.ts.json | 6 + .../node24-web-stream-encoding/main.ts.json | 6 + .../node24-web-stream-errors/main.ts.json | 6 + .../node24-web-stream-lifecycle/main.ts.json | 6 + .../node24-web-stream-pipe-abort/main.ts.json | 6 + .../main.ts.json | 6 + .../node24-web-stream-pipes/main.ts.json | 6 + .../node24-web-stream-queues/main.ts.json | 6 + .../main.ts.json | 6 + .../node24-web-stream-readers/main.ts.json | 6 + .../cases/node24-web-stream-tee/main.ts.json | 6 + .../node24-web-stream-transforms/main.ts.json | 6 + .../npm/cases/npm-reexport/main.ts.json | 8 + .../npm/cases/package-imports/main.ts.json | 6 + .../cases/promise-bridge-forever/main.ts.json | 6 + .../promise-bridge-unhandled/main.ts.json | 6 + .../npm/cases/promise-bridge/main.ts.json | 6 + .../npm/cases/scoped-nested/main.ts.json | 6 + .../fixtures/npm/cases/self-name/main.ts.json | 6 + .../npm/cases/side-effect-order/main.ts.json | 7 + .../npm/cases/stream-shims/main.ts.json | 6 + .../main.ts.json | 6 + .../main.ts.json | 6 + .../npm/cases/typed-callbacks/main.ts.json | 6 + .../npm/cases/util-shims/main.ts.json | 6 + .../npm/cases/web-streams/main.ts.json | 6 + .../npm/cases/workspace-copied/main.ts.json | 6 + .../npm/cases/workspace-linked/main.ts.json | 6 + .../npm/cases/workspace-unclean/main.ts.json | 6 + .../npm/cases/zlib-shims/main.ts.json | 6 + .../strictness/indexed-loose/main.ts.json | 6 + .../strictness/indexed-strict/main.ts.json | 16 + .../strictness/json-any-broken/main.ts.json | 16 + .../fixtures/strictness/json-any/main.ts.json | 6 + .../strictness/null-floor/main.ts.json | 17 + .../strictness/project-paths/main.ts.json | 8 + .../compiler/test/ts7/order-parity.test.ts | 50 +- scripts/test-ts7.mjs | 9 +- scripts/ts7-order-fixtures.mjs | 10 + tests/harness/ts7-baselines.test.ts | 14 +- 2517 files changed, 15962 insertions(+), 15943 deletions(-) delete mode 100644 packages/compiler/test/ts7/baselines/order-parity.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/001-hello.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/002-log-args.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/100-number-format.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1000-json-stringify-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1001-json-escapes-unicode.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1002-json-parse-cast.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1003-json-parse-unions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1004-json-parse-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1005-json-nested.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1006-json-fs-config.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1007-json-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1008-json-null-arms.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1009-json-optional-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/101-arithmetic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1010-json-stringify-space.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1011-json-unknown-typeof.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/102-comparisons.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1020-async-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1021-async-ordering.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1022-async-exceptions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1023-async-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1024-async-pending-exit.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1025-async-promise-capture.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1026-throw-promise.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1027-async-return-promise.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1028-async-return-record-literals.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1029-async-eager-chains.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/103-ternary.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/104-ternary-empty-arrays.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1050-comptime-tables.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1051-comptime-strings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1052-comptime-records.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1053-comptime-json.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1054-comptime-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/110-number-radix.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1100-island-eval-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1101-island-marshal-unicode.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1102-island-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/111-record-entries.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1110-math-members.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1111-math-random.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1112-number-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1113-string-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1114-string-unicode-island.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1115-parse-globals.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1116-island-static-mix.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1117-typeof-static-union.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1118-object-spread-conditional.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1119-switch-union.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/112-class-descriptor-key.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1120-web-globals-encoders.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1121-infinity-number-tostring.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1122-any-captures.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1123-any-conditional-spread.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1124-union-narrowed-retag.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/113-promise-checked-exits.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/114-live-record-delete.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/115-array-compound.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/116-text-decoder-runtime.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/117-weak-cache-cycle.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/118-fs-stored-callbacks.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/119-native-patterns.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1200-regex-test-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1201-regex-replace.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1202-regex-substitutions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1203-regex-split.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1204-regex-empty-unicode.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1205-regex-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1206-regex-dynamic-mix.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1300-errors-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1301-errors-subclass.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1302-errors-typed-catch.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1303-errors-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1304-errors-uncaught.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1305-errors-async-rejections.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1306-errors-runtime-instances.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1350-path-normalize-join.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1351-path-parts.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1352-path-resolve-relative.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1353-os-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1354-builtin-bare-specifiers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1355-url-parse.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1356-url-file-bridge.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1357-fsp-roundtrip.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1358-crypto-random.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1359-json-module/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1360-spawn-sync.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1361-spawn-events.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1362-spawn-timers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1363-spawn-unhandled-error.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1364-union-truthiness.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1365-union-logical.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1366-union-equality.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1367-destructuring.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1368-constructor-functions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1369-promise-union.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1370-spread.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1371-union-template-tostring.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1372-loose-null-tests.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1373-union-array-arms.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/140-bitwise-operators.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1400-typedarray-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1401-typedarray-slice-set.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1402-buffer-encodings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1403-buffer-fs.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1404-zlib-crypto-bytes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1405-bytes-unions-arrays.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1406-dataview-mp4.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1407-dataview-bounds.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1408-string-indexing.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1409-typedarray-integer-loops.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1420-number-statics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1421-number-parse-dynamic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1422-date-iso.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1423-text-codec.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1424-fs-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1425-stdin-tty.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1426-stdin-read.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1427-fromcharcode-lastindexof.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1428-settled-await-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1429-promise-catch-finally.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1430-promise-race.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1431-caught-tostring.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1432-destructured-params.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1433-filter-narrow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1434-async-never.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1435-math-spread.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1436-default-undef-param.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1437-pad-default.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1438-promise-all.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1440-interval-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1441-interval-clear-cross.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1442-interval-throw.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1443-signal-handlers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1444-exit-listeners.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1445-exit-process-exit.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1446-exit-uncaught.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1447-stdin-closed-events.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1448-stream-columns.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1450-incdec-expression.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1451-instanceof-uint8array-unknown.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1452-return-through-finally.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1453-pmap-settled.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1454-nonnull-narrow-and-fcc-bytes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1455-lambda-union-return-adoption.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1460-console-error-warn.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1461-process-pid-getuid-kill.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1462-exec-sync.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1463-timeout-unref.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1464-env-writes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1465-env-value.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1466-child-containers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1467-string-match.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1468-exec-path.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1469-remove-listener.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1470-child-lifecycle.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1471-child-unref.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1472-errno-code.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1473-promisify-execfile.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1474-string-decoder.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1475-readline-closed-stdin.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1476-assign-expression.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1477-in-expressions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1478-promise-reject.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1479-destructuring-assign.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1480-os-network-interfaces.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1481-string-case-static.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1482-spawnsync-error.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1483-array-slice.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1520-fs-wider-surface.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1520-string-split-static.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1521-fs-lstat-lock.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1521-string-trim-pad-static.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1522-parseint-static.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1522-spawnsync-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1523-isnan-floor-static.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1523-spawn-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1524-atomics-sleep-static.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1524-catch-narrowing.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1525-child-exit-signal.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1525-unknown-typeof-validation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1526-set-spread.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1527-logical-mixed-operands.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1528-delete-records-env.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1529-class-with-statics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1530-array-push-variadic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1530-spread-override-completion.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1531-delete-optional-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1531-process-arch-versions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1532-array-splice-shift.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1532-union-shared-field-read.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1533-bool-equality.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1533-path-platform-namespaces.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1534-crypto-hash-chain.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1534-union-as-arm-cast.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1535-spawn-fd-stdio.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1535-union-param-defaults.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1536-destructuring-defaults.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1536-string-array-sweep.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1537-chalk-hybrid/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1537-os-release-spawnsync-stdio.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1538-await-promiselike-return.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1538-math-static-scalar.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1539-readonly-set-map.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1539-unknown-truthiness.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1540-os-userinfo.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1540-void-statement.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1541-fs-readdir-dirent.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1541-union-keyed-reads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1542-map-promise-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1542-record-literal-into-union.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1543-rest-destructuring.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1543-set-server-handles.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1544-dyn-json-reads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1544-string-matchall.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1545-spread-order-and-optional.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1546-union-element-reads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1547-computed-key-fold.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1548-boolean-condition-forms.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1549-array-isarray-unions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1550-param-defaults-func-set.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1551-dyn-receiver-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1552-exec-options-record.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1553-truthy-hof-predicates.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1554-caught-into-unknown.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1555-index-spread-into-declared.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1556-union-retag-width-arms.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1557-url-host.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1558-any-joins-and-dyn-validation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1559-conditional-spread-index-merge.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1560-forof-homogeneous-tuples.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1561-forof-strings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1561-promise-then.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1562-optional-chain-tails.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1562-spawn-conditional-spread.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1563-forof-iterator-projections.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1563-string-raw-fold.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1564-fs-watch.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1564-string-raw.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1565-spawn-pipe-streams.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1565-union-element-join.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1566-child-duck-interface.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1567-server-close-override.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1568-x509-fingerprint.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1569-fsp-mkdir-unlink-chmod.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1570-child-unref-kill-reffed.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1571-optional-call-tostring-tail.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1571-stdin-set-raw-mode-non-tty.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1572-promise-reject-all-tuple.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1572-x509-validity-date-gettime.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1573-promisify-execfile-env-spread.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1573-tdz-scalar-forward-capture.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1574-dyn-optional-method-number-keys.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1574-promise-all-tuple-literal.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1575-unknown-assert-into-record.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1576-width-coercions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1577-url-hostname.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1578-exec-input-optional.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1579-matchall-index.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1580-exec-env-conditional-spread.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1581-declare-const-read.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1582-timer-sleep-resolve.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1583-loops-and-stream-captures.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1584-union-field-unassigned.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1585-union-field-conditional-ctor.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1586-derived-field-before-super-init.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1587-any-field-unassigned.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1590-js-unannotated.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1591-js-closures.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1592-js-classes.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1593-js-jsdoc-records.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1594-js-async.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1595-js-island-gap/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1596-cjs-modules/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1597-mjs-graph/main.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1598-cjs-builtin-require/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1599-js-uncaught-throw.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1600-assert-passing.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1601-assert-fail-exit.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1602-assert-caught-error.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1603-assert-scalar-messages.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1604-assert-deep-structures.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1605-assert-import-forms.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1606-assert-strict-module.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1607-assert-throws-match.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1608-cjs-assert/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1609-assert-async.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1610-path-win32-full.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1611-url-file-bridge-neutral.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1612-cjs-module-globals.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1613-cjs-esm-proxy-named/main.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1614-js-fence-dodges.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1615-cjs-export-shapes/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1616-cjs-esm-lexer-invisible/main.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1617-cjs-esm-lexer-visible/main.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1618-cjs-esm-poisoned-tail/main.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1619-cjs-esm-reexport-invisible/main.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1620-cjs-require-effects-order/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1621-cjs-require-cache-hit/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1622-cjs-require-conditional/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1623-cjs-require-diamond/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1624-cjs-require-dir-mid-file/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1625-cjs-require-lazy-fn/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1626-cjs-require-mjs/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1627-mjs-import-cjs-requires/main.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1628-checked-dynamic-builtin-args.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1629-require-main-filename.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1630-inspect-scalars.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1630-rmsync-retry-options.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1631-inspect-arrays.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1632-inspect-records.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1633-inspect-map-set.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1634-inspect-classes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1635-inspect-buffer.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1636-util-format.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1637-inspect-dyn.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1638-inspect-cjs.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1639-versions-openssl-probe.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1640-fd-read-decode.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1641-string-search.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1642-object-fromentries-rows.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1643-metadata-dyn-return.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1644-ee-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1645-ee-extends.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1646-ee-once-remove.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1647-ee-meta-events.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1648-ee-error-event.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1649-ee-names-counts.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1650-ee-prepend.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1651-ee-max-listeners.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1652-ee-snapshot.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1653-ee-cjs.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1654-ee-namespace.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1655-spawnsync-neutral.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1656-execsync-neutral.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1657-spawn-async-neutral.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1660-buffer-read-write-num.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1661-buffer-encodings-full.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1662-string-decoder-encodings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1663-buffer-compare-search-fill.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1664-dyn-fn-boundary.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1665-dyn-fn-mustcall/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1666-dyn-fn-identity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1667-dyn-fn-not-callable.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1668-dyn-fn-throws.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1669-symbol-identity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1670-symbol-registry.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1671-symbol-typeof.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1672-symbol-containers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1673-symbol-cjs.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1674-symbol-inspect.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1676-func-array-surface.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1677-emitter-listeners.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1678-emitter-dyn-listeners.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1679-console-dyn.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1680-assert-bytes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1681-assert-funcs.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1685-stream-readable-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1686-stream-readable-paused.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1687-stream-readable-flow-control.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1688-stream-writable-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1689-stream-writable-async-drain.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1690-stream-duplex.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1691-stream-transform.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1692-stream-pipe.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1693-stream-pipe-backpressure.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1694-stream-destroy.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1695-stream-props.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1696-stream-read-inside-read.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1697-stream-tick-vs-timer.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1698-stream-uncaught-error.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1699-stream-callback-shapes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1700-mustcall-common/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1701-mustcall-exit-report/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1702-dyn-proto-dispatch.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1703-arguments-rest-props.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1710-cjs-export-class/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1711-cjs-export-single-values/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1712-field-incdec.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1713-js-dyn-fields.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1720-assert-throws-shape.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1721-assert-throws-regex-class.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1722-assert-rejects.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1723-assert-does-not-reject.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1724-assert-iferror.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1725-assert-symbols.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1726-promise-with-resolvers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1727-assert-throws-shape-exit.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1730-countdown-symbol-keys/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1731-symbol-field-shapes.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1732-symbol-field-cross-module/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1740-stream-extends-readable.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1741-stream-extends-writable.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1742-stream-extends-duplex-transform.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1743-stream-extends-vt-dispatch.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1744-stream-set-encoding.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1745-stream-encoding-js.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1746-stream-for-await.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1747-stream-for-await-js.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1750-http-agent-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1751-options-record-stance.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1760-surplus-args-drop.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1761-emitter-special-event-names.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1770-assert-dyn-strict.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1771-assert-dyn-deep.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1772-assert-dyn-js.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1773-assert-dyn-exit.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1780-http-res-surface.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1781-http-server-shapes.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1790-computed-key-folds.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1791-searchparams-core.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1792-searchparams-encoding.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1793-searchparams-iteration.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1794-searchparams-url-live.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1795-dyn-handle-request.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1796-dyn-handle-body.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1797-dyn-handle-socket.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1798-dyn-handle-typed-box.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1800-immediate-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1801-immediate-handle.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1802-immediate-unref-exit.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1803-timeout-refresh.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1804-timers-module.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1805-timer-callback-args.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1806-timer-delay-trunc.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1810-stream-options-const-record.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1811-stream-option-value-callbacks.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1812-stream-super-options-forwarding.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1813-stream-finished.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1814-stream-pipeline.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1815-stream-state-reads.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1820-static-block-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1821-static-block-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1822-static-block-js.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1823-static-instance-method-names.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1824-for-of-destructuring-defaults.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1825-exhaustive-typeof-switch.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1826-settimeout-arguments-callback.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1830-enum-numeric-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1831-enum-string-const-reverse.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1832-enum-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1835-var-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1836-var-loop-capture.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1837-var-undefined-hoisting.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1838-var-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1839-var-js/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1840-jsdoc-import-type-only/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1850-overload-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1851-overload-return-narrowing.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1852-overload-class-members.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1853-overload-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1854-ambient-declare-fn.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1855-ambient-declare-fn-uncaught.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1870-unit-type-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1871-empty-array-never.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1872-template-tostring-composite.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1880-json-declared-field-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1881-default-anon/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1882-default-cjs-interop/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1883-default-exports/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1890-ns-imports/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1891-ns-reexport/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1940-class-values-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1941-class-values-registry.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1942-class-expressions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1943-class-statics-expanded.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1944-class-values-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1950-generic-fn-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1951-generic-classes-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1952-generic-class-statics-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1953-generic-class-hierarchy.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1954-generic-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1960-namespace-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1961-namespace-nested.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1962-namespace-classes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1963-namespace-aliases.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1964-namespace-type-only.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1965-namespace-ambient.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1966-namespace-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1967-namespace-alias-typeonly.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1968-namespace-import-eq-snapshot.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1970-decorators-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1971-decorators-rebinding.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1972-decorators-throwing.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1973-decorators-ambient.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1980-primitive-proto-statics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1981-date-utc.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1982-freeze-resolve-passthrough.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1983-array-tuple-surfaces.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1990-labels-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1991-for-in-loops.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1992-small-syntax.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/200-strings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2000-generic-methods-basic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2001-generic-methods-generic-class.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2002-generic-methods-inheritance.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2003-generic-methods-object-literal.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2004-generic-methods-statics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/201-templates.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2010-generators-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2011-generators-forof.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2012-generators-return-throw.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2013-generators-sent-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2014-generators-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2015-generators-yieldstar.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2016-generators-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2017-generators-async.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2018-generators-uncaught.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2019-generators-loops.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2020-generic-value-bindings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2021-generic-value-binding-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2022-width-index-capture.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2023-width-readonly.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2024-width-array-elems.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2025-width-union-compose.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2026-width-spread.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2030-width-nested.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2031-width-tuples.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2032-cjs-export-assigned-class-expression/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2033-property-assigned-class-extends.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2035-ternary-array-retag.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2036-evolving-array-decl.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2037-fn-decl-hoisting.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2038-evolving-array-js.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2040-any-bindings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2040-mixin-heritage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2041-any-params-returns.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2041-mixin-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2042-any-flow-loops.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2042-mixin-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2043-any-dom-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2043-mixin-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2044-vtable-sibling-slots.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2045-objlit-accessors-basic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2045-parameter-properties.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2046-abstract-classes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2046-objlit-accessors-effects.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2047-objlit-accessors-shapes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2047-optional-class-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2050-dynamic-import-own-module/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2051-dynamic-import-then/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2052-dynamic-import-self.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2053-typeof-static-fold.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2054-destructuring-island-source.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2060-empty-tuple.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2070-computed-key-folds.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2071-integer-key-enumeration-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2072-expando-function-members.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2073-destructuring-assignment.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2074-island-destructuring.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2075-index-signature-runtime-keys.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2080-destructuring-defaults.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2081-destructuring-rest.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2082-destructuring-assignment.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2083-destructuring-island-decl.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2084-destructuring-primitive-sources.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2085-destructuring-heads-rest-params.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2086-destructuring-island-globals.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2087-destructuring-for-heads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2090-index-signature-number-keys.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2091-index-signature-string-intersection.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2092-package-imports/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2093-timers-promises.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2094-diagnostics-channel.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2095-js-catch-unknown.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2096-os-type.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2097-js-evolving-globals.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/210-string-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2100-stream-default-hwm.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2101-dyn-param-defaults.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2102-empty-pattern-decls.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2103-optional-tuple-elements.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2104-computed-key-destructuring.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2105-computed-key-static-folds.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2106-comma-expressions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/211-string-unicode.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2110-top-object-types.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2111-json-stringify-unknown.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2112-array-at-findlast.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2113-string-index-methods.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/212-string-aliasing-append.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2120-package-self-import/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2121-esm-cycle-inert-backedge/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2122-import-refusal-crash/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2123-ambient-import-crash/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2124-imports-field-wildcard/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2130-overload-island-returns.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2140-uri-component-codecs.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2160-dc-tracing-channel.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2161-js-object-literal-identity.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2162-js-dyn-destructure.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2163-js-selfref-const.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2164-js-then-dyn-handler.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2165-js-throw-dyn.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2166-cjs-getter-this/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2170-island-array-exits.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2171-island-json-stringify.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2172-island-regexp-boundary.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2190-new-object-and-string-wrappers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2191-uri-encoders.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2192-object-default-tostring.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2193-discarded-stdlib-reads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2194-ambient-undef-chains.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2195-require-missing-package/main.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2196-island-computed-key-chain.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2210-dyn-promise-crossing.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2211-dc-trace-promise.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2212-unhandled-rejection-listener.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2213-async-local-storage.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2214-dc-bind-store.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2215-process-emit-warning-exit.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2240-width-class-into-record.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2241-width-record-into-class.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2242-width-statics-into-record.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2243-width-assert-satisfies-shapes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2250-tagged-templates.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2251-tagged-templates-dyn.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2252-class-iterators.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2253-union-coercions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2260-http2-constants.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2280-builtin-namespace-destructure.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2281-domexception-atob-btoa.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2282-queue-microtask.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2283-structured-clone.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2284-regexp-constructor.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2285-iferror-dyn.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2286-dyn-object-walks.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2300-dyn-record-spread-and-keyed-access.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2301-cjs-export-table-dom-attach.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2310-process-next-tick.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2311-next-tick-js-callbacks.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2312-stream-underscore-assign.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2313-stream-underscore-assign-js.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2314-process-introspection.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2320-await-unit.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2321-emitter-static-setmax.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2322-dyn-array-sort.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2323-timer-callback-returns.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2330-tls-server-runtime-options.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2331-tls-server-options-typed.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2350-nan-global.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2351-async-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2352-void-coercions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2353-decorators-member-ambient.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2354-decorators-expression-ambient.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2360-tuple-to-array.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2361-assign-index-record.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2362-execsync-inherit.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2363-nullish-retag.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2364-in-runtime-key.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2365-dyn-into-island.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2366-string-well-formed.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2367-regexp-escape.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2368-set-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2369-promise-try.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2370-group-by.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2371-iterator-helpers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2380-buffer-module-named-import.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2381-builtin-default-imports.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2382-cycle-two-decl/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2383-cycle-assertdoc/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2384-cycle-mixed-bindings/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2385-builtin-reexport-facade/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2386-string-to-chars.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2387-tonumber-argv.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2388-tonumber-grammar-zoo.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2389-tonumber-unary-plus.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2390-dot-requires/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2391-default-builtin-imports/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2392-block-guard-alias-scope.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2393-loop-exit-guard-narrow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2394-loop-narrow-containment.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2395-while-cond-guard.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2396-born-narrowed-decl.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2397-branch-kill-merge.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2398-switch-arm-kill.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2399-reassign-kill-polarity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/240-stdout-write.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2400-kill-return-edge.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2401-kill-break-staging.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2402-labeled-break-kill.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2403-kill-continue-backedge.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2404-kill-throw-catch.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2405-sibling-arm-narrow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2406-switch-clause-sibling-narrow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2407-infinite-loop-seal.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2408-loop-terminality-reopen.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2409-loop-body-return-not-terminal.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2410-stacked-cases-terminality.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2411-exhaustive-switch-terminality.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2412-dowhile-guard-trailing-test.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2413-dowhile-kill-renarrow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2414-dowhile-continue-kill.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2415-dowhile-break-trailing-test.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2416-spread-ternary-positions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2417-ternary-local-inference.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2418-wrapped-ternary-arms.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2419-selector-ternary-union.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2420-nullish-null-identity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2421-float-lane-inference.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2422-ieee-div-rem-corners.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2423-param-null-reassign.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2424-ternary-miss-first-narrowing.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2425-elseif-head-exit-narrow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2426-default-snapshot-mutable/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2427-perf-hooks-now.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2428-field-redeclare-inherited.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2429-destructure-class-instance.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2430-empty-literal-unknown-field.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2431-primitive-ctor-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2432-generic-member-fields-async.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2433-as-const-command-tables.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2434-deferred-init-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2435-loose-same-kind-equality.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2440-console-inspect-args.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2441-console-process-argv.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2442-union-literal-arm-widening.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2443-union-literal-shadow-narrowing.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2444-union-literal-reducer-spread.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2445-math-minmax-nary.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2446-performance-global.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2447-island-boundary-slots/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2448-entries-null-arms-regex-arrays.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2449-js-dyn-worlds/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2450-private-instance-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2451-private-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2452-private-statics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2453-private-accessors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2454-private-generator-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2455-private-brand-checks.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2456-private-async-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2457-private-members.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2460-qs-parse-grammar.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2461-qs-parse-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2462-qs-stringify.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2463-qs-escape-unescape.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2464-qs-require-forms.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2470-mockable-module-shape.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2471-record-keyed-write-hasown.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2472-string-regexp-union.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2473-option-table-widths.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2474-island-literal-forms.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2475-variadic-wrapper-island.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2476-map-regex-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2480-recursive-record-tree.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2481-mutual-recursive-records.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2482-recursive-union-tree.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2483-recursive-record-cycles.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2484-json-stringify-circular.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2485-inspect-circular-refs.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2486-recursive-record-boundaries.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2487-recursive-deep-equal.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2488-ast-walker.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2490-find-miss-null-compare.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2491-strict-unit-compare-no-arm.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2492-loose-null-compare-unions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2493-switch-unit-cases.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2494-no-arm-compare-effects.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2500-net-autosel-timeout.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2510-dyn-evolving-array-map.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2511-dyn-evolving-array-filter-foreach.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2512-dyn-evolving-array-mixed-push.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2513-dyn-evolving-array-derived.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2520-private-statics-class-name-calls.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2521-private-statics-class-expression.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2522-private-statics-decorated.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2523-private-statics-aliased-class.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2530-object-destructuring-decl.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2531-array-tuple-destructuring-decl.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2532-param-destructuring-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2533-forof-destructuring.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2534-object-rest-decl.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2535-destructuring-assign-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2536-destructuring-assign-nested.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2537-destructuring-assign-member-targets.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2538-destructuring-assign-class-source.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2539-class-instance-rest.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2540-accessor-destructuring-defaults.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2541-destructuring-eval-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2550-generics-keyof-pick.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2551-generics-value-aliases.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2552-generics-iface-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2553-generics-signature-bindings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2554-generics-frontier-mix.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2555-generics-keyof-writes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2556-crypto-introspection.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2556-width-hybrid-shapes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2557-tls-ca-store.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2557-width-field-lifts.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2558-index-signature-func-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2558-rejection-events.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2559-index-signature-container-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2560-arraybuffer-dataview-set.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2561-object-is.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2562-intl-numberformat-en-us.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2563-stream-promises-pipeline.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2564-stream-promises-finished.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2565-stream-promises-js.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2566-promise-reject-dyn-reason.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2567-rest-spread-forward.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2568-rest-spread-forward-dynamic.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2569-upcast-identity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2570-buffer-arg-validation.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2571-searchparams-arg-validation.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2572-readable-emitted-readable-flag.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2573-fs-url-arg-ladders.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2574-emitter-max-listeners-ladders.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2575-string-destructuring-decl.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2576-string-destructuring-assign.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2577-builtin-global-destructuring.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2578-jsval-into-unknown-rows.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2579-jsval-object-param-crossing.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2580-jsval-routed-keyed-ops.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2581-jsval-routed-calls.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2582-jsval-object-statics.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2582-jsval-routed-keyed-ops.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2583-dyn-nullish-coalesce.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2583-jsval-routed-calls.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2584-jsval-object-statics.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2584-union-dyn-collapse.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2585-dyn-nullish-coalesce.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2585-unknown-array.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2586-object-assign-spread.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2587-array-entries-forof.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2588-array-entries-chains.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2589-object-create-null.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2590-object-create-dynamic.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2591-ambient-generic-traps.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2592-ambient-trap-uncaught.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2593-generic-inert-bindings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2594-nullish-generic-bindings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2595-fs-arg-ladders.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2596-net-arg-ladders.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2597-dgram-send-ladders.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2598-tls-arg-ladders.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2599-stream-arg-ladders.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2600-dyn-keyed-write-harness.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2601-dyn-keyed-write-ops.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2602-dyn-array-destructure.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2603-island-keyed-write-dyn.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2604-cycle-classes-mutual/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2605-cycle-three-module/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2606-dynamic-import-cycle/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2608-regex-named-groups.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2609-regex-named-replace.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2610-regex-named-matchall.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2611-regex-named-groups-js.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2613-for-init-uninitialized-let.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2614-trap-binding-later-writes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2615-nullish-field-record-binding.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2616-js-collect-probe-defers.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2617-enum-static-field-import/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2618-ee-emit-override.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2619-ee-override-chain.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2620-ee-override-once-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2621-ee-override-error-throw.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2622-ee-override-filter.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2623-ee-job-queue.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2624-ee-override-js.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2625-bytes-views.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2626-stream-event-names.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2627-stream-ticks-are-nextticks.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2628-stream-push-encodings.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2629-stream-consumers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2630-stream-consumers-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2631-create-require/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2632-dyn-jsval-iterate.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2633-island-promise-crossing.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2634-stream-pipeline-arg-ladders.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2635-trap-binding-unmappable-written.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2636-trap-binding-ambient-rooted-rewrite.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2637-create-require-bare/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2638-http-dyn-res-compat.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2639-http-dyn-req-pause.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2640-net-dyn-socket-compat.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2641-http-agent-surface.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2642-http-agent-maxsockets.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2643-or-default-retag.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2644-http-client-url-argument.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2645-https-client-url-argument.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2646-top-level-await.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2647-top-level-await-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2648-top-level-await-rejection.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2649-top-level-await-pending.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2650-top-level-await-self-import.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2651-top-level-await-pending-unhandled.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2652-top-level-await-dynamic/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2653-top-level-await-rejection-stops-loop.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2654-top-level-await-unrelated-rejection.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2655-top-level-await-cycle/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2656-top-level-await-cycle-order/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2657-top-level-await-cycle-dynamic/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2658-top-level-await-sync-completion/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2659-top-level-await-dynamic-cycle/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2660-top-level-await-cycle-rejection/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2661-top-level-await-dynamic-runtime-root/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2662-top-level-await-cycle-external-wait/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2663-top-level-await-dependency-errors/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2664-top-level-await-same-checkpoint-rejection.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2665-top-level-await-unhandled-listener-liveness.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2666-array-to-sorted.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2667-array-to-sorted-any.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2668-stored-number-array-iterator.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2669-array-copying-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2670-uint8array-copy-iterate.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2671-array-copying-js.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2672-http-request-response-callback.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2673-top-level-await-implicit-module.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2674-top-level-for-await-implicit-module.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2675-create-require-nested-esm.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2675-process-self-reexec.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2676-indexed-read-strict-equality.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2676-record-clone-overrides.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2676-top-level-await-ambiguous/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2677-runtime-optional-closure.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2677-top-level-await-module-scope/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2678-date-instances.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2678-large-string-sparse-index.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2678-util-parseargs.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2679-util-parseargs-cjs.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2680-util-parseargs-default.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2681-util-parseargs-dynamic.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2682-fs-rename.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2683-filter-truthy-predicate.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2683-fs-rename-js.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2684-filter-no-predicate-dyn.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2684-fs-rename-abort.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2685-array-unshift-reverse.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2685-fs-write-sync.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2686-fs-file-handle.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2687-fsp-write-file-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2687-process-write-args.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2688-fs-stats-disk-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2689-http-server-timeout-properties.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2690-https-server-timeout-option.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2691-retained-lowering-record-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2692-inline-record-assert-index.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2692-string-accumulation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2693-math-constants.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2700-array-sort-complexity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2700-http-static-trailers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2700-wasi-core.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2701-array-sort-snapshot.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2701-http-static-trailer-wire.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2701-import-meta/main.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2702-http-static-trailer-end.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2702-type-import-link-static/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2702-uint8array-to-sorted.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2703-array-sparse-sort.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2703-type-import-link-static-reexport/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2704-array-sparse-to-sorted.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2704-type-import-link-static-success/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2705-array-sparse-sort-append.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2705-type-import-link-dynamic/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2706-array-search-missing-needle.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2706-type-import-link-dynamic-success/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2707-array-search-huge-sparse.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2707-type-import-link-static-default-reexport/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2708-type-import-link-dynamic/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2720-array-read-parity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2721-array-nested-missing-receiver.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2750-array-sparse-foundation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2751-buffer-concat-sparse-list.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2752-array-optional-stores.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2753-array-optional-method-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2754-array-property-undefined.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2755-array-optional-literal-forwarding.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2780-array-parity-composition.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2781-array-missing-value-escape.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2782-array-sparse-callbacks.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2783-array-defaults-rest.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2784-array-reduce-missing-result.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2785-array-missing-destructuring.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2786-array-sparse-serialization.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2787-array-missing-string-arithmetic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2788-array-missing-builtin-conversions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2789-array-missing-optional-tostring.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2790-array-missing-tagged-substitutions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2790-dynamic-import-self-name/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2791-record-optional-keys.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2792-record-optional-spread-entries.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2793-union-conversion-identity-capture.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2794-array-generic-callback-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2795-array-optional-typedarray-source.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2796-array-sparse-class-value-instanceof.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2800-array-expression-consumers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2801-array-switch-consumers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2820-array-missing-method-receivers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2821-array-optional-numeric-comparisons.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2830-cjs-require-self-name/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2840-finally-completions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2841-using-sync.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2842-await-using.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2843-using-suppressed-error.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2844-node-disposable-resources.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2845-for-using-of.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2846-generator-using.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2850-async-generators-protocol.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2851-async-generators-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2852-timers-promises-interval.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2854-leading-bom-literals.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2855-searchparams-sort-complexity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2856-dynamic-any-local-operators.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2857-branded-primitives.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2858-import-meta-resolve/main.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2859-import-meta-resolve-dynamic/main.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2860-require-resolve/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2861-readable-iterator-close.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2862-web-readable-async-iteration.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2863-class-async-iterator.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2864-array-class-method-receivers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2865-cjs-process-alias.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2866-dyn-switch.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2867-array-shift-length.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2868-empty-record-promise-presence.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2869-nullish-mixed-lazy.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2870-and-dropped-truthy-arm.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2871-optional-promise-to-unknown.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2872-unobserved-dynamic-event.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2873-optional-receiver-loop-lifetime.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2874-nullable-callback-field-cycle.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2875-evolving-let-read-before-write.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2876-class-unknown-roundtrip.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2877-child-unknown-roundtrip.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2878-class-private-unknown.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2880-cjs-module-graph/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2890-crypto-static-utility.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2891-json-record-key-escapes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2892-windows-console-unicode.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2893-child-stdin-duplex.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2894-child-stdin-backpressure.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2895-child-stdin-write-after-end.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2896-child-stdin-write-after-finish.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2897-child-stdin-destroy.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2898-child-stdin-spawn-failure.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2899-nested-mutual-recursion.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2900-float64array-static.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2900-void-conditional-arrow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2901-bigint-core.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2902-bigint-bytes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2903-bigint-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2904-bigint-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2905-bigint-edges.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2906-bigint-wasi-width.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2910-overloaded-callable-alias.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2911-execfile-callback.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2912-execfile-callback-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2912-promisify-fs-readfile.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2913-builtin-callable-alias.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2914-fixed-tuple-call-spread.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2915-path-function-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2916-path-function-values-cjs.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2917-builtin-callable-widths.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2918-builtin-callable-widths-cjs.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2919-fs-function-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2920-fs-promises-function-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2921-zlib-callbacks.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2922-dyn-bitwise-not.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2923-cjs-factory-export/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2930-union-receiver-calls.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2931-union-dynamic-field-call.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2932-create-require-program/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2933-static-dynamic-import/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2934-static-import-stored.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2935-module-namespace-values/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2936-static-loose-equality.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2937-bitwise-hot-loop.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2938-fs-sync-overloads.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2939-child-shell-text.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2940-date-parse.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2940-fsp-realpath.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2941-fsp-lstat-identity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2941-process-exit-code.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2942-fsp-readdir-dirent.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2942-process-exit-code-override.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2943-process-exit-code-invalid.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2944-process-exit-code-wrap.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2945-url-origin-username.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2946-child-fork-ipc/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2946-url-port-hash.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2947-set-readonly-seeds.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2948-child-fork-eof-callback/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2948-stdio-callback-record.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2949-child-fork-default/main.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2949-url-password.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2950-fs-descriptor-publication.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2951-math-static-analytic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2952-math-static-remaining.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2953-http-header-validation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2954-http-outgoing-headers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2955-http-static-state.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2956-http-static-informational.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2957-http-static-response-controls.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2961-emitter-computed-names.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2962-emitter-computed-optional.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2963-child-fork-dispatch/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2964-indexed-compound.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2966-numeric-array-read-fusion.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2967-numeric-array-read-lifetime.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2968-numeric-array-borrow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2969-scalar-record-results.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2970-constant-numeric-tables.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2971-constant-table-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2972-http-static-distinct-snapshots.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2972-math-receiver-borrow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2973-http-static-agent.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2973-integer-bitwise-arithmetic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2974-array-search-from-index.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2974-http-static-module-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2974-numeric-remainder.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2975-bigint-default-radix.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2975-http-static-client-controls.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2976-http-static-incoming-state.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2976-json-stringify-no-arguments.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2977-http-static-incoming-timeout.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2977-nested-array-binding-defaults.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2978-http-static-client-timeout.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2978-regexp-optional-subject.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2979-array-search-mixed-needles.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2979-http-static-server-timeout.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2980-http-static-server-timeout-default.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2980-string-position-arguments.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2981-http-static-events.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2981-string-optional-positions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2982-http-static-close-all.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2982-string-position-coercion-order.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2983-http-static-close-idle.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2984-http-static-close-upgrade.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2985-http-static-message-destroy.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2986-http-static-client-socket-finish.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2987-http-static-timeout-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2988-http-static-client-abort.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2989-http-static-response-timeout-handled.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2990-http-static-request-timeout-handled.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2991-array-indexed-equality.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2992-stream-rows.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2993-fiber-stack-lifetimes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2994-fromcharcode-scalar.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2995-math-hyperbolic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2996-math-near-one.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2997-math-integer-float.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/300-if-else.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3001-caught-typeof-object.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3002-promise-then-two.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/301-while.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/302-for.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3020-string-last-index-position.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3021-buffer-union-narrow-callback.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3022-string-affix-positions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3023-string-affix-position-coercion.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3024-string-number-narrow-for-in.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3025-string-search-position-coercion.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3026-array-last-index-of.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3027-array-last-index-of-records.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3028-string-search-dynamic-needle.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3029-string-search-union-needle.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/303-break-continue.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3030-array-search-no-arg.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3031-array-relative-index-coercion.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3031-string-last-index-search-value.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3032-string-search-value.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3033-string-search-needle-coercion.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3034-arguments-with-parameters.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3035-string-positioned-search-value.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3036-string-object-search-value.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3037-number-nullish-conversion.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3038-number-scalar-unions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3039-string-repeat-count.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/304-compound-incdec.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3040-string-prototype-call.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3041-string-prototype-object-call.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3042-string-padding-coercion.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3043-string-split-arguments.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3044-array-slice-splice-positions.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3045-array-indexed-mutation.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3046-array-indexed-ref-identity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3047-object-prototype-tag.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3048-object-own-prototype.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3049-array-flat-depth.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/305-truthiness.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3050-array-splice-insert.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3051-array-join-default.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3052-array-construction.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3053-array-construction-js.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3054-dynamic-abort-record.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3055-default-builtin-nodenext/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3056-default-builtin-bundler/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3057-default-builtin-nodenext-dynamic/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3058-optional-array-chain-join.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3059-arguments-property-names.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3060-dynamic-host-global.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3061-concurrent-fiber-stacks.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3062-runtime-optional-record-guards.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3063-runtime-optional-class-guards.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3064-installed-entry-imports/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3065-installed-entry-js/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3066-source-debugging/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3067-cjs-function-export-require/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3068-debug-variables/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3068-url-checked-identity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3069-set-checked-seed.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3069-tuple-spread.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3070-checked-object-accessors.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3070-collection-views.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3071-checked-specialization-narrowing.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3071-map-contextual-record-seeds.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3072-optional-union-receivers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3072-weak-process-streams.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3073-optional-callable-module.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3073-union-keyed-reads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3074-discriminated-intersections.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3075-recursive-contextual-literals.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3076-nullish-record-defaults.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3077-optional-union-array-reads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3078-forward-mutable-captures.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3079-forward-mutable-tdz.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3080-exhaustive-never-bindings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3081-recursive-array-destinations.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3082-forward-write-unwind.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3083-set-string-seed.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3084-record-own-membership.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3085-conditional-record-construction.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3086-error-constructor-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3087-error-options-lifetime.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3088-array-wide-callbacks.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3089-array-find-narrowing.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3090-json-discriminated-records.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3091-json-recursive-discriminants.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3092-number-union-predicates.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3093-error-option-data.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3094-json-replacer-traversal.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3095-json-reviver-traversal.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3096-json-callback-nonfinite.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3097-json-callback-reentrancy.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3098-json-callback-space.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3099-json-callback-functions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3100-json-callback-holder.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3101-json-callback-bytes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3102-json-unknown-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3103-scalar-record-nested-control-flow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3104-native-analysis-tables-loops.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3105-nullable-collections.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3106-mixed-insertion-spreads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3107-nullable-collection-lifetimes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3108-for-await-sync-arrays.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3108-identity-map-keys.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3109-destructuring-unknown-defaults.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3109-identity-union-collections.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3110-builtin-error-families.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3110-identity-collection-mutation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3111-identity-collection-cycles.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3112-union-switch-control-flow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3113-union-array-removal.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3114-union-record-field-write.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3115-zlib-static-compression-levels.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3116-sequence-expression-lifetimes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3117-unknown-switch-control-flow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3118-recursive-union-spread.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3119-runtime-optional-spread.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3120-dynamic-property-descriptors.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3120-generator-method-loop-bindings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3120-ir-nonfinite-numbers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3121-compound-assignment-values.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3121-dynamic-accessor-descriptors.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3122-dynamic-delete-descriptors.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3122-dynamic-delete-descriptors.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3122-js-async-class-methods.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3123-destructured-global-tdz.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3124-array-prototype-borrow.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3125-regex-global-match.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3126-js-number-radix/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3127-spawn-runtime-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3128-regex-last-index.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3129-js-token-union/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3130-child-generic-streams.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3131-child-rest-listeners.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3132-child-generic-stream-completion.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3133-text-decoder-streaming.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3134-fs-vectors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3135-fs-file-handle-controls.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3136-fs-file-handle-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3137-fs-vector-callbacks.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3138-array-large-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3139-regex-native-deep-alternatives.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3140-array-dense-access.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3141-map-string-key-hash.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3150-integer-remainder.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3151-array-push-writes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3170-number-conversion-fast-paths.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3171-method-census-data-writes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/400-fib.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/401-mutual-recursion.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/402-string-functions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/403-void-and-params.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4030-runtime-object-truthiness.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4031-event-emitter-long-tuples.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4032-inline-rc-fast-paths.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/404-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4040-adapted-function-identity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4041-adapted-function-properties.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4042-object-is-union-subclass.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4043-nonnull-missing-element.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4044-adapted-callback-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4045-optional-element-projections.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4046-captured-parameter-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4047-captured-parameter-rebinding.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/405-params-optional.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/406-params-defaults.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4060-cycle-shared-instance/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4060-stack-union-reads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4061-cycle-evaluation-order/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4061-nullable-ref-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4062-cycle-tdz-read/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4063-cycle-hoisted-calls/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4064-cycle-classes-after-init/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4065-cycle-init-throws/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4066-cycle-top-level-tdz/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4067-dynamic-import-cycle-tdz/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/407-params-rest.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/408-params-ctors-inheritance.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4080-optional-read-presence-tests.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4080-string-index-bounds.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4081-hoisted-function-tdz.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4081-string-index-unproven.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4082-hoisted-function-tdz-uncaught.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4083-dynamic-import-failure/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4084-record-optional-field-copies.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4085-generator-loop-close.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4086-optional-capture-defaults.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4088-class-static-tdz.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4089-class-wrapper-tdz.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/409-params-async-generics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4090-computed-key-tdz.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4091-class-evaluation-deferred.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/410-params-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4140-array-callback-split-visit.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4141-array-callback-ambient-receiver/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4142-array-callback-factories.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4143-union-refinement-intersection-arms.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/420-dead-strip-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4290-acyclic-immutable-trees.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4291-acyclic-constructor-escapes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4292-acyclic-readonly-bypass.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4293-acyclic-dynamic-writes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4294-console-line-sizes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4295-console-template-parts.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4296-console-glued-long-parts.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4410-inline-object-allocation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4411-nullable-ref-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4412-nullable-record-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4413-cycle-old-late-death.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4413-nullable-null-and-undefined.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4414-cycle-old-weak-keys.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4414-nullable-string-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4415-identity-borrowed-operands.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4415-nullable-container-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4431-exception-pending-contexts.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4432-checked-downcast-failures.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4451-int32-field-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4452-int32-field-dynamic-writes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4453-int32-closed-locals.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4471-unassigned-field-reads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4476-string-ascii-header-fact.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4477-buffer-write-ascii-runs.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4478-string-large-index-reads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4481-array-optional-push.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4482-instanceof-static-class-optional.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4483-array-splice-statement.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4484-array-length-reset.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4485-array-splice-optional-item.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4486-array-field-element-borrows.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4487-array-literal-optional-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4520-optional-guard-narrowing.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4521-array-callback-element-presence.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4522-captured-parameter-lifetimes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4523-array-pop-removal.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4524-array-callback-supertype-params.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4541-nullable-wrap-borrows.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4542-preserving-call-borrows.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4543-walk-borrowed-locals.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4544-checked-cast-aliases.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4545-borrowed-returns.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4546-rebound-borrowed-params.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4560-field-store-borrowed-receivers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4561-virtual-borrowed-parameters.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4562-string-self-concat-move.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4563-array-read-projection-receivers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4564-literal-choice-strings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4568-for-of-hole-elements.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4569-shorthand-missing-elements.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4570-map-lookup-default-record.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4591-weak-keys-union-records.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4592-cycle-const-from-import/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4593-weak-keys-empty-objects.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4594-union-class-field-mixed-types.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4595-union-class-field-optional-receiver.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4596-error-subclass-int-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4596-tdz-nullable-forward-capture.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4597-callback-field-method-name.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4598-live-array-ref-element-access.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4598-map-set-clear-reuse.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4598-os-available-parallelism.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4601-cycle-holders.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4602-constructor-escape-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4610-array-ext-dyn-refresh.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4620-optional-chain-borrowed-receivers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4621-edge-preserving-callees/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4650-stale-property-narrowing.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4651-map-string-get-entry.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4652-stale-closure-binding-narrowing.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4660-typed-rest-spread-forwarding.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4671-scoped-array-read-borrows.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4690-cycle-bypass-long-lived.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/500-array-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/501-array-push-pop.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/502-array-for-of.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/503-array-functions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/504-array-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/510-array-map-filter-foreach.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/511-array-indexof-includes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/512-array-join-chains.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/513-array-methods-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/514-array-find-some-every.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/515-array-flatmap.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/516-array-reduce.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/517-array-hof-index-args.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/518-array-sort.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/518-promise-void-union-callbacks.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/519-array-from-length.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/519-promise-union-await-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/520-map-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/521-map-number-keys.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/522-map-foreach.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/523-map-ref-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/524-map-cycles.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/525-map-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/526-set-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/527-set-foreach.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/528-set-seeded.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/529-map-seeded.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/530-record-arrays.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/531-record-array-hofs.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/532-record-arrays-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/533-array-element-cycles.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/534-record-width-subtyping.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/535-object-statics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/536-map-seed-array.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/537-map-iter-drains.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/538-map-set-for-of.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/540-tuples-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/541-ref-array-json.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/542-union-element-arrays.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/600-closures-basic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/601-closures-loops.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/602-closures-identity-recursion.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/603-closures-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/604-closures-for-of.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/605-closures-forward-capture-tdz.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/700-classes-basic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/701-classes-composition.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/702-classes-this-capture.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/703-classes-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/710-inheritance-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/711-inheritance-dispatch.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/712-inheritance-instanceof.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/713-inheritance-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/720-accessors-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/721-accessors-eval-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/722-accessors-inheritance.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/723-accessors-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/750-cycle-closure-box.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/751-cycle-records-mutual.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/752-cycle-classes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/753-cycle-owned-arrays.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/754-cycle-external-ref.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/755-cycle-async-promise.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/756-cycle-inheritance.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/757-cycle-cross-generation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/760-any-arithmetic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/761-any-objects.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/762-any-boundary.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/763-any-flow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/764-any-async.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/765-any-optional-chain.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/766-any-union-boundary.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/767-string-literal-keys.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/768-any-uninitialized.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/800-switch-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/801-switch-lazy-tests.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/802-switch-loops.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/803-switch-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/804-switch-braced-blocks.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/810-do-while.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/820-multi-decl.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/830-let-uninitialized.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/900-records-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/901-records-eval-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/902-records-functions-closures.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/903-records-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/904-records-optional-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/905-records-optional-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/906-records-utility-types.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/907-records-utility-generics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/908-records-index-signatures.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/909-records-index-json.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/910-records-index-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/911-records-index-dot-access.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/912-unknown-slots.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/913-records-index-iteration.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/914-records-from-entries.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/915-unknown-tostring-eq.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/916-unknown-bytes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/917-record-array-index-dot.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/950-modules-basic/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/951-modules-diamond/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/952-modules-cross/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/953-modules-default/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/954-modules-reexport/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/957-builtins-namespace.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/960-generics-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/961-generics-recursion.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/962-generics-closures.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/963-generics-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/964-generics-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/965-generics-async.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/965-unions-retag.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/966-unions-retag-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/967-record-field-widening.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/968-jsval-lift.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/969-unions-arm-matrix.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/970-unions-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/971-unions-switch.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/972-unions-nested.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/973-unions-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/974-unions-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/975-unions-undefined.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/976-unions-null.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/977-unions-unit-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/978-unions-nullish.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/979-unions-optional-chaining.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/980-exceptions-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/981-exceptions-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/982-exceptions-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/983-exceptions-control-flow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/984-exceptions-finally.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/985-exceptions-call-chains.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/986-exceptions-uncaught.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/987-exceptions-result-unions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/990-process-basics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/991-process-exit.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/992-fs-roundtrip.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/993-fs-readdir.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/994-fs-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/995-fs-uncaught.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/996-fs-rc-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/997-fs-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/998-process-env.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/abstract-property-dispatch.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/arguments-arrow-capture.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/arguments-reexport/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-exits.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-mutation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-strings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-buffer-conversions.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-buffer-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-checked-callback-results.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-checked-constructor.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-concat-widening.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-fill-unit-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-from-checked.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-from-value.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-isarray-value/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-numeric-own-keys.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-optional-number-write-index.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-primitive-ordering.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-read-helper-effects.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-refined-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-sort-runs.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-sort-runtime-comparator.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-sort-unknown-comparator.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-storage-transitions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-truncate-reuse.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/async-backend-factory.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/async-local-typed-results.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/atomics-integer-operations.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/bigint-checked-casts.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/bigint-checked-storage.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/bigint-union-conversion.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/boxed-error-rethrows.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/buffer-codec-boundaries.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/buffer-primitive-predicate.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/builtin-prototype-method-values.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/byte-loop-bounds.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/byte-number-pipeline.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/byte-record-windows.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-argument-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-control-flow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-owned-boundaries.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-projections.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-union-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-virtual-optionals.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-module-members.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-properties.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-property-cycles.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-reexport/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/captured-class-refinement.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/catch-capture.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/caught-class-identity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/caught-standalone-class.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/caught-system-error-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-addition.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-any-addition.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-array-assignment.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-array-flat/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-bitwise/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-builder-cycles.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-byte-storage/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-callback-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-class-descriptors.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-class-factory.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-collection-iterators.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-collection-symbol-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-dispatch-input-lifetimes.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-increment/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-inherited-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-iterator-consumption.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-numeric-arithmetic.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-object-module-alias.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-optional-calls.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-promise-recovery.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-proxy-callback/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-record-constructor.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-renderer-defaults.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-rest-function-adapters.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-storage-transitions.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-symbol-array.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-value-input-lifetimes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-accessor-returned-function.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-array-optional-return.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-bracket-method-calls.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-brand-overload.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-callback-replacement.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-callback-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-checked-composites.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-checked-upcast.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-collection-insertion.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-computed-presence.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-computed-symbols.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-covariant-returns.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-curried-factory.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-data-descriptors.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-inherited-statics.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-parameter-base.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-record-base.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-recursive-statics.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-static-members.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-function-base/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-instance-constructor.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-interface-protocols.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-interface-refinements.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-json-checked.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-local-function-base.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-method-spreads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-narrowed-views.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-property-call-values.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-prototype-data.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-prototype-descriptor-copy.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-specialized-computed-base.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-static-data.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-subclass-assertions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-super-surplus-spread.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-symbol-accessors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-symbol-cache.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-value-constructor-exceptions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/closure-nullable-union-return.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/closure-union-locals.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-cycles.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-maps.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-missing.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-sets.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-copy-identities.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-data-unions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion-mappers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion-protocol/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion-references.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-storage-copies.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-value-keys.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/compound-field-receivers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/compound-presence-guards.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/conditional-tuple-destructuring.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/console-imports.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/console-native-value.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/const-enum-module-cycle/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/constant-callback-dispatch.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/constant-module-globals/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/constant-number-remainders.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/contextual-array-union-write.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/contextual-return-layouts.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/counted-loop-numbers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/counted-loop-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/crypto-hash-optional-input.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/cycle-generations-long-lived.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/cycle-growth-yield.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/date-checked-native.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/declared-index-spread.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/deep-reference-teardown.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/default-undefined-parameters.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/deferred-field-updates.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/deferred-registry-many.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/derived-numeric-updates.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/destructure-call-assignment.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/destructure-inferred-row-defaults.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/destructure-union-arrays.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/dynamic-function-descriptors.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-cause-writes.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-inherited-message.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-inherited-name.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-property-writes.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-prototype-tostring.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-stack-frames.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-stack-limit.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-tostring-overrides.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-values-inspect.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/exact-index-round-trip.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/expression-runtime-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fiber-switch-stress.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fiberless-async-ordering.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fiberless-async-unhandled.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/field-assignment-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/file-handle-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/file-read-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/file-url-percent-decoding.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/final-field-borrows.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-multiple-bindings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-multiple-lexical-bindings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-of-checked-iterator.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-of-subclass-elements.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/forward-generic-signatures.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fresh-array-union-layout.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/frozen-checked-dictionaries.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-native-realpath.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-read-encodings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-remove-readonly.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-write-string-bytes-union.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-apply-value.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-constructor-global.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-constructor-kinds/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-custom-prototype.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-custom-to-string.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-object-assign.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-own-prototype/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-checked-protocol.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-checked-return.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-custom-delegation/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-default-return-pattern.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-delegation-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-inferred-date.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-mixed-checked-channels.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-untyped-consumer/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-base-specializations.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-binding-ownership.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-class-js-functions/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-class-recovery.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-namespace-factories/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-nullable-collections.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-pattern-bindings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-record-index.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-visitor-void.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-error-subclasses.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-runtime-probes.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-stored-probes.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-string-cache/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-symbol-cache/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/guarded-native-iterables.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/heap-input-aliases.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/heap-input-collections.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/in-array-runtime-index.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/indexed-assignment-values.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/indexed-assignment-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/indexed-element-field-reads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-array-assignment-values.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-class-default.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-compound-values.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-conditional-class.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-error-fields.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-map-patterns.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-method-override.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-partial-destructuring.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-primitive-properties.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-record-return.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-recursive-record.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-undefined-field.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/input-lifetime-intervals.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/input-lifetimes-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/instanceof-class-record-union.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-flow-arithmetic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-loop-forms.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-view-control.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-view-numbers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-view-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/intl-grapheme-conformance/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/intl-grapheme.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/iterator-typed-returns.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-abort-portable.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-array-constructor.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-array-default-buffer.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-array-iterators.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-arrow-bind.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-buffer-callback-brand.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-callable-proxy.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-chained-native-results.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-array-iterator.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-array-reference.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-number-negation.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-sort-result.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-child-error-listener.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-cjs-callable-snapshots/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-added-parameters.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-checked-overrides.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-computed-fields.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-enumeration.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-field-accessor-override.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-fluent-overrides.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-late-method-values.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-member-dispatch.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-return-shapes.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-shadowed-methods.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-stored-method-receiver.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-subclass-properties.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-symbol-spread.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-computed-prototype-additions.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-constructor-returned-callable.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-constructor-spread.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-dataview-dispatch.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-declared-fields.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-default-listener-arguments.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-default-options/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-deferred-field-initializers.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-deferred-registry-effects.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-derived-constructor-hoisting.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-dormant-array-write.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-dormant-overrides.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-expando-records.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-implicit-call-results.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inferred-callback-exports/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inferred-class-array-return.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inferred-object-values.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inherited-field-storage.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inherited-parameter-abi.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-iterable-spread.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-loose-dynamic-primitives.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-map-object-seeds.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-member-increment.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-module-function-values.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-mutable-null-members.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-nested-native-descriptors.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-normalize-dispatch.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-nullish-inherited-fields.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-object-receiver-storage.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-object-returning-constructors.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-object-shared-arrays.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-omitted-typed-arguments.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-open-binding-writes.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-optional-class-fields.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-optional-member-call.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-primitive-union-addition.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-all-values.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-catch-handler.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-finally-order.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-pending-reactions.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-prototype-host-boundary.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-reflect-receivers.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-regex-record-captures.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-scalar-iterables.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-shared-method-dispatch.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-specialized-field-method.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-static-accessors.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-static-method-values.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-static-registries.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-super-accessor-initialization.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-uninitialized-native-fields.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-guarded-map-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-output-bulk.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-runtime-options.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-stringify-value.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-typed-parse-direct.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/literal-switch-dispatch.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/live-reference-shared-converters.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/llvm-read-receiver-lifetime.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-call-spreads.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-declaration.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-evaluation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-inheritance.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-lifetimes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-namespace/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-prototype-data.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-specialization.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-unknown.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-union-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/locale-compare-root-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/logical-assignment-dynamic.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/logical-assignment-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/logical-runtime-optional-record.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/loop-reference-lifetimes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-checked-boundary/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-checked-seed.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-number-keys-dense.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-read-lifetimes-exits.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-read-lifetimes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-seeds-and-spreads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-typed-array-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/math-function-values.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/missing-read-lambda-results.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/missing-read-narrowed-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/missing-read-number-conversions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/module-byte-loops.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/module-fallback-functions/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/narrowed-nullish-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-borrowed-find-last.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-borrowed-slice.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-copying-methods.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-fill-copywithin.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-frozen-noops.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-index-boundaries.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-integrity.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-length.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-named-properties.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-prototype/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-read-lifetimes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-reduce-find-last.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-search-from-index.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-splice-coercion.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-splice-flat.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-buffer-coercion.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-callback-dispatch.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-array-boundaries.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-cache.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-properties.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-property-cycles.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-property-order.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-type-predicates.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-factory-records.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-method-values.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-method-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-descriptors.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-for-in-minimal.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-property-attributes.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-prototype.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-property-names.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-proxy-env.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-arena-reuse.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-bounded-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-buffer-consumers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-cancel-hot.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-class-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-clone-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-commonjs.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-delayed-messages.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-environment.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-error.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-exception-state.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-exit-listeners.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-io.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-loop-cancellation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-message-graphs.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-messages.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-poll-exceptions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-port-lifetime.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-process-exit.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-publish-classes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-publish-refusals.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-published-graphs.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-references.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-roots/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-shared-views.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-stack-overflow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-exception-state.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-loop.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-recursion.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-suspended.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-tested-loops.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-wait.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-typed-arrays.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nested-map-cycles.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nested-map-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/never-returning-calls.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/next-tick-commonjs-entry.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-buffer-encoding-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-buffer-encoding.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-kdf-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-kdf-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-kdf.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-sha2.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-deep-equality-properties.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-deep-equality.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-deep-equality.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-files-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-files.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-imports.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-parse-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-parse.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-esm-metadata/main.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-file-url-buffer.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-file-url-errors.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-file-url-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-callbacks.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-errors.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-options.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-promise-errors.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-promises.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs-callbacks.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs-errors.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs-options.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-callbacks.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-errors.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-promises.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-symlinks.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-no-error-assertions-coercion.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-no-error-assertions.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-no-error-assertions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-parseargs.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-string-decoder.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text-environment.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text-validation.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-system-error-validation.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-system-errors.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-system-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-codec-properties.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-encode-into.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities-coercion.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities-validation.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-authority-coercion.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-authority.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-factories.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-factory-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-mutation-coercion.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-mutation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-util-types.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-util-types.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-util-types.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/non-null-class-iteration.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nonnull-element-arguments.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nonnull-forwarded-class-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullable-object-extension.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullish-asserted-class-arms.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullish-assignment-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullish-long-chain.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/number-parse-statics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/number-predicates-unknown.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/numeric-call-specialization.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-enumeration-array-reads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-from-checked-entries.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-inherited-to-string.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-key-indexes.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-prototype-identity.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-reexport/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-spread-computed.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/opentui-byte-queue.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-callback-arity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-class-flows.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-element-defaults.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-flag-comparisons.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-native-callables.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-node-list-iteration.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-string-index/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/path-to-file-url-options.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/performance-presence.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/primitive-and-function-descriptors.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/primitive-union-string.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-builtin-values.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-env-computed-keys.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-hrtime.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-named-signals.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-handler-throws.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-loop.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-module.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-monitor.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-rejection.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-sync.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-version-pin.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-versions-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/projected-collection-lifetimes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/promise-checked-rejections.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/promise-resolve-void.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/prototype-method-overrides.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/prototype-named-data-records.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-field-presence.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-key-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-optional-json-presence.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-presence-copies.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-presence-delete-json.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-unchecked-read-presence.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-unknown-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/reflect-own-keys.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/reflect-record-union-keys.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/reflect-typed-record-keys.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-callback-replacements.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-callback-values.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-checked-casts.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-checked-storage.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-exec-long-subject.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-input-lifetimes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-native-matcher.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-optional-captures.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-optional-templates.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-split-captures.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-text-paths.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regexp-constructor-repeat.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regexp-optional-constructor.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regexp-string-coercion.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/renderer-export-dictionaries.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/renderer-null-state.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/renderer-specializations.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/repeat-and-typed-read-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/rest-optional-array-arguments.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/rest-optional-elements.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/return-void-through-finally.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/runtime-optional-string-flows.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/scalar-string-slices.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-checked-methods.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-checked-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-iterator-seed-references.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-iterator-seeds.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-optional-seeds.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/small-collection-transitions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-depth-async-bodies.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-async.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-caught.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-finally.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-shapes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-uncaught.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/static-field-updates/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/static-method-receivers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stdio-values.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stdio-write-errors.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stdio-write-overrides.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stored-native-builtins.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stored-object-helpers.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-code-points.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-concat-number-parts.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-construction-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-boundaries.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-evaluation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-iteration.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-operations.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-normalize.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-pattern-replacement.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-split-checked-separator.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-split-traversal.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/structural-class-properties.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/structured-text-boundaries.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/structured-text-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/switch-integer-dispatch.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-checked-boundary/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-class-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-class-fields/main.cjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-class-methods/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-fields-deferred-factory.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-fields-inferred.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-object-properties/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/synchronous-callback-lifetimes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/terminal-stream-properties.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/text-codec-values/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/text-codec-var.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/text-encode-into-boundaries.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/timers-clear-many.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-and-string-search.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-array-union.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-callback-visitation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-forof-visitation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-bulk-conversion.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-byte-io.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-checked-index.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-alias.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-identity.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-union.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-values.mjs.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-dynamic-methods.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-integer-widths.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-nan-coded-reads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-numeric-import.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-present-reads.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-reversed-storage.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-unknown.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-collection-iterator-references.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-collection-iterators.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-collection-views/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-index-arguments.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-prototype-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-rest-callables.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-rest-filtered-return.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typedarray-native-inputs.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typeof-checked-comparison.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/uint8array-sort-domains.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unicode-case-paths.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unicode-process-argv.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-discriminant-width.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-literal-scalar-discriminants.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-literal-slot-conversion.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-nested-layout-discriminant.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-optional-semantic-identity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-record-clone.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-record-structural-copy.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-reference-comparison.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-array-holes.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-collections.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-object-enumeration.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-record-views.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/url-runtime-base.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/utf8-span-decoding.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/util-parseargs-wrapped/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-map-array-buffer.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-map-fresh-array.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-map-native.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-native-class-identity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-set-native.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/corpus/worker-class-instance-clone.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/accessors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/any-unit-exit.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/any.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/arrow-bind.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/assert-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/async-iterator-handles.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/bigint-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/blocked-binding-cascade.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/catch-bindings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/checker-panic-infinity.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/checker-panic-tuple.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/child-process.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-esm-lexer-require-reached/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-module-mutation/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-require-cycle/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-require-esm-type-link/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-require-tdz/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-decorators.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-interface-refinements.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-prototype-reflection.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/collection-iterator-helpers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/collection-views.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/component-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/comptime.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/create-require.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-class-early/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-default-export/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-namespace-import/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-var-early/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dataview.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/date-formatters.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/date-union-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deep-binary-nesting.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deep-nesting-preflight.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/default-export.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deferred-class-binding/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deferred-class-receiver/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/delete-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/destructuring-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-import-static.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-import/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-representable-types.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-surface.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-internal.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-listeners.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-stream-internal.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-unrestricted.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-emit-override.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/enums.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/es2025-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/esm-syntax-commonjs/main.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/exceptions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/fetch-static.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-narrow.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate-dyn.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate-dynamic.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate-island.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/function-forms.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/function-limits.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generator-method-overrides.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generic-methods.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generic-signature-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generic-value-bindings.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generics.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/http2-module.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/http2-response-trailers.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/identity-collection-keys.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-defer-type/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-defer/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-equals-require.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-forms/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-bare.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-computed.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-destructure.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-rest.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-write.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/imports.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/index-signature-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/inheritance.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/intersection-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/intl-segmenter.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/intl.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/invalid-package-config/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/island-boundary-slots.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/island.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/iterator-slot-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsdoc-import-require.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-dyn.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-module-comment/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-modules/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-shape/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-boundaries.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-require-binding-esm.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/maps-surface.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/maps.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/merged-namespace-collect-probe.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/mixed-compare.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/mixins.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/module-out-of-scope.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/module-resolution-introspection.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/multiple-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/namespaces.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/new-target-field-initializer.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/no-error-assertion-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/node-fallback-fence.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/npm-imports/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ns-import-object/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/nullish-class-defaults.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/object-create-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/optional-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/options-record.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/outside-world.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/overload-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/overloaded-function-values.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/pkg-import-fences/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/private-members.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/promise-all-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/record-width.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/regex.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/retained-generic-rest-order.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/runtime-optional-capture-chain.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/runtime-optional-refined-union.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/self-returning-function.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/sets.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/spi-off/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/spread-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/spread-runtime-optional.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/statements.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/static-blocks.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/stdlib-fence.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/stdlib.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/text-codec-value.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/text-decoder-label.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/top-level-await-commonjs/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/top-level-await-implicit-module-nested-require.js.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/top-level-await-module-leak/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/tuples.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/unassigned-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/union-clone-override-width.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/unions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/unrelated-class-assertion.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/url-mutation-object-plus.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/url-mutation-operator.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/url-mutation-runtime-key.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/utility-types.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/var-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/argv-env.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/child-execfile.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/child-stdin-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/child-stdin.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/crypto-kdf.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/deep-equality.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/env-files.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fenced.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fetch-static.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/file-url-conversion.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-links.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-statfs.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-timestamps.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/import-fences.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/no-error-assertions.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/path-os.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/stream-capture.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/style-text.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/system-errors.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/terminal-error-fields.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/text-encoding.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/text-utilities.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/url-factories.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/url-getters.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/url-mutation.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/util-types.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2465-getter-table/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2466-getter-star/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2467-star-barrel/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2468-defineprop-exports/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2469-bundle-offender/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2556-toesm-external/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2557-toesm-drift/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/abandoned-handles/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/any-chaining/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/assert-shims/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/buffer-shims/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/builtin-shims/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/bytes-exit/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/callbacks/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chain/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-esm-named/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-lexer-aligned/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-lexer-invisible/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-named/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/class-construct/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/create-require/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/crypto-shims/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dotfolder/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dual-entry/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dual-package-kinds/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dynamic-import-local/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dynamic-import/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esbuild-require/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esm-entries/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esm-missing-default/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esm-missing-export/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/fetch-destructure/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/fs-shims/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hoisted-workspace/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/import-refusal/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-array-exits/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-instanceof-regexp/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-json-stringify/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-registry/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-timers/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-web-plumbing/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/jsval-into-dyn/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/jsval-iterate/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/lazy-traps/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/misc-shims/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/namespace/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-async-events/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-commonjs-metadata/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-crypto-kdf/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-deep-equality/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-async/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-subscriber-throw/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-tracing/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-transform-throw/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-env/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-esm-metadata/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-event-emitter/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-file-url-conversion/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-fs-descriptors/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-mime-errors/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-mime/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-no-error-assertions/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-parseargs/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-promise-timers/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-string-decoder/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-style-text/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-system-errors/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-text-encoding/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-text-utilities/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-timers-unref/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-url-authority/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-url-factories/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-url-mutation/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-util-adapters/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-util-types/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-encoding/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-errors/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-lifecycle/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-pipe-abort/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-pipe-errors/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-pipes/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-queues/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-readable-lifecycle/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-readers/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-tee/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-transforms/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/npm-reexport/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/package-imports/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/promise-bridge-forever/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/promise-bridge-unhandled/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/promise-bridge/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/scoped-nested/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/self-name/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/side-effect-order/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/stream-shims/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/top-level-await-pending-exit-code/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/top-level-await-pending-exit-listener/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/typed-callbacks/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/util-shims/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/web-streams/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/workspace-copied/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/workspace-linked/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/workspace-unclean/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/zlib-shims/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/indexed-loose/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/indexed-strict/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/json-any-broken/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/json-any/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/null-floor/main.ts.json create mode 100644 packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/project-paths/main.ts.json diff --git a/packages/compiler/src/frontend/program.ts b/packages/compiler/src/frontend/program.ts index a16965d4c..20e139e63 100644 --- a/packages/compiler/src/frontend/program.ts +++ b/packages/compiler/src/frontend/program.ts @@ -13,7 +13,7 @@ * the order-parity suite holding both lanes to identical diagnostics and * module order over the whole corpus. The phase-4 flip deleted the 5.9.3 * pipeline; its recorded verdicts live on as the canary baselines - * (test/ts7/baselines/order-parity.json), and the rationale prose the old + * (test/ts7/baselines/order-parity/), and the rationale prose the old * program.ts carried was folded in here where behavior demands it. * * Differences from the retired 5.9.3 lane, each deliberate and each diff --git a/packages/compiler/test/ts7/baselines/order-parity.json b/packages/compiler/test/ts7/baselines/order-parity.json deleted file mode 100644 index b7f4a71ef..000000000 --- a/packages/compiler/test/ts7/baselines/order-parity.json +++ /dev/null @@ -1,15912 +0,0 @@ -{ - "entries": { - "/tests/corpus/001-hello.ts": { - "order": [ - "/tests/corpus/001-hello.ts" - ], - "diags": [] - }, - "/tests/corpus/002-log-args.ts": { - "order": [ - "/tests/corpus/002-log-args.ts" - ], - "diags": [] - }, - "/tests/corpus/100-number-format.ts": { - "order": [ - "/tests/corpus/100-number-format.ts" - ], - "diags": [] - }, - "/tests/corpus/1000-json-stringify-basics.ts": { - "order": [ - "/tests/corpus/1000-json-stringify-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1001-json-escapes-unicode.ts": { - "order": [ - "/tests/corpus/1001-json-escapes-unicode.ts" - ], - "diags": [] - }, - "/tests/corpus/1002-json-parse-cast.ts": { - "order": [ - "/tests/corpus/1002-json-parse-cast.ts" - ], - "diags": [] - }, - "/tests/corpus/1003-json-parse-unions.ts": { - "order": [ - "/tests/corpus/1003-json-parse-unions.ts" - ], - "diags": [] - }, - "/tests/corpus/1004-json-parse-errors.ts": { - "order": [ - "/tests/corpus/1004-json-parse-errors.ts" - ], - "diags": [] - }, - "/tests/corpus/1005-json-nested.ts": { - "order": [ - "/tests/corpus/1005-json-nested.ts" - ], - "diags": [] - }, - "/tests/corpus/1006-json-fs-config.ts": { - "order": [ - "/tests/corpus/1006-json-fs-config.ts" - ], - "diags": [] - }, - "/tests/corpus/1007-json-rc-stress.ts": { - "order": [ - "/tests/corpus/1007-json-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/1008-json-null-arms.ts": { - "order": [ - "/tests/corpus/1008-json-null-arms.ts" - ], - "diags": [] - }, - "/tests/corpus/1009-json-optional-fields.ts": { - "order": [ - "/tests/corpus/1009-json-optional-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/101-arithmetic.ts": { - "order": [ - "/tests/corpus/101-arithmetic.ts" - ], - "diags": [] - }, - "/tests/corpus/1010-json-stringify-space.ts": { - "order": [ - "/tests/corpus/1010-json-stringify-space.ts" - ], - "diags": [] - }, - "/tests/corpus/1011-json-unknown-typeof.ts": { - "order": [ - "/tests/corpus/1011-json-unknown-typeof.ts" - ], - "diags": [] - }, - "/tests/corpus/102-comparisons.ts": { - "order": [ - "/tests/corpus/102-comparisons.ts" - ], - "diags": [] - }, - "/tests/corpus/1020-async-basics.ts": { - "order": [ - "/tests/corpus/1020-async-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1021-async-ordering.ts": { - "order": [ - "/tests/corpus/1021-async-ordering.ts" - ], - "diags": [] - }, - "/tests/corpus/1022-async-exceptions.ts": { - "order": [ - "/tests/corpus/1022-async-exceptions.ts" - ], - "diags": [] - }, - "/tests/corpus/1023-async-rc-stress.ts": { - "order": [ - "/tests/corpus/1023-async-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/1024-async-pending-exit.ts": { - "order": [ - "/tests/corpus/1024-async-pending-exit.ts" - ], - "diags": [] - }, - "/tests/corpus/1025-async-promise-capture.ts": { - "order": [ - "/tests/corpus/1025-async-promise-capture.ts" - ], - "diags": [] - }, - "/tests/corpus/1026-throw-promise.ts": { - "order": [ - "/tests/corpus/1026-throw-promise.ts" - ], - "diags": [] - }, - "/tests/corpus/1027-async-return-promise.ts": { - "order": [ - "/tests/corpus/1027-async-return-promise.ts" - ], - "diags": [] - }, - "/tests/corpus/1028-async-return-record-literals.ts": { - "order": [ - "/tests/corpus/1028-async-return-record-literals.ts" - ], - "diags": [] - }, - "/tests/corpus/1029-async-eager-chains.ts": { - "order": [ - "/tests/corpus/1029-async-eager-chains.ts" - ], - "diags": [] - }, - "/tests/corpus/103-ternary.ts": { - "order": [ - "/tests/corpus/103-ternary.ts" - ], - "diags": [] - }, - "/tests/corpus/104-ternary-empty-arrays.ts": { - "order": [ - "/tests/corpus/104-ternary-empty-arrays.ts" - ], - "diags": [] - }, - "/tests/corpus/1050-comptime-tables.ts": { - "order": [ - "/tests/corpus/1050-comptime-tables.ts" - ], - "diags": [] - }, - "/tests/corpus/1051-comptime-strings.ts": { - "order": [ - "/tests/corpus/1051-comptime-strings.ts" - ], - "diags": [] - }, - "/tests/corpus/1052-comptime-records.ts": { - "order": [ - "/tests/corpus/1052-comptime-records.ts" - ], - "diags": [] - }, - "/tests/corpus/1053-comptime-json.ts": { - "order": [ - "/tests/corpus/1053-comptime-json.ts" - ], - "diags": [] - }, - "/tests/corpus/1054-comptime-modules/main.ts": { - "order": [ - "/tests/corpus/1054-comptime-modules/tables.ts", - "/tests/corpus/1054-comptime-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/110-number-radix.ts": { - "order": [ - "/tests/corpus/110-number-radix.ts" - ], - "diags": [] - }, - "/tests/corpus/1100-island-eval-basics.ts": { - "order": [ - "/tests/corpus/1100-island-eval-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1101-island-marshal-unicode.ts": { - "order": [ - "/tests/corpus/1101-island-marshal-unicode.ts" - ], - "diags": [] - }, - "/tests/corpus/1102-island-rc-stress.ts": { - "order": [ - "/tests/corpus/1102-island-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/111-record-entries.ts": { - "order": [ - "/tests/corpus/111-record-entries.ts" - ], - "diags": [] - }, - "/tests/corpus/1110-math-members.ts": { - "order": [ - "/tests/corpus/1110-math-members.ts" - ], - "diags": [] - }, - "/tests/corpus/1111-math-random.ts": { - "order": [ - "/tests/corpus/1111-math-random.ts" - ], - "diags": [] - }, - "/tests/corpus/1112-number-methods.ts": { - "order": [ - "/tests/corpus/1112-number-methods.ts" - ], - "diags": [] - }, - "/tests/corpus/1113-string-methods.ts": { - "order": [ - "/tests/corpus/1113-string-methods.ts" - ], - "diags": [] - }, - "/tests/corpus/1114-string-unicode-island.ts": { - "order": [ - "/tests/corpus/1114-string-unicode-island.ts" - ], - "diags": [] - }, - "/tests/corpus/1115-parse-globals.ts": { - "order": [ - "/tests/corpus/1115-parse-globals.ts" - ], - "diags": [] - }, - "/tests/corpus/1116-island-static-mix.ts": { - "order": [ - "/tests/corpus/1116-island-static-mix.ts" - ], - "diags": [] - }, - "/tests/corpus/1117-typeof-static-union.ts": { - "order": [ - "/tests/corpus/1117-typeof-static-union.ts" - ], - "diags": [] - }, - "/tests/corpus/1118-object-spread-conditional.ts": { - "order": [ - "/tests/corpus/1118-object-spread-conditional.ts" - ], - "diags": [] - }, - "/tests/corpus/1119-switch-union.ts": { - "order": [ - "/tests/corpus/1119-switch-union.ts" - ], - "diags": [] - }, - "/tests/corpus/112-class-descriptor-key.js": { - "order": [ - "/tests/corpus/112-class-descriptor-key.js" - ], - "diags": [] - }, - "/tests/corpus/1120-web-globals-encoders.ts": { - "order": [ - "/tests/corpus/1120-web-globals-encoders.ts" - ], - "diags": [] - }, - "/tests/corpus/1121-infinity-number-tostring.ts": { - "order": [ - "/tests/corpus/1121-infinity-number-tostring.ts" - ], - "diags": [] - }, - "/tests/corpus/1122-any-captures.ts": { - "order": [ - "/tests/corpus/1122-any-captures.ts" - ], - "diags": [] - }, - "/tests/corpus/1123-any-conditional-spread.ts": { - "order": [ - "/tests/corpus/1123-any-conditional-spread.ts" - ], - "diags": [] - }, - "/tests/corpus/1124-union-narrowed-retag.ts": { - "order": [ - "/tests/corpus/1124-union-narrowed-retag.ts" - ], - "diags": [] - }, - "/tests/corpus/113-promise-checked-exits.ts": { - "order": [ - "/tests/corpus/113-promise-checked-exits.ts" - ], - "diags": [] - }, - "/tests/corpus/114-live-record-delete.ts": { - "order": [ - "/tests/corpus/114-live-record-delete.ts" - ], - "diags": [] - }, - "/tests/corpus/115-array-compound.js": { - "order": [ - "/tests/corpus/115-array-compound.js" - ], - "diags": [] - }, - "/tests/corpus/116-text-decoder-runtime.js": { - "order": [ - "/tests/corpus/116-text-decoder-runtime.js" - ], - "diags": [] - }, - "/tests/corpus/117-weak-cache-cycle.js": { - "order": [ - "/tests/corpus/117-weak-cache-cycle.js" - ], - "diags": [] - }, - "/tests/corpus/118-fs-stored-callbacks.cjs": { - "order": [ - "/tests/corpus/118-fs-stored-callbacks.cjs" - ], - "diags": [] - }, - "/tests/corpus/119-native-patterns.js": { - "order": [ - "/tests/corpus/119-native-patterns.js" - ], - "diags": [] - }, - "/tests/corpus/1200-regex-test-basics.ts": { - "order": [ - "/tests/corpus/1200-regex-test-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1201-regex-replace.ts": { - "order": [ - "/tests/corpus/1201-regex-replace.ts" - ], - "diags": [] - }, - "/tests/corpus/1202-regex-substitutions.ts": { - "order": [ - "/tests/corpus/1202-regex-substitutions.ts" - ], - "diags": [] - }, - "/tests/corpus/1203-regex-split.ts": { - "order": [ - "/tests/corpus/1203-regex-split.ts" - ], - "diags": [] - }, - "/tests/corpus/1204-regex-empty-unicode.ts": { - "order": [ - "/tests/corpus/1204-regex-empty-unicode.ts" - ], - "diags": [] - }, - "/tests/corpus/1205-regex-rc-stress.ts": { - "order": [ - "/tests/corpus/1205-regex-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/1206-regex-dynamic-mix.ts": { - "order": [ - "/tests/corpus/1206-regex-dynamic-mix.ts" - ], - "diags": [] - }, - "/tests/corpus/1300-errors-basics.ts": { - "order": [ - "/tests/corpus/1300-errors-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1301-errors-subclass.ts": { - "order": [ - "/tests/corpus/1301-errors-subclass.ts" - ], - "diags": [] - }, - "/tests/corpus/1302-errors-typed-catch.ts": { - "order": [ - "/tests/corpus/1302-errors-typed-catch.ts" - ], - "diags": [] - }, - "/tests/corpus/1303-errors-rc-stress.ts": { - "order": [ - "/tests/corpus/1303-errors-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/1304-errors-uncaught.ts": { - "order": [ - "/tests/corpus/1304-errors-uncaught.ts" - ], - "diags": [] - }, - "/tests/corpus/1305-errors-async-rejections.ts": { - "order": [ - "/tests/corpus/1305-errors-async-rejections.ts" - ], - "diags": [] - }, - "/tests/corpus/1306-errors-runtime-instances.ts": { - "order": [ - "/tests/corpus/1306-errors-runtime-instances.ts" - ], - "diags": [] - }, - "/tests/corpus/1350-path-normalize-join.ts": { - "order": [ - "/tests/corpus/1350-path-normalize-join.ts" - ], - "diags": [] - }, - "/tests/corpus/1351-path-parts.ts": { - "order": [ - "/tests/corpus/1351-path-parts.ts" - ], - "diags": [] - }, - "/tests/corpus/1352-path-resolve-relative.ts": { - "order": [ - "/tests/corpus/1352-path-resolve-relative.ts" - ], - "diags": [] - }, - "/tests/corpus/1353-os-basics.ts": { - "order": [ - "/tests/corpus/1353-os-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1354-builtin-bare-specifiers.ts": { - "order": [ - "/tests/corpus/1354-builtin-bare-specifiers.ts" - ], - "diags": [] - }, - "/tests/corpus/1355-url-parse.ts": { - "order": [ - "/tests/corpus/1355-url-parse.ts" - ], - "diags": [] - }, - "/tests/corpus/1356-url-file-bridge.ts": { - "order": [ - "/tests/corpus/1356-url-file-bridge.ts" - ], - "diags": [] - }, - "/tests/corpus/1357-fsp-roundtrip.ts": { - "order": [ - "/tests/corpus/1357-fsp-roundtrip.ts" - ], - "diags": [] - }, - "/tests/corpus/1358-crypto-random.ts": { - "order": [ - "/tests/corpus/1358-crypto-random.ts" - ], - "diags": [] - }, - "/tests/corpus/1359-json-module/main.ts": { - "order": [ - "/tests/corpus/1359-json-module/main.ts" - ], - "diags": [] - }, - "/tests/corpus/1360-spawn-sync.ts": { - "order": [ - "/tests/corpus/1360-spawn-sync.ts" - ], - "diags": [] - }, - "/tests/corpus/1361-spawn-events.ts": { - "order": [ - "/tests/corpus/1361-spawn-events.ts" - ], - "diags": [] - }, - "/tests/corpus/1362-spawn-timers.ts": { - "order": [ - "/tests/corpus/1362-spawn-timers.ts" - ], - "diags": [] - }, - "/tests/corpus/1363-spawn-unhandled-error.ts": { - "order": [ - "/tests/corpus/1363-spawn-unhandled-error.ts" - ], - "diags": [] - }, - "/tests/corpus/1364-union-truthiness.ts": { - "order": [ - "/tests/corpus/1364-union-truthiness.ts" - ], - "diags": [] - }, - "/tests/corpus/1365-union-logical.ts": { - "order": [ - "/tests/corpus/1365-union-logical.ts" - ], - "diags": [] - }, - "/tests/corpus/1366-union-equality.ts": { - "order": [ - "/tests/corpus/1366-union-equality.ts" - ], - "diags": [] - }, - "/tests/corpus/1367-destructuring.ts": { - "order": [ - "/tests/corpus/1367-destructuring.ts" - ], - "diags": [] - }, - "/tests/corpus/1368-constructor-functions.ts": { - "order": [ - "/tests/corpus/1368-constructor-functions.ts" - ], - "diags": [] - }, - "/tests/corpus/1369-promise-union.ts": { - "order": [ - "/tests/corpus/1369-promise-union.ts" - ], - "diags": [] - }, - "/tests/corpus/1370-spread.ts": { - "order": [ - "/tests/corpus/1370-spread.ts" - ], - "diags": [] - }, - "/tests/corpus/1371-union-template-tostring.ts": { - "order": [ - "/tests/corpus/1371-union-template-tostring.ts" - ], - "diags": [] - }, - "/tests/corpus/1372-loose-null-tests.ts": { - "order": [ - "/tests/corpus/1372-loose-null-tests.ts" - ], - "diags": [] - }, - "/tests/corpus/1373-union-array-arms.ts": { - "order": [ - "/tests/corpus/1373-union-array-arms.ts" - ], - "diags": [] - }, - "/tests/corpus/140-bitwise-operators.ts": { - "order": [ - "/tests/corpus/140-bitwise-operators.ts" - ], - "diags": [] - }, - "/tests/corpus/1400-typedarray-basics.ts": { - "order": [ - "/tests/corpus/1400-typedarray-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1401-typedarray-slice-set.ts": { - "order": [ - "/tests/corpus/1401-typedarray-slice-set.ts" - ], - "diags": [] - }, - "/tests/corpus/1402-buffer-encodings.ts": { - "order": [ - "/tests/corpus/1402-buffer-encodings.ts" - ], - "diags": [] - }, - "/tests/corpus/1403-buffer-fs.ts": { - "order": [ - "/tests/corpus/1403-buffer-fs.ts" - ], - "diags": [] - }, - "/tests/corpus/1404-zlib-crypto-bytes.ts": { - "order": [ - "/tests/corpus/1404-zlib-crypto-bytes.ts" - ], - "diags": [] - }, - "/tests/corpus/1405-bytes-unions-arrays.ts": { - "order": [ - "/tests/corpus/1405-bytes-unions-arrays.ts" - ], - "diags": [] - }, - "/tests/corpus/1406-dataview-mp4.ts": { - "order": [ - "/tests/corpus/1406-dataview-mp4.ts" - ], - "diags": [] - }, - "/tests/corpus/1407-dataview-bounds.ts": { - "order": [ - "/tests/corpus/1407-dataview-bounds.ts" - ], - "diags": [] - }, - "/tests/corpus/1408-string-indexing.ts": { - "order": [ - "/tests/corpus/1408-string-indexing.ts" - ], - "diags": [] - }, - "/tests/corpus/1409-typedarray-integer-loops.ts": { - "order": [ - "/tests/corpus/1409-typedarray-integer-loops.ts" - ], - "diags": [] - }, - "/tests/corpus/1420-number-statics.ts": { - "order": [ - "/tests/corpus/1420-number-statics.ts" - ], - "diags": [] - }, - "/tests/corpus/1421-number-parse-dynamic.ts": { - "order": [ - "/tests/corpus/1421-number-parse-dynamic.ts" - ], - "diags": [] - }, - "/tests/corpus/1422-date-iso.ts": { - "order": [ - "/tests/corpus/1422-date-iso.ts" - ], - "diags": [] - }, - "/tests/corpus/1423-text-codec.ts": { - "order": [ - "/tests/corpus/1423-text-codec.ts" - ], - "diags": [] - }, - "/tests/corpus/1424-fs-options.ts": { - "order": [ - "/tests/corpus/1424-fs-options.ts" - ], - "diags": [] - }, - "/tests/corpus/1425-stdin-tty.ts": { - "order": [ - "/tests/corpus/1425-stdin-tty.ts" - ], - "diags": [] - }, - "/tests/corpus/1426-stdin-read.ts": { - "order": [ - "/tests/corpus/1426-stdin-read.ts" - ], - "diags": [] - }, - "/tests/corpus/1427-fromcharcode-lastindexof.ts": { - "order": [ - "/tests/corpus/1427-fromcharcode-lastindexof.ts" - ], - "diags": [] - }, - "/tests/corpus/1428-settled-await-order.ts": { - "order": [ - "/tests/corpus/1428-settled-await-order.ts" - ], - "diags": [] - }, - "/tests/corpus/1429-promise-catch-finally.ts": { - "order": [ - "/tests/corpus/1429-promise-catch-finally.ts" - ], - "diags": [] - }, - "/tests/corpus/1430-promise-race.ts": { - "order": [ - "/tests/corpus/1430-promise-race.ts" - ], - "diags": [] - }, - "/tests/corpus/1431-caught-tostring.ts": { - "order": [ - "/tests/corpus/1431-caught-tostring.ts" - ], - "diags": [] - }, - "/tests/corpus/1432-destructured-params.ts": { - "order": [ - "/tests/corpus/1432-destructured-params.ts" - ], - "diags": [] - }, - "/tests/corpus/1433-filter-narrow.ts": { - "order": [ - "/tests/corpus/1433-filter-narrow.ts" - ], - "diags": [] - }, - "/tests/corpus/1434-async-never.ts": { - "order": [ - "/tests/corpus/1434-async-never.ts" - ], - "diags": [] - }, - "/tests/corpus/1435-math-spread.ts": { - "order": [ - "/tests/corpus/1435-math-spread.ts" - ], - "diags": [] - }, - "/tests/corpus/1436-default-undef-param.ts": { - "order": [ - "/tests/corpus/1436-default-undef-param.ts" - ], - "diags": [] - }, - "/tests/corpus/1437-pad-default.ts": { - "order": [ - "/tests/corpus/1437-pad-default.ts" - ], - "diags": [] - }, - "/tests/corpus/1438-promise-all.ts": { - "order": [ - "/tests/corpus/1438-promise-all.ts" - ], - "diags": [] - }, - "/tests/corpus/1440-interval-basics.ts": { - "order": [ - "/tests/corpus/1440-interval-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1441-interval-clear-cross.ts": { - "order": [ - "/tests/corpus/1441-interval-clear-cross.ts" - ], - "diags": [] - }, - "/tests/corpus/1442-interval-throw.ts": { - "order": [ - "/tests/corpus/1442-interval-throw.ts" - ], - "diags": [] - }, - "/tests/corpus/1443-signal-handlers.ts": { - "order": [ - "/tests/corpus/1443-signal-handlers.ts" - ], - "diags": [] - }, - "/tests/corpus/1444-exit-listeners.ts": { - "order": [ - "/tests/corpus/1444-exit-listeners.ts" - ], - "diags": [] - }, - "/tests/corpus/1445-exit-process-exit.ts": { - "order": [ - "/tests/corpus/1445-exit-process-exit.ts" - ], - "diags": [] - }, - "/tests/corpus/1446-exit-uncaught.ts": { - "order": [ - "/tests/corpus/1446-exit-uncaught.ts" - ], - "diags": [] - }, - "/tests/corpus/1447-stdin-closed-events.ts": { - "order": [ - "/tests/corpus/1447-stdin-closed-events.ts" - ], - "diags": [] - }, - "/tests/corpus/1448-stream-columns.ts": { - "order": [ - "/tests/corpus/1448-stream-columns.ts" - ], - "diags": [] - }, - "/tests/corpus/1450-incdec-expression.ts": { - "order": [ - "/tests/corpus/1450-incdec-expression.ts" - ], - "diags": [] - }, - "/tests/corpus/1451-instanceof-uint8array-unknown.ts": { - "order": [ - "/tests/corpus/1451-instanceof-uint8array-unknown.ts" - ], - "diags": [] - }, - "/tests/corpus/1452-return-through-finally.ts": { - "order": [ - "/tests/corpus/1452-return-through-finally.ts" - ], - "diags": [] - }, - "/tests/corpus/1453-pmap-settled.ts": { - "order": [ - "/tests/corpus/1453-pmap-settled.ts" - ], - "diags": [] - }, - "/tests/corpus/1454-nonnull-narrow-and-fcc-bytes.ts": { - "order": [ - "/tests/corpus/1454-nonnull-narrow-and-fcc-bytes.ts" - ], - "diags": [] - }, - "/tests/corpus/1455-lambda-union-return-adoption.ts": { - "order": [ - "/tests/corpus/1455-lambda-union-return-adoption.ts" - ], - "diags": [] - }, - "/tests/corpus/1460-console-error-warn.ts": { - "order": [ - "/tests/corpus/1460-console-error-warn.ts" - ], - "diags": [] - }, - "/tests/corpus/1461-process-pid-getuid-kill.ts": { - "order": [ - "/tests/corpus/1461-process-pid-getuid-kill.ts" - ], - "diags": [] - }, - "/tests/corpus/1462-exec-sync.ts": { - "order": [ - "/tests/corpus/1462-exec-sync.ts" - ], - "diags": [] - }, - "/tests/corpus/1463-timeout-unref.ts": { - "order": [ - "/tests/corpus/1463-timeout-unref.ts" - ], - "diags": [] - }, - "/tests/corpus/1464-env-writes.ts": { - "order": [ - "/tests/corpus/1464-env-writes.ts" - ], - "diags": [] - }, - "/tests/corpus/1465-env-value.ts": { - "order": [ - "/tests/corpus/1465-env-value.ts" - ], - "diags": [] - }, - "/tests/corpus/1466-child-containers.ts": { - "order": [ - "/tests/corpus/1466-child-containers.ts" - ], - "diags": [] - }, - "/tests/corpus/1467-string-match.ts": { - "order": [ - "/tests/corpus/1467-string-match.ts" - ], - "diags": [] - }, - "/tests/corpus/1468-exec-path.ts": { - "order": [ - "/tests/corpus/1468-exec-path.ts" - ], - "diags": [] - }, - "/tests/corpus/1469-remove-listener.ts": { - "order": [ - "/tests/corpus/1469-remove-listener.ts" - ], - "diags": [] - }, - "/tests/corpus/1470-child-lifecycle.ts": { - "order": [ - "/tests/corpus/1470-child-lifecycle.ts" - ], - "diags": [] - }, - "/tests/corpus/1471-child-unref.ts": { - "order": [ - "/tests/corpus/1471-child-unref.ts" - ], - "diags": [] - }, - "/tests/corpus/1472-errno-code.ts": { - "order": [ - "/tests/corpus/1472-errno-code.ts" - ], - "diags": [] - }, - "/tests/corpus/1473-promisify-execfile.ts": { - "order": [ - "/tests/corpus/1473-promisify-execfile.ts" - ], - "diags": [] - }, - "/tests/corpus/1474-string-decoder.ts": { - "order": [ - "/tests/corpus/1474-string-decoder.ts" - ], - "diags": [] - }, - "/tests/corpus/1475-readline-closed-stdin.ts": { - "order": [ - "/tests/corpus/1475-readline-closed-stdin.ts" - ], - "diags": [] - }, - "/tests/corpus/1476-assign-expression.ts": { - "order": [ - "/tests/corpus/1476-assign-expression.ts" - ], - "diags": [] - }, - "/tests/corpus/1477-in-expressions.ts": { - "order": [ - "/tests/corpus/1477-in-expressions.ts" - ], - "diags": [] - }, - "/tests/corpus/1478-promise-reject.ts": { - "order": [ - "/tests/corpus/1478-promise-reject.ts" - ], - "diags": [] - }, - "/tests/corpus/1479-destructuring-assign.ts": { - "order": [ - "/tests/corpus/1479-destructuring-assign.ts" - ], - "diags": [] - }, - "/tests/corpus/1480-os-network-interfaces.ts": { - "order": [ - "/tests/corpus/1480-os-network-interfaces.ts" - ], - "diags": [] - }, - "/tests/corpus/1481-string-case-static.ts": { - "order": [ - "/tests/corpus/1481-string-case-static.ts" - ], - "diags": [] - }, - "/tests/corpus/1482-spawnsync-error.ts": { - "order": [ - "/tests/corpus/1482-spawnsync-error.ts" - ], - "diags": [] - }, - "/tests/corpus/1483-array-slice.ts": { - "order": [ - "/tests/corpus/1483-array-slice.ts" - ], - "diags": [] - }, - "/tests/corpus/1520-fs-wider-surface.ts": { - "order": [ - "/tests/corpus/1520-fs-wider-surface.ts" - ], - "diags": [] - }, - "/tests/corpus/1520-string-split-static.ts": { - "order": [ - "/tests/corpus/1520-string-split-static.ts" - ], - "diags": [] - }, - "/tests/corpus/1521-fs-lstat-lock.ts": { - "order": [ - "/tests/corpus/1521-fs-lstat-lock.ts" - ], - "diags": [] - }, - "/tests/corpus/1521-string-trim-pad-static.ts": { - "order": [ - "/tests/corpus/1521-string-trim-pad-static.ts" - ], - "diags": [] - }, - "/tests/corpus/1522-parseint-static.ts": { - "order": [ - "/tests/corpus/1522-parseint-static.ts" - ], - "diags": [] - }, - "/tests/corpus/1522-spawnsync-options.ts": { - "order": [ - "/tests/corpus/1522-spawnsync-options.ts" - ], - "diags": [] - }, - "/tests/corpus/1523-isnan-floor-static.ts": { - "order": [ - "/tests/corpus/1523-isnan-floor-static.ts" - ], - "diags": [] - }, - "/tests/corpus/1523-spawn-options.ts": { - "order": [ - "/tests/corpus/1523-spawn-options.ts" - ], - "diags": [] - }, - "/tests/corpus/1524-atomics-sleep-static.ts": { - "order": [ - "/tests/corpus/1524-atomics-sleep-static.ts" - ], - "diags": [] - }, - "/tests/corpus/1524-catch-narrowing.ts": { - "order": [ - "/tests/corpus/1524-catch-narrowing.ts" - ], - "diags": [] - }, - "/tests/corpus/1525-child-exit-signal.ts": { - "order": [ - "/tests/corpus/1525-child-exit-signal.ts" - ], - "diags": [] - }, - "/tests/corpus/1525-unknown-typeof-validation.ts": { - "order": [ - "/tests/corpus/1525-unknown-typeof-validation.ts" - ], - "diags": [] - }, - "/tests/corpus/1526-set-spread.ts": { - "order": [ - "/tests/corpus/1526-set-spread.ts" - ], - "diags": [] - }, - "/tests/corpus/1527-logical-mixed-operands.ts": { - "order": [ - "/tests/corpus/1527-logical-mixed-operands.ts" - ], - "diags": [] - }, - "/tests/corpus/1528-delete-records-env.ts": { - "order": [ - "/tests/corpus/1528-delete-records-env.ts" - ], - "diags": [] - }, - "/tests/corpus/1529-class-with-statics.ts": { - "order": [ - "/tests/corpus/1529-class-with-statics.ts" - ], - "diags": [] - }, - "/tests/corpus/1530-array-push-variadic.ts": { - "order": [ - "/tests/corpus/1530-array-push-variadic.ts" - ], - "diags": [] - }, - "/tests/corpus/1530-spread-override-completion.ts": { - "order": [ - "/tests/corpus/1530-spread-override-completion.ts" - ], - "diags": [] - }, - "/tests/corpus/1531-delete-optional-fields.ts": { - "order": [ - "/tests/corpus/1531-delete-optional-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/1531-process-arch-versions.ts": { - "order": [ - "/tests/corpus/1531-process-arch-versions.ts" - ], - "diags": [] - }, - "/tests/corpus/1532-array-splice-shift.ts": { - "order": [ - "/tests/corpus/1532-array-splice-shift.ts" - ], - "diags": [] - }, - "/tests/corpus/1532-union-shared-field-read.ts": { - "order": [ - "/tests/corpus/1532-union-shared-field-read.ts" - ], - "diags": [] - }, - "/tests/corpus/1533-bool-equality.ts": { - "order": [ - "/tests/corpus/1533-bool-equality.ts" - ], - "diags": [] - }, - "/tests/corpus/1533-path-platform-namespaces.ts": { - "order": [ - "/tests/corpus/1533-path-platform-namespaces.ts" - ], - "diags": [] - }, - "/tests/corpus/1534-crypto-hash-chain.ts": { - "order": [ - "/tests/corpus/1534-crypto-hash-chain.ts" - ], - "diags": [] - }, - "/tests/corpus/1534-union-as-arm-cast.ts": { - "order": [ - "/tests/corpus/1534-union-as-arm-cast.ts" - ], - "diags": [] - }, - "/tests/corpus/1535-spawn-fd-stdio.ts": { - "order": [ - "/tests/corpus/1535-spawn-fd-stdio.ts" - ], - "diags": [] - }, - "/tests/corpus/1535-union-param-defaults.ts": { - "order": [ - "/tests/corpus/1535-union-param-defaults.ts" - ], - "diags": [] - }, - "/tests/corpus/1536-destructuring-defaults.ts": { - "order": [ - "/tests/corpus/1536-destructuring-defaults.ts" - ], - "diags": [] - }, - "/tests/corpus/1536-string-array-sweep.ts": { - "order": [ - "/tests/corpus/1536-string-array-sweep.ts" - ], - "diags": [] - }, - "/tests/corpus/1537-chalk-hybrid/main.ts": { - "order": [ - "/tests/corpus/1537-chalk-hybrid/colors.ts", - "/tests/corpus/1537-chalk-hybrid/main.ts" - ], - "diags": [] - }, - "/tests/corpus/1537-os-release-spawnsync-stdio.ts": { - "order": [ - "/tests/corpus/1537-os-release-spawnsync-stdio.ts" - ], - "diags": [] - }, - "/tests/corpus/1538-await-promiselike-return.ts": { - "order": [ - "/tests/corpus/1538-await-promiselike-return.ts" - ], - "diags": [] - }, - "/tests/corpus/1538-math-static-scalar.ts": { - "order": [ - "/tests/corpus/1538-math-static-scalar.ts" - ], - "diags": [] - }, - "/tests/corpus/1539-readonly-set-map.ts": { - "order": [ - "/tests/corpus/1539-readonly-set-map.ts" - ], - "diags": [] - }, - "/tests/corpus/1539-unknown-truthiness.ts": { - "order": [ - "/tests/corpus/1539-unknown-truthiness.ts" - ], - "diags": [] - }, - "/tests/corpus/1540-os-userinfo.ts": { - "order": [ - "/tests/corpus/1540-os-userinfo.ts" - ], - "diags": [] - }, - "/tests/corpus/1540-void-statement.ts": { - "order": [ - "/tests/corpus/1540-void-statement.ts" - ], - "diags": [] - }, - "/tests/corpus/1541-fs-readdir-dirent.ts": { - "order": [ - "/tests/corpus/1541-fs-readdir-dirent.ts" - ], - "diags": [] - }, - "/tests/corpus/1541-union-keyed-reads.ts": { - "order": [ - "/tests/corpus/1541-union-keyed-reads.ts" - ], - "diags": [] - }, - "/tests/corpus/1542-map-promise-values.ts": { - "order": [ - "/tests/corpus/1542-map-promise-values.ts" - ], - "diags": [] - }, - "/tests/corpus/1542-record-literal-into-union.ts": { - "order": [ - "/tests/corpus/1542-record-literal-into-union.ts" - ], - "diags": [] - }, - "/tests/corpus/1543-rest-destructuring.ts": { - "order": [ - "/tests/corpus/1543-rest-destructuring.ts" - ], - "diags": [] - }, - "/tests/corpus/1543-set-server-handles.ts": { - "order": [ - "/tests/corpus/1543-set-server-handles.ts" - ], - "diags": [] - }, - "/tests/corpus/1544-dyn-json-reads.ts": { - "order": [ - "/tests/corpus/1544-dyn-json-reads.ts" - ], - "diags": [] - }, - "/tests/corpus/1544-string-matchall.ts": { - "order": [ - "/tests/corpus/1544-string-matchall.ts" - ], - "diags": [] - }, - "/tests/corpus/1545-spread-order-and-optional.ts": { - "order": [ - "/tests/corpus/1545-spread-order-and-optional.ts" - ], - "diags": [] - }, - "/tests/corpus/1546-union-element-reads.ts": { - "order": [ - "/tests/corpus/1546-union-element-reads.ts" - ], - "diags": [] - }, - "/tests/corpus/1547-computed-key-fold.ts": { - "order": [ - "/tests/corpus/1547-computed-key-fold.ts" - ], - "diags": [] - }, - "/tests/corpus/1548-boolean-condition-forms.ts": { - "order": [ - "/tests/corpus/1548-boolean-condition-forms.ts" - ], - "diags": [] - }, - "/tests/corpus/1549-array-isarray-unions.ts": { - "order": [ - "/tests/corpus/1549-array-isarray-unions.ts" - ], - "diags": [] - }, - "/tests/corpus/1550-param-defaults-func-set.ts": { - "order": [ - "/tests/corpus/1550-param-defaults-func-set.ts" - ], - "diags": [] - }, - "/tests/corpus/1551-dyn-receiver-methods.ts": { - "order": [ - "/tests/corpus/1551-dyn-receiver-methods.ts" - ], - "diags": [] - }, - "/tests/corpus/1552-exec-options-record.ts": { - "order": [ - "/tests/corpus/1552-exec-options-record.ts" - ], - "diags": [] - }, - "/tests/corpus/1553-truthy-hof-predicates.ts": { - "order": [ - "/tests/corpus/1553-truthy-hof-predicates.ts" - ], - "diags": [] - }, - "/tests/corpus/1554-caught-into-unknown.ts": { - "order": [ - "/tests/corpus/1554-caught-into-unknown.ts" - ], - "diags": [] - }, - "/tests/corpus/1555-index-spread-into-declared.ts": { - "order": [ - "/tests/corpus/1555-index-spread-into-declared.ts" - ], - "diags": [] - }, - "/tests/corpus/1556-union-retag-width-arms.ts": { - "order": [ - "/tests/corpus/1556-union-retag-width-arms.ts" - ], - "diags": [] - }, - "/tests/corpus/1557-url-host.ts": { - "order": [ - "/tests/corpus/1557-url-host.ts" - ], - "diags": [] - }, - "/tests/corpus/1558-any-joins-and-dyn-validation.ts": { - "order": [ - "/tests/corpus/1558-any-joins-and-dyn-validation.ts" - ], - "diags": [] - }, - "/tests/corpus/1559-conditional-spread-index-merge.ts": { - "order": [ - "/tests/corpus/1559-conditional-spread-index-merge.ts" - ], - "diags": [] - }, - "/tests/corpus/1560-forof-homogeneous-tuples.ts": { - "order": [ - "/tests/corpus/1560-forof-homogeneous-tuples.ts" - ], - "diags": [] - }, - "/tests/corpus/1561-forof-strings.ts": { - "order": [ - "/tests/corpus/1561-forof-strings.ts" - ], - "diags": [] - }, - "/tests/corpus/1561-promise-then.ts": { - "order": [ - "/tests/corpus/1561-promise-then.ts" - ], - "diags": [] - }, - "/tests/corpus/1562-optional-chain-tails.ts": { - "order": [ - "/tests/corpus/1562-optional-chain-tails.ts" - ], - "diags": [] - }, - "/tests/corpus/1562-spawn-conditional-spread.ts": { - "order": [ - "/tests/corpus/1562-spawn-conditional-spread.ts" - ], - "diags": [] - }, - "/tests/corpus/1563-forof-iterator-projections.ts": { - "order": [ - "/tests/corpus/1563-forof-iterator-projections.ts" - ], - "diags": [] - }, - "/tests/corpus/1563-string-raw-fold.ts": { - "order": [ - "/tests/corpus/1563-string-raw-fold.ts" - ], - "diags": [] - }, - "/tests/corpus/1564-fs-watch.ts": { - "order": [ - "/tests/corpus/1564-fs-watch.ts" - ], - "diags": [] - }, - "/tests/corpus/1564-string-raw.ts": { - "order": [ - "/tests/corpus/1564-string-raw.ts" - ], - "diags": [] - }, - "/tests/corpus/1565-spawn-pipe-streams.ts": { - "order": [ - "/tests/corpus/1565-spawn-pipe-streams.ts" - ], - "diags": [] - }, - "/tests/corpus/1565-union-element-join.ts": { - "order": [ - "/tests/corpus/1565-union-element-join.ts" - ], - "diags": [] - }, - "/tests/corpus/1566-child-duck-interface.ts": { - "order": [ - "/tests/corpus/1566-child-duck-interface.ts" - ], - "diags": [] - }, - "/tests/corpus/1567-server-close-override.ts": { - "order": [ - "/tests/corpus/1567-server-close-override.ts" - ], - "diags": [] - }, - "/tests/corpus/1568-x509-fingerprint.ts": { - "order": [ - "/tests/corpus/1568-x509-fingerprint.ts" - ], - "diags": [] - }, - "/tests/corpus/1569-fsp-mkdir-unlink-chmod.ts": { - "order": [ - "/tests/corpus/1569-fsp-mkdir-unlink-chmod.ts" - ], - "diags": [] - }, - "/tests/corpus/1570-child-unref-kill-reffed.ts": { - "order": [ - "/tests/corpus/1570-child-unref-kill-reffed.ts" - ], - "diags": [] - }, - "/tests/corpus/1571-optional-call-tostring-tail.ts": { - "order": [ - "/tests/corpus/1571-optional-call-tostring-tail.ts" - ], - "diags": [] - }, - "/tests/corpus/1571-stdin-set-raw-mode-non-tty.ts": { - "order": [ - "/tests/corpus/1571-stdin-set-raw-mode-non-tty.ts" - ], - "diags": [] - }, - "/tests/corpus/1572-promise-reject-all-tuple.ts": { - "order": [ - "/tests/corpus/1572-promise-reject-all-tuple.ts" - ], - "diags": [] - }, - "/tests/corpus/1572-x509-validity-date-gettime.ts": { - "order": [ - "/tests/corpus/1572-x509-validity-date-gettime.ts" - ], - "diags": [] - }, - "/tests/corpus/1573-promisify-execfile-env-spread.ts": { - "order": [ - "/tests/corpus/1573-promisify-execfile-env-spread.ts" - ], - "diags": [] - }, - "/tests/corpus/1573-tdz-scalar-forward-capture.ts": { - "order": [ - "/tests/corpus/1573-tdz-scalar-forward-capture.ts" - ], - "diags": [] - }, - "/tests/corpus/1574-dyn-optional-method-number-keys.ts": { - "order": [ - "/tests/corpus/1574-dyn-optional-method-number-keys.ts" - ], - "diags": [] - }, - "/tests/corpus/1574-promise-all-tuple-literal.ts": { - "order": [ - "/tests/corpus/1574-promise-all-tuple-literal.ts" - ], - "diags": [] - }, - "/tests/corpus/1575-unknown-assert-into-record.ts": { - "order": [ - "/tests/corpus/1575-unknown-assert-into-record.ts" - ], - "diags": [] - }, - "/tests/corpus/1576-width-coercions.ts": { - "order": [ - "/tests/corpus/1576-width-coercions.ts" - ], - "diags": [] - }, - "/tests/corpus/1577-url-hostname.ts": { - "order": [ - "/tests/corpus/1577-url-hostname.ts" - ], - "diags": [] - }, - "/tests/corpus/1578-exec-input-optional.ts": { - "order": [ - "/tests/corpus/1578-exec-input-optional.ts" - ], - "diags": [] - }, - "/tests/corpus/1579-matchall-index.ts": { - "order": [ - "/tests/corpus/1579-matchall-index.ts" - ], - "diags": [] - }, - "/tests/corpus/1580-exec-env-conditional-spread.ts": { - "order": [ - "/tests/corpus/1580-exec-env-conditional-spread.ts" - ], - "diags": [] - }, - "/tests/corpus/1581-declare-const-read.ts": { - "order": [ - "/tests/corpus/1581-declare-const-read.ts" - ], - "diags": [] - }, - "/tests/corpus/1582-timer-sleep-resolve.ts": { - "order": [ - "/tests/corpus/1582-timer-sleep-resolve.ts" - ], - "diags": [] - }, - "/tests/corpus/1583-loops-and-stream-captures.ts": { - "order": [ - "/tests/corpus/1583-loops-and-stream-captures.ts" - ], - "diags": [] - }, - "/tests/corpus/1584-union-field-unassigned.ts": { - "order": [ - "/tests/corpus/1584-union-field-unassigned.ts" - ], - "diags": [] - }, - "/tests/corpus/1585-union-field-conditional-ctor.ts": { - "order": [ - "/tests/corpus/1585-union-field-conditional-ctor.ts" - ], - "diags": [] - }, - "/tests/corpus/1586-derived-field-before-super-init.ts": { - "order": [ - "/tests/corpus/1586-derived-field-before-super-init.ts" - ], - "diags": [] - }, - "/tests/corpus/1587-any-field-unassigned.ts": { - "order": [ - "/tests/corpus/1587-any-field-unassigned.ts" - ], - "diags": [] - }, - "/tests/corpus/1590-js-unannotated.js": { - "order": [ - "/tests/corpus/1590-js-unannotated.js" - ], - "diags": [] - }, - "/tests/corpus/1591-js-closures.js": { - "order": [ - "/tests/corpus/1591-js-closures.js" - ], - "diags": [] - }, - "/tests/corpus/1592-js-classes.js": { - "order": [ - "/tests/corpus/1592-js-classes.js" - ], - "diags": [] - }, - "/tests/corpus/1593-js-jsdoc-records.js": { - "order": [ - "/tests/corpus/1593-js-jsdoc-records.js" - ], - "diags": [] - }, - "/tests/corpus/1594-js-async.js": { - "order": [ - "/tests/corpus/1594-js-async.js" - ], - "diags": [] - }, - "/tests/corpus/1595-js-island-gap/main.js": { - "order": [ - "/tests/corpus/1595-js-island-gap/main.js" - ], - "diags": [] - }, - "/tests/corpus/1596-cjs-modules/main.js": { - "order": [ - "/tests/corpus/1596-cjs-modules/lib.js", - "/tests/corpus/1596-cjs-modules/common/index.js", - "/tests/corpus/1596-cjs-modules/main.js" - ], - "diags": [] - }, - "/tests/corpus/1597-mjs-graph/main.mjs": { - "order": [ - "/tests/corpus/1597-mjs-graph/util.mjs", - "/tests/corpus/1597-mjs-graph/stats.mjs", - "/tests/corpus/1597-mjs-graph/main.mjs" - ], - "diags": [] - }, - "/tests/corpus/1598-cjs-builtin-require/main.js": { - "order": [ - "/tests/corpus/1598-cjs-builtin-require/main.js" - ], - "diags": [] - }, - "/tests/corpus/1599-js-uncaught-throw.js": { - "order": [ - "/tests/corpus/1599-js-uncaught-throw.js" - ], - "diags": [] - }, - "/tests/corpus/1600-assert-passing.ts": { - "order": [ - "/tests/corpus/1600-assert-passing.ts" - ], - "diags": [] - }, - "/tests/corpus/1601-assert-fail-exit.ts": { - "order": [ - "/tests/corpus/1601-assert-fail-exit.ts" - ], - "diags": [] - }, - "/tests/corpus/1602-assert-caught-error.ts": { - "order": [ - "/tests/corpus/1602-assert-caught-error.ts" - ], - "diags": [] - }, - "/tests/corpus/1603-assert-scalar-messages.ts": { - "order": [ - "/tests/corpus/1603-assert-scalar-messages.ts" - ], - "diags": [] - }, - "/tests/corpus/1604-assert-deep-structures.ts": { - "order": [ - "/tests/corpus/1604-assert-deep-structures.ts" - ], - "diags": [] - }, - "/tests/corpus/1605-assert-import-forms.ts": { - "order": [ - "/tests/corpus/1605-assert-import-forms.ts" - ], - "diags": [] - }, - "/tests/corpus/1606-assert-strict-module.ts": { - "order": [ - "/tests/corpus/1606-assert-strict-module.ts" - ], - "diags": [] - }, - "/tests/corpus/1607-assert-throws-match.ts": { - "order": [ - "/tests/corpus/1607-assert-throws-match.ts" - ], - "diags": [] - }, - "/tests/corpus/1608-cjs-assert/main.js": { - "order": [ - "/tests/corpus/1608-cjs-assert/main.js" - ], - "diags": [] - }, - "/tests/corpus/1609-assert-async.ts": { - "order": [ - "/tests/corpus/1609-assert-async.ts" - ], - "diags": [] - }, - "/tests/corpus/1610-path-win32-full.ts": { - "order": [ - "/tests/corpus/1610-path-win32-full.ts" - ], - "diags": [] - }, - "/tests/corpus/1611-url-file-bridge-neutral.ts": { - "order": [ - "/tests/corpus/1611-url-file-bridge-neutral.ts" - ], - "diags": [] - }, - "/tests/corpus/1612-cjs-module-globals.cjs": { - "order": [ - "/tests/corpus/1612-cjs-module-globals.cjs" - ], - "diags": [] - }, - "/tests/corpus/1613-cjs-esm-proxy-named/main.mjs": { - "order": [ - "/tests/corpus/1613-cjs-esm-proxy-named/table.cjs", - "/tests/corpus/1613-cjs-esm-proxy-named/main.mjs" - ], - "diags": [] - }, - "/tests/corpus/1614-js-fence-dodges.cjs": { - "order": [ - "/tests/corpus/1614-js-fence-dodges.cjs" - ], - "diags": [] - }, - "/tests/corpus/1615-cjs-export-shapes/main.cjs": { - "order": [ - "/tests/corpus/1615-cjs-export-shapes/table.cjs", - "/tests/corpus/1615-cjs-export-shapes/proxied.cjs", - "/tests/corpus/1615-cjs-export-shapes/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/1616-cjs-esm-lexer-invisible/main.mjs": { - "order": [ - "/tests/corpus/1616-cjs-esm-lexer-invisible/cjs.cjs", - "/tests/corpus/1616-cjs-esm-lexer-invisible/main.mjs" - ], - "diags": [] - }, - "/tests/corpus/1617-cjs-esm-lexer-visible/main.mjs": { - "order": [ - "/tests/corpus/1617-cjs-esm-lexer-visible/shorthand.cjs", - "/tests/corpus/1617-cjs-esm-lexer-visible/assigns.cjs", - "/tests/corpus/1617-cjs-esm-lexer-visible/callval.cjs", - "/tests/corpus/1617-cjs-esm-lexer-visible/getterhead.cjs", - "/tests/corpus/1617-cjs-esm-lexer-visible/wscomma.cjs", - "/tests/corpus/1617-cjs-esm-lexer-visible/main.mjs" - ], - "diags": [] - }, - "/tests/corpus/1618-cjs-esm-poisoned-tail/main.mjs": { - "order": [ - "/tests/corpus/1618-cjs-esm-poisoned-tail/cjs.cjs", - "/tests/corpus/1618-cjs-esm-poisoned-tail/main.mjs" - ], - "diags": [] - }, - "/tests/corpus/1619-cjs-esm-reexport-invisible/main.mjs": { - "order": [ - "/tests/corpus/1619-cjs-esm-reexport-invisible/cjs.cjs", - "/tests/corpus/1619-cjs-esm-reexport-invisible/mid.mjs", - "/tests/corpus/1619-cjs-esm-reexport-invisible/main.mjs" - ], - "diags": [] - }, - "/tests/corpus/1620-cjs-require-effects-order/main.js": { - "order": [ - "/tests/corpus/1620-cjs-require-effects-order/greeter.js", - "/tests/corpus/1620-cjs-require-effects-order/status.js", - "/tests/corpus/1620-cjs-require-effects-order/main.js" - ], - "diags": [] - }, - "/tests/corpus/1621-cjs-require-cache-hit/main.js": { - "order": [ - "/tests/corpus/1621-cjs-require-cache-hit/counter.js", - "/tests/corpus/1621-cjs-require-cache-hit/main.js" - ], - "diags": [] - }, - "/tests/corpus/1622-cjs-require-conditional/main.js": { - "order": [ - "/tests/corpus/1622-cjs-require-conditional/taken.js", - "/tests/corpus/1622-cjs-require-conditional/skipped.js", - "/tests/corpus/1622-cjs-require-conditional/main.js" - ], - "diags": [] - }, - "/tests/corpus/1623-cjs-require-diamond/main.js": { - "order": [ - "/tests/corpus/1623-cjs-require-diamond/shared.js", - "/tests/corpus/1623-cjs-require-diamond/left.js", - "/tests/corpus/1623-cjs-require-diamond/right.js", - "/tests/corpus/1623-cjs-require-diamond/main.js" - ], - "diags": [] - }, - "/tests/corpus/1624-cjs-require-dir-mid-file/main.js": { - "order": [ - "/tests/corpus/1624-cjs-require-dir-mid-file/common/index.js", - "/tests/corpus/1624-cjs-require-dir-mid-file/main.js" - ], - "diags": [] - }, - "/tests/corpus/1625-cjs-require-lazy-fn/main.js": { - "order": [ - "/tests/corpus/1625-cjs-require-lazy-fn/lazy.js", - "/tests/corpus/1625-cjs-require-lazy-fn/never.js", - "/tests/corpus/1625-cjs-require-lazy-fn/main.js" - ], - "diags": [] - }, - "/tests/corpus/1626-cjs-require-mjs/main.js": { - "order": [ - "/tests/corpus/1626-cjs-require-mjs/base.mjs", - "/tests/corpus/1626-cjs-require-mjs/mid.mjs", - "/tests/corpus/1626-cjs-require-mjs/main.js" - ], - "diags": [] - }, - "/tests/corpus/1627-mjs-import-cjs-requires/main.mjs": { - "order": [ - "/tests/corpus/1627-mjs-import-cjs-requires/base.mjs", - "/tests/corpus/1627-mjs-import-cjs-requires/cjspart.js", - "/tests/corpus/1627-mjs-import-cjs-requires/main.mjs" - ], - "diags": [] - }, - "/tests/corpus/1628-checked-dynamic-builtin-args.cjs": { - "order": [ - "/tests/corpus/1628-checked-dynamic-builtin-args.cjs" - ], - "diags": [] - }, - "/tests/corpus/1629-require-main-filename.cjs": { - "order": [ - "/tests/corpus/1629-require-main-filename.cjs" - ], - "diags": [] - }, - "/tests/corpus/1630-inspect-scalars.ts": { - "order": [ - "/tests/corpus/1630-inspect-scalars.ts" - ], - "diags": [] - }, - "/tests/corpus/1630-rmsync-retry-options.cjs": { - "order": [ - "/tests/corpus/1630-rmsync-retry-options.cjs" - ], - "diags": [] - }, - "/tests/corpus/1631-inspect-arrays.ts": { - "order": [ - "/tests/corpus/1631-inspect-arrays.ts" - ], - "diags": [] - }, - "/tests/corpus/1632-inspect-records.ts": { - "order": [ - "/tests/corpus/1632-inspect-records.ts" - ], - "diags": [] - }, - "/tests/corpus/1633-inspect-map-set.ts": { - "order": [ - "/tests/corpus/1633-inspect-map-set.ts" - ], - "diags": [] - }, - "/tests/corpus/1634-inspect-classes.ts": { - "order": [ - "/tests/corpus/1634-inspect-classes.ts" - ], - "diags": [] - }, - "/tests/corpus/1635-inspect-buffer.ts": { - "order": [ - "/tests/corpus/1635-inspect-buffer.ts" - ], - "diags": [] - }, - "/tests/corpus/1636-util-format.ts": { - "order": [ - "/tests/corpus/1636-util-format.ts" - ], - "diags": [] - }, - "/tests/corpus/1637-inspect-dyn.ts": { - "order": [ - "/tests/corpus/1637-inspect-dyn.ts" - ], - "diags": [] - }, - "/tests/corpus/1638-inspect-cjs.cjs": { - "order": [ - "/tests/corpus/1638-inspect-cjs.cjs" - ], - "diags": [] - }, - "/tests/corpus/1639-versions-openssl-probe.ts": { - "order": [ - "/tests/corpus/1639-versions-openssl-probe.ts" - ], - "diags": [] - }, - "/tests/corpus/1640-fd-read-decode.ts": { - "order": [ - "/tests/corpus/1640-fd-read-decode.ts" - ], - "diags": [] - }, - "/tests/corpus/1641-string-search.ts": { - "order": [ - "/tests/corpus/1641-string-search.ts" - ], - "diags": [] - }, - "/tests/corpus/1642-object-fromentries-rows.ts": { - "order": [ - "/tests/corpus/1642-object-fromentries-rows.ts" - ], - "diags": [] - }, - "/tests/corpus/1643-metadata-dyn-return.cjs": { - "order": [ - "/tests/corpus/1643-metadata-dyn-return.cjs" - ], - "diags": [] - }, - "/tests/corpus/1644-ee-basics.ts": { - "order": [ - "/tests/corpus/1644-ee-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1645-ee-extends.ts": { - "order": [ - "/tests/corpus/1645-ee-extends.ts" - ], - "diags": [] - }, - "/tests/corpus/1646-ee-once-remove.ts": { - "order": [ - "/tests/corpus/1646-ee-once-remove.ts" - ], - "diags": [] - }, - "/tests/corpus/1647-ee-meta-events.ts": { - "order": [ - "/tests/corpus/1647-ee-meta-events.ts" - ], - "diags": [] - }, - "/tests/corpus/1648-ee-error-event.ts": { - "order": [ - "/tests/corpus/1648-ee-error-event.ts" - ], - "diags": [] - }, - "/tests/corpus/1649-ee-names-counts.ts": { - "order": [ - "/tests/corpus/1649-ee-names-counts.ts" - ], - "diags": [] - }, - "/tests/corpus/1650-ee-prepend.ts": { - "order": [ - "/tests/corpus/1650-ee-prepend.ts" - ], - "diags": [] - }, - "/tests/corpus/1651-ee-max-listeners.ts": { - "order": [ - "/tests/corpus/1651-ee-max-listeners.ts" - ], - "diags": [] - }, - "/tests/corpus/1652-ee-snapshot.ts": { - "order": [ - "/tests/corpus/1652-ee-snapshot.ts" - ], - "diags": [] - }, - "/tests/corpus/1653-ee-cjs.cjs": { - "order": [ - "/tests/corpus/1653-ee-cjs.cjs" - ], - "diags": [] - }, - "/tests/corpus/1654-ee-namespace.ts": { - "order": [ - "/tests/corpus/1654-ee-namespace.ts" - ], - "diags": [] - }, - "/tests/corpus/1655-spawnsync-neutral.ts": { - "order": [ - "/tests/corpus/1655-spawnsync-neutral.ts" - ], - "diags": [] - }, - "/tests/corpus/1656-execsync-neutral.ts": { - "order": [ - "/tests/corpus/1656-execsync-neutral.ts" - ], - "diags": [] - }, - "/tests/corpus/1657-spawn-async-neutral.ts": { - "order": [ - "/tests/corpus/1657-spawn-async-neutral.ts" - ], - "diags": [] - }, - "/tests/corpus/1660-buffer-read-write-num.ts": { - "order": [ - "/tests/corpus/1660-buffer-read-write-num.ts" - ], - "diags": [] - }, - "/tests/corpus/1661-buffer-encodings-full.ts": { - "order": [ - "/tests/corpus/1661-buffer-encodings-full.ts" - ], - "diags": [] - }, - "/tests/corpus/1662-string-decoder-encodings.ts": { - "order": [ - "/tests/corpus/1662-string-decoder-encodings.ts" - ], - "diags": [] - }, - "/tests/corpus/1663-buffer-compare-search-fill.ts": { - "order": [ - "/tests/corpus/1663-buffer-compare-search-fill.ts" - ], - "diags": [] - }, - "/tests/corpus/1664-dyn-fn-boundary.cjs": { - "order": [ - "/tests/corpus/1664-dyn-fn-boundary.cjs" - ], - "diags": [] - }, - "/tests/corpus/1665-dyn-fn-mustcall/main.cjs": { - "order": [ - "/tests/corpus/1665-dyn-fn-mustcall/common.cjs", - "/tests/corpus/1665-dyn-fn-mustcall/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/1666-dyn-fn-identity.ts": { - "order": [ - "/tests/corpus/1666-dyn-fn-identity.ts" - ], - "diags": [] - }, - "/tests/corpus/1667-dyn-fn-not-callable.cjs": { - "order": [ - "/tests/corpus/1667-dyn-fn-not-callable.cjs" - ], - "diags": [] - }, - "/tests/corpus/1668-dyn-fn-throws.cjs": { - "order": [ - "/tests/corpus/1668-dyn-fn-throws.cjs" - ], - "diags": [] - }, - "/tests/corpus/1669-symbol-identity.ts": { - "order": [ - "/tests/corpus/1669-symbol-identity.ts" - ], - "diags": [] - }, - "/tests/corpus/1670-symbol-registry.ts": { - "order": [ - "/tests/corpus/1670-symbol-registry.ts" - ], - "diags": [] - }, - "/tests/corpus/1671-symbol-typeof.ts": { - "order": [ - "/tests/corpus/1671-symbol-typeof.ts" - ], - "diags": [] - }, - "/tests/corpus/1672-symbol-containers.ts": { - "order": [ - "/tests/corpus/1672-symbol-containers.ts" - ], - "diags": [] - }, - "/tests/corpus/1673-symbol-cjs.cjs": { - "order": [ - "/tests/corpus/1673-symbol-cjs.cjs" - ], - "diags": [] - }, - "/tests/corpus/1674-symbol-inspect.ts": { - "order": [ - "/tests/corpus/1674-symbol-inspect.ts" - ], - "diags": [] - }, - "/tests/corpus/1676-func-array-surface.ts": { - "order": [ - "/tests/corpus/1676-func-array-surface.ts" - ], - "diags": [] - }, - "/tests/corpus/1677-emitter-listeners.ts": { - "order": [ - "/tests/corpus/1677-emitter-listeners.ts" - ], - "diags": [] - }, - "/tests/corpus/1678-emitter-dyn-listeners.cjs": { - "order": [ - "/tests/corpus/1678-emitter-dyn-listeners.cjs" - ], - "diags": [] - }, - "/tests/corpus/1679-console-dyn.js": { - "order": [ - "/tests/corpus/1679-console-dyn.js" - ], - "diags": [] - }, - "/tests/corpus/1680-assert-bytes.ts": { - "order": [ - "/tests/corpus/1680-assert-bytes.ts" - ], - "diags": [] - }, - "/tests/corpus/1681-assert-funcs.ts": { - "order": [ - "/tests/corpus/1681-assert-funcs.ts" - ], - "diags": [] - }, - "/tests/corpus/1685-stream-readable-basics.ts": { - "order": [ - "/tests/corpus/1685-stream-readable-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1686-stream-readable-paused.ts": { - "order": [ - "/tests/corpus/1686-stream-readable-paused.ts" - ], - "diags": [] - }, - "/tests/corpus/1687-stream-readable-flow-control.ts": { - "order": [ - "/tests/corpus/1687-stream-readable-flow-control.ts" - ], - "diags": [] - }, - "/tests/corpus/1688-stream-writable-basics.ts": { - "order": [ - "/tests/corpus/1688-stream-writable-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1689-stream-writable-async-drain.ts": { - "order": [ - "/tests/corpus/1689-stream-writable-async-drain.ts" - ], - "diags": [] - }, - "/tests/corpus/1690-stream-duplex.ts": { - "order": [ - "/tests/corpus/1690-stream-duplex.ts" - ], - "diags": [] - }, - "/tests/corpus/1691-stream-transform.ts": { - "order": [ - "/tests/corpus/1691-stream-transform.ts" - ], - "diags": [] - }, - "/tests/corpus/1692-stream-pipe.ts": { - "order": [ - "/tests/corpus/1692-stream-pipe.ts" - ], - "diags": [] - }, - "/tests/corpus/1693-stream-pipe-backpressure.ts": { - "order": [ - "/tests/corpus/1693-stream-pipe-backpressure.ts" - ], - "diags": [] - }, - "/tests/corpus/1694-stream-destroy.ts": { - "order": [ - "/tests/corpus/1694-stream-destroy.ts" - ], - "diags": [] - }, - "/tests/corpus/1695-stream-props.ts": { - "order": [ - "/tests/corpus/1695-stream-props.ts" - ], - "diags": [] - }, - "/tests/corpus/1696-stream-read-inside-read.ts": { - "order": [ - "/tests/corpus/1696-stream-read-inside-read.ts" - ], - "diags": [] - }, - "/tests/corpus/1697-stream-tick-vs-timer.ts": { - "order": [ - "/tests/corpus/1697-stream-tick-vs-timer.ts" - ], - "diags": [] - }, - "/tests/corpus/1698-stream-uncaught-error.ts": { - "order": [ - "/tests/corpus/1698-stream-uncaught-error.ts" - ], - "diags": [] - }, - "/tests/corpus/1699-stream-callback-shapes.ts": { - "order": [ - "/tests/corpus/1699-stream-callback-shapes.ts" - ], - "diags": [] - }, - "/tests/corpus/1700-mustcall-common/main.cjs": { - "order": [ - "/tests/corpus/1700-mustcall-common/common.cjs", - "/tests/corpus/1700-mustcall-common/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/1701-mustcall-exit-report/main.cjs": { - "order": [ - "/tests/corpus/1701-mustcall-exit-report/common.cjs", - "/tests/corpus/1701-mustcall-exit-report/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/1702-dyn-proto-dispatch.cjs": { - "order": [ - "/tests/corpus/1702-dyn-proto-dispatch.cjs" - ], - "diags": [] - }, - "/tests/corpus/1703-arguments-rest-props.cjs": { - "order": [ - "/tests/corpus/1703-arguments-rest-props.cjs" - ], - "diags": [] - }, - "/tests/corpus/1710-cjs-export-class/main.js": { - "order": [ - "/tests/corpus/1710-cjs-export-class/countdown.js", - "/tests/corpus/1710-cjs-export-class/main.js" - ], - "diags": [] - }, - "/tests/corpus/1711-cjs-export-single-values/main.js": { - "order": [ - "/tests/corpus/1711-cjs-export-single-values/double.js", - "/tests/corpus/1711-cjs-export-single-values/limit.js", - "/tests/corpus/1711-cjs-export-single-values/version.js", - "/tests/corpus/1711-cjs-export-single-values/offset.js", - "/tests/corpus/1711-cjs-export-single-values/enabled.js", - "/tests/corpus/1711-cjs-export-single-values/main.js" - ], - "diags": [] - }, - "/tests/corpus/1712-field-incdec.ts": { - "order": [ - "/tests/corpus/1712-field-incdec.ts" - ], - "diags": [] - }, - "/tests/corpus/1713-js-dyn-fields.js": { - "order": [ - "/tests/corpus/1713-js-dyn-fields.js" - ], - "diags": [] - }, - "/tests/corpus/1720-assert-throws-shape.ts": { - "order": [ - "/tests/corpus/1720-assert-throws-shape.ts" - ], - "diags": [] - }, - "/tests/corpus/1721-assert-throws-regex-class.ts": { - "order": [ - "/tests/corpus/1721-assert-throws-regex-class.ts" - ], - "diags": [] - }, - "/tests/corpus/1722-assert-rejects.ts": { - "order": [ - "/tests/corpus/1722-assert-rejects.ts" - ], - "diags": [] - }, - "/tests/corpus/1723-assert-does-not-reject.ts": { - "order": [ - "/tests/corpus/1723-assert-does-not-reject.ts" - ], - "diags": [] - }, - "/tests/corpus/1724-assert-iferror.ts": { - "order": [ - "/tests/corpus/1724-assert-iferror.ts" - ], - "diags": [] - }, - "/tests/corpus/1725-assert-symbols.ts": { - "order": [ - "/tests/corpus/1725-assert-symbols.ts" - ], - "diags": [] - }, - "/tests/corpus/1726-promise-with-resolvers.ts": { - "order": [ - "/tests/corpus/1726-promise-with-resolvers.ts" - ], - "diags": [] - }, - "/tests/corpus/1727-assert-throws-shape-exit.ts": { - "order": [ - "/tests/corpus/1727-assert-throws-shape-exit.ts" - ], - "diags": [] - }, - "/tests/corpus/1730-countdown-symbol-keys/main.js": { - "order": [ - "/tests/corpus/1730-countdown-symbol-keys/index.js", - "/tests/corpus/1730-countdown-symbol-keys/countdown.js", - "/tests/corpus/1730-countdown-symbol-keys/main.js" - ], - "diags": [] - }, - "/tests/corpus/1731-symbol-field-shapes.cjs": { - "order": [ - "/tests/corpus/1731-symbol-field-shapes.cjs" - ], - "diags": [] - }, - "/tests/corpus/1732-symbol-field-cross-module/main.js": { - "order": [ - "/tests/corpus/1732-symbol-field-cross-module/timer.js", - "/tests/corpus/1732-symbol-field-cross-module/main.js" - ], - "diags": [] - }, - "/tests/corpus/1740-stream-extends-readable.ts": { - "order": [ - "/tests/corpus/1740-stream-extends-readable.ts" - ], - "diags": [] - }, - "/tests/corpus/1741-stream-extends-writable.ts": { - "order": [ - "/tests/corpus/1741-stream-extends-writable.ts" - ], - "diags": [] - }, - "/tests/corpus/1742-stream-extends-duplex-transform.ts": { - "order": [ - "/tests/corpus/1742-stream-extends-duplex-transform.ts" - ], - "diags": [] - }, - "/tests/corpus/1743-stream-extends-vt-dispatch.ts": { - "order": [ - "/tests/corpus/1743-stream-extends-vt-dispatch.ts" - ], - "diags": [] - }, - "/tests/corpus/1744-stream-set-encoding.ts": { - "order": [ - "/tests/corpus/1744-stream-set-encoding.ts" - ], - "diags": [] - }, - "/tests/corpus/1745-stream-encoding-js.cjs": { - "order": [ - "/tests/corpus/1745-stream-encoding-js.cjs" - ], - "diags": [] - }, - "/tests/corpus/1746-stream-for-await.ts": { - "order": [ - "/tests/corpus/1746-stream-for-await.ts" - ], - "diags": [] - }, - "/tests/corpus/1747-stream-for-await-js.cjs": { - "order": [ - "/tests/corpus/1747-stream-for-await-js.cjs" - ], - "diags": [] - }, - "/tests/corpus/1750-http-agent-options.ts": { - "order": [ - "/tests/corpus/1750-http-agent-options.ts" - ], - "diags": [] - }, - "/tests/corpus/1751-options-record-stance.ts": { - "order": [ - "/tests/corpus/1751-options-record-stance.ts" - ], - "diags": [] - }, - "/tests/corpus/1760-surplus-args-drop.cjs": { - "order": [ - "/tests/corpus/1760-surplus-args-drop.cjs" - ], - "diags": [] - }, - "/tests/corpus/1761-emitter-special-event-names.cjs": { - "order": [ - "/tests/corpus/1761-emitter-special-event-names.cjs" - ], - "diags": [] - }, - "/tests/corpus/1770-assert-dyn-strict.ts": { - "order": [ - "/tests/corpus/1770-assert-dyn-strict.ts" - ], - "diags": [] - }, - "/tests/corpus/1771-assert-dyn-deep.ts": { - "order": [ - "/tests/corpus/1771-assert-dyn-deep.ts" - ], - "diags": [] - }, - "/tests/corpus/1772-assert-dyn-js.cjs": { - "order": [ - "/tests/corpus/1772-assert-dyn-js.cjs" - ], - "diags": [] - }, - "/tests/corpus/1773-assert-dyn-exit.ts": { - "order": [ - "/tests/corpus/1773-assert-dyn-exit.ts" - ], - "diags": [] - }, - "/tests/corpus/1780-http-res-surface.ts": { - "order": [ - "/tests/corpus/1780-http-res-surface.ts" - ], - "diags": [] - }, - "/tests/corpus/1781-http-server-shapes.cjs": { - "order": [ - "/tests/corpus/1781-http-server-shapes.cjs" - ], - "diags": [] - }, - "/tests/corpus/1790-computed-key-folds.ts": { - "order": [ - "/tests/corpus/1790-computed-key-folds.ts" - ], - "diags": [] - }, - "/tests/corpus/1791-searchparams-core.ts": { - "order": [ - "/tests/corpus/1791-searchparams-core.ts" - ], - "diags": [] - }, - "/tests/corpus/1792-searchparams-encoding.ts": { - "order": [ - "/tests/corpus/1792-searchparams-encoding.ts" - ], - "diags": [] - }, - "/tests/corpus/1793-searchparams-iteration.ts": { - "order": [ - "/tests/corpus/1793-searchparams-iteration.ts" - ], - "diags": [] - }, - "/tests/corpus/1794-searchparams-url-live.ts": { - "order": [ - "/tests/corpus/1794-searchparams-url-live.ts" - ], - "diags": [] - }, - "/tests/corpus/1795-dyn-handle-request.cjs": { - "order": [ - "/tests/corpus/1795-dyn-handle-request.cjs" - ], - "diags": [] - }, - "/tests/corpus/1796-dyn-handle-body.cjs": { - "order": [ - "/tests/corpus/1796-dyn-handle-body.cjs" - ], - "diags": [] - }, - "/tests/corpus/1797-dyn-handle-socket.cjs": { - "order": [ - "/tests/corpus/1797-dyn-handle-socket.cjs" - ], - "diags": [] - }, - "/tests/corpus/1798-dyn-handle-typed-box.ts": { - "order": [ - "/tests/corpus/1798-dyn-handle-typed-box.ts" - ], - "diags": [] - }, - "/tests/corpus/1800-immediate-basics.ts": { - "order": [ - "/tests/corpus/1800-immediate-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1801-immediate-handle.ts": { - "order": [ - "/tests/corpus/1801-immediate-handle.ts" - ], - "diags": [] - }, - "/tests/corpus/1802-immediate-unref-exit.ts": { - "order": [ - "/tests/corpus/1802-immediate-unref-exit.ts" - ], - "diags": [] - }, - "/tests/corpus/1803-timeout-refresh.ts": { - "order": [ - "/tests/corpus/1803-timeout-refresh.ts" - ], - "diags": [] - }, - "/tests/corpus/1804-timers-module.ts": { - "order": [ - "/tests/corpus/1804-timers-module.ts" - ], - "diags": [] - }, - "/tests/corpus/1805-timer-callback-args.ts": { - "order": [ - "/tests/corpus/1805-timer-callback-args.ts" - ], - "diags": [] - }, - "/tests/corpus/1806-timer-delay-trunc.ts": { - "order": [ - "/tests/corpus/1806-timer-delay-trunc.ts" - ], - "diags": [] - }, - "/tests/corpus/1810-stream-options-const-record.ts": { - "order": [ - "/tests/corpus/1810-stream-options-const-record.ts" - ], - "diags": [] - }, - "/tests/corpus/1811-stream-option-value-callbacks.cjs": { - "order": [ - "/tests/corpus/1811-stream-option-value-callbacks.cjs" - ], - "diags": [] - }, - "/tests/corpus/1812-stream-super-options-forwarding.cjs": { - "order": [ - "/tests/corpus/1812-stream-super-options-forwarding.cjs" - ], - "diags": [] - }, - "/tests/corpus/1813-stream-finished.ts": { - "order": [ - "/tests/corpus/1813-stream-finished.ts" - ], - "diags": [] - }, - "/tests/corpus/1814-stream-pipeline.cjs": { - "order": [ - "/tests/corpus/1814-stream-pipeline.cjs" - ], - "diags": [] - }, - "/tests/corpus/1815-stream-state-reads.cjs": { - "order": [ - "/tests/corpus/1815-stream-state-reads.cjs" - ], - "diags": [] - }, - "/tests/corpus/1820-static-block-basics.ts": { - "order": [ - "/tests/corpus/1820-static-block-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1821-static-block-order.ts": { - "order": [ - "/tests/corpus/1821-static-block-order.ts" - ], - "diags": [] - }, - "/tests/corpus/1822-static-block-js.js": { - "order": [ - "/tests/corpus/1822-static-block-js.js" - ], - "diags": [] - }, - "/tests/corpus/1823-static-instance-method-names.ts": { - "order": [ - "/tests/corpus/1823-static-instance-method-names.ts" - ], - "diags": [] - }, - "/tests/corpus/1824-for-of-destructuring-defaults.ts": { - "order": [ - "/tests/corpus/1824-for-of-destructuring-defaults.ts" - ], - "diags": [] - }, - "/tests/corpus/1825-exhaustive-typeof-switch.ts": { - "order": [ - "/tests/corpus/1825-exhaustive-typeof-switch.ts" - ], - "diags": [] - }, - "/tests/corpus/1826-settimeout-arguments-callback.js": { - "order": [ - "/tests/corpus/1826-settimeout-arguments-callback.js" - ], - "diags": [] - }, - "/tests/corpus/1830-enum-numeric-basics.ts": { - "order": [ - "/tests/corpus/1830-enum-numeric-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1831-enum-string-const-reverse.ts": { - "order": [ - "/tests/corpus/1831-enum-string-const-reverse.ts" - ], - "diags": [] - }, - "/tests/corpus/1832-enum-modules/main.ts": { - "order": [ - "/tests/corpus/1832-enum-modules/lib.ts", - "/tests/corpus/1832-enum-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/1835-var-basics.ts": { - "order": [ - "/tests/corpus/1835-var-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1836-var-loop-capture.ts": { - "order": [ - "/tests/corpus/1836-var-loop-capture.ts" - ], - "diags": [] - }, - "/tests/corpus/1837-var-undefined-hoisting.ts": { - "order": [ - "/tests/corpus/1837-var-undefined-hoisting.ts" - ], - "diags": [] - }, - "/tests/corpus/1838-var-modules/main.ts": { - "order": [ - "/tests/corpus/1838-var-modules/dep.ts", - "/tests/corpus/1838-var-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/1839-var-js/main.cjs": { - "order": [ - "/tests/corpus/1839-var-js/lib.cjs", - "/tests/corpus/1839-var-js/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/1840-jsdoc-import-type-only/main.js": { - "order": [ - "/tests/corpus/1840-jsdoc-import-type-only/main.js" - ], - "diags": [] - }, - "/tests/corpus/1850-overload-basics.ts": { - "order": [ - "/tests/corpus/1850-overload-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1851-overload-return-narrowing.ts": { - "order": [ - "/tests/corpus/1851-overload-return-narrowing.ts" - ], - "diags": [] - }, - "/tests/corpus/1852-overload-class-members.ts": { - "order": [ - "/tests/corpus/1852-overload-class-members.ts" - ], - "diags": [] - }, - "/tests/corpus/1853-overload-modules/main.ts": { - "order": [ - "/tests/corpus/1853-overload-modules/lib.ts", - "/tests/corpus/1853-overload-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/1854-ambient-declare-fn.ts": { - "order": [ - "/tests/corpus/1854-ambient-declare-fn.ts" - ], - "diags": [] - }, - "/tests/corpus/1855-ambient-declare-fn-uncaught.ts": { - "order": [ - "/tests/corpus/1855-ambient-declare-fn-uncaught.ts" - ], - "diags": [] - }, - "/tests/corpus/1870-unit-type-values.ts": { - "order": [ - "/tests/corpus/1870-unit-type-values.ts" - ], - "diags": [] - }, - "/tests/corpus/1871-empty-array-never.ts": { - "order": [ - "/tests/corpus/1871-empty-array-never.ts" - ], - "diags": [] - }, - "/tests/corpus/1872-template-tostring-composite.ts": { - "order": [ - "/tests/corpus/1872-template-tostring-composite.ts" - ], - "diags": [] - }, - "/tests/corpus/1880-json-declared-field-order.ts": { - "order": [ - "/tests/corpus/1880-json-declared-field-order.ts" - ], - "diags": [] - }, - "/tests/corpus/1881-default-anon/main.ts": { - "order": [ - "/tests/corpus/1881-default-anon/adder.ts", - "/tests/corpus/1881-default-anon/box.ts", - "/tests/corpus/1881-default-anon/main.ts" - ], - "diags": [] - }, - "/tests/corpus/1882-default-cjs-interop/main.ts": { - "order": [ - "/tests/corpus/1882-default-cjs-interop/table.cjs", - "/tests/corpus/1882-default-cjs-interop/scalar.cjs", - "/tests/corpus/1882-default-cjs-interop/main.ts" - ], - "diags": [] - }, - "/tests/corpus/1883-default-exports/main.ts": { - "order": [ - "/tests/corpus/1883-default-exports/double.ts", - "/tests/corpus/1883-default-exports/counter.ts", - "/tests/corpus/1883-default-exports/config.ts", - "/tests/corpus/1883-default-exports/pick.ts", - "/tests/corpus/1883-default-exports/hub.ts", - "/tests/corpus/1883-default-exports/main.ts" - ], - "diags": [] - }, - "/tests/corpus/1890-ns-imports/main.ts": { - "order": [ - "/tests/corpus/1890-ns-imports/geo.ts", - "/tests/corpus/1890-ns-imports/main.ts" - ], - "diags": [] - }, - "/tests/corpus/1891-ns-reexport/main.ts": { - "order": [ - "/tests/corpus/1891-ns-reexport/shared.ts", - "/tests/corpus/1891-ns-reexport/agg.ts", - "/tests/corpus/1891-ns-reexport/constants.ts", - "/tests/corpus/1891-ns-reexport/drink.ts", - "/tests/corpus/1891-ns-reexport/main.ts" - ], - "diags": [] - }, - "/tests/corpus/1940-class-values-basics.ts": { - "order": [ - "/tests/corpus/1940-class-values-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1941-class-values-registry.ts": { - "order": [ - "/tests/corpus/1941-class-values-registry.ts" - ], - "diags": [] - }, - "/tests/corpus/1942-class-expressions.ts": { - "order": [ - "/tests/corpus/1942-class-expressions.ts" - ], - "diags": [] - }, - "/tests/corpus/1943-class-statics-expanded.ts": { - "order": [ - "/tests/corpus/1943-class-statics-expanded.ts" - ], - "diags": [] - }, - "/tests/corpus/1944-class-values-modules/main.ts": { - "order": [ - "/tests/corpus/1944-class-values-modules/lib.ts", - "/tests/corpus/1944-class-values-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/1950-generic-fn-values.ts": { - "order": [ - "/tests/corpus/1950-generic-fn-values.ts" - ], - "diags": [] - }, - "/tests/corpus/1951-generic-classes-basics.ts": { - "order": [ - "/tests/corpus/1951-generic-classes-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1952-generic-class-statics-values.ts": { - "order": [ - "/tests/corpus/1952-generic-class-statics-values.ts" - ], - "diags": [] - }, - "/tests/corpus/1953-generic-class-hierarchy.ts": { - "order": [ - "/tests/corpus/1953-generic-class-hierarchy.ts" - ], - "diags": [] - }, - "/tests/corpus/1954-generic-modules/main.ts": { - "order": [ - "/tests/corpus/1954-generic-modules/lib.ts", - "/tests/corpus/1954-generic-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/1960-namespace-basics.ts": { - "order": [ - "/tests/corpus/1960-namespace-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1961-namespace-nested.ts": { - "order": [ - "/tests/corpus/1961-namespace-nested.ts" - ], - "diags": [] - }, - "/tests/corpus/1962-namespace-classes.ts": { - "order": [ - "/tests/corpus/1962-namespace-classes.ts" - ], - "diags": [] - }, - "/tests/corpus/1963-namespace-aliases.ts": { - "order": [ - "/tests/corpus/1963-namespace-aliases.ts" - ], - "diags": [] - }, - "/tests/corpus/1964-namespace-type-only.ts": { - "order": [ - "/tests/corpus/1964-namespace-type-only.ts" - ], - "diags": [] - }, - "/tests/corpus/1965-namespace-ambient.ts": { - "order": [ - "/tests/corpus/1965-namespace-ambient.ts" - ], - "diags": [] - }, - "/tests/corpus/1966-namespace-modules/main.ts": { - "order": [ - "/tests/corpus/1966-namespace-modules/geo.ts", - "/tests/corpus/1966-namespace-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/1967-namespace-alias-typeonly.ts": { - "order": [ - "/tests/corpus/1967-namespace-alias-typeonly.ts" - ], - "diags": [] - }, - "/tests/corpus/1968-namespace-import-eq-snapshot.ts": { - "order": [ - "/tests/corpus/1968-namespace-import-eq-snapshot.ts" - ], - "diags": [] - }, - "/tests/corpus/1970-decorators-basics.ts": { - "order": [ - "/tests/corpus/1970-decorators-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1971-decorators-rebinding.ts": { - "order": [ - "/tests/corpus/1971-decorators-rebinding.ts" - ], - "diags": [] - }, - "/tests/corpus/1972-decorators-throwing.ts": { - "order": [ - "/tests/corpus/1972-decorators-throwing.ts" - ], - "diags": [] - }, - "/tests/corpus/1973-decorators-ambient.ts": { - "order": [ - "/tests/corpus/1973-decorators-ambient.ts" - ], - "diags": [] - }, - "/tests/corpus/1980-primitive-proto-statics.ts": { - "order": [ - "/tests/corpus/1980-primitive-proto-statics.ts" - ], - "diags": [] - }, - "/tests/corpus/1981-date-utc.ts": { - "order": [ - "/tests/corpus/1981-date-utc.ts" - ], - "diags": [] - }, - "/tests/corpus/1982-freeze-resolve-passthrough.ts": { - "order": [ - "/tests/corpus/1982-freeze-resolve-passthrough.ts" - ], - "diags": [] - }, - "/tests/corpus/1983-array-tuple-surfaces.ts": { - "order": [ - "/tests/corpus/1983-array-tuple-surfaces.ts" - ], - "diags": [] - }, - "/tests/corpus/1990-labels-basics.ts": { - "order": [ - "/tests/corpus/1990-labels-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/1991-for-in-loops.ts": { - "order": [ - "/tests/corpus/1991-for-in-loops.ts" - ], - "diags": [] - }, - "/tests/corpus/1992-small-syntax.ts": { - "order": [ - "/tests/corpus/1992-small-syntax.ts" - ], - "diags": [] - }, - "/tests/corpus/200-strings.ts": { - "order": [ - "/tests/corpus/200-strings.ts" - ], - "diags": [] - }, - "/tests/corpus/2000-generic-methods-basic.ts": { - "order": [ - "/tests/corpus/2000-generic-methods-basic.ts" - ], - "diags": [] - }, - "/tests/corpus/2001-generic-methods-generic-class.ts": { - "order": [ - "/tests/corpus/2001-generic-methods-generic-class.ts" - ], - "diags": [] - }, - "/tests/corpus/2002-generic-methods-inheritance.ts": { - "order": [ - "/tests/corpus/2002-generic-methods-inheritance.ts" - ], - "diags": [] - }, - "/tests/corpus/2003-generic-methods-object-literal.ts": { - "order": [ - "/tests/corpus/2003-generic-methods-object-literal.ts" - ], - "diags": [] - }, - "/tests/corpus/2004-generic-methods-statics.ts": { - "order": [ - "/tests/corpus/2004-generic-methods-statics.ts" - ], - "diags": [] - }, - "/tests/corpus/201-templates.ts": { - "order": [ - "/tests/corpus/201-templates.ts" - ], - "diags": [] - }, - "/tests/corpus/2010-generators-basics.ts": { - "order": [ - "/tests/corpus/2010-generators-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/2011-generators-forof.ts": { - "order": [ - "/tests/corpus/2011-generators-forof.ts" - ], - "diags": [] - }, - "/tests/corpus/2012-generators-return-throw.ts": { - "order": [ - "/tests/corpus/2012-generators-return-throw.ts" - ], - "diags": [] - }, - "/tests/corpus/2013-generators-sent-values.ts": { - "order": [ - "/tests/corpus/2013-generators-sent-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2014-generators-values.ts": { - "order": [ - "/tests/corpus/2014-generators-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2015-generators-yieldstar.ts": { - "order": [ - "/tests/corpus/2015-generators-yieldstar.ts" - ], - "diags": [] - }, - "/tests/corpus/2016-generators-rc-stress.ts": { - "order": [ - "/tests/corpus/2016-generators-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/2017-generators-async.ts": { - "order": [ - "/tests/corpus/2017-generators-async.ts" - ], - "diags": [] - }, - "/tests/corpus/2018-generators-uncaught.ts": { - "order": [ - "/tests/corpus/2018-generators-uncaught.ts" - ], - "diags": [] - }, - "/tests/corpus/2019-generators-loops.ts": { - "order": [ - "/tests/corpus/2019-generators-loops.ts" - ], - "diags": [] - }, - "/tests/corpus/2020-generic-value-bindings.ts": { - "order": [ - "/tests/corpus/2020-generic-value-bindings.ts" - ], - "diags": [] - }, - "/tests/corpus/2021-generic-value-binding-modules/main.ts": { - "order": [ - "/tests/corpus/2021-generic-value-binding-modules/lib.ts", - "/tests/corpus/2021-generic-value-binding-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2022-width-index-capture.ts": { - "order": [ - "/tests/corpus/2022-width-index-capture.ts" - ], - "diags": [] - }, - "/tests/corpus/2023-width-readonly.ts": { - "order": [ - "/tests/corpus/2023-width-readonly.ts" - ], - "diags": [] - }, - "/tests/corpus/2024-width-array-elems.ts": { - "order": [ - "/tests/corpus/2024-width-array-elems.ts" - ], - "diags": [] - }, - "/tests/corpus/2025-width-union-compose.ts": { - "order": [ - "/tests/corpus/2025-width-union-compose.ts" - ], - "diags": [] - }, - "/tests/corpus/2026-width-spread.ts": { - "order": [ - "/tests/corpus/2026-width-spread.ts" - ], - "diags": [] - }, - "/tests/corpus/2030-width-nested.ts": { - "order": [ - "/tests/corpus/2030-width-nested.ts" - ], - "diags": [] - }, - "/tests/corpus/2031-width-tuples.ts": { - "order": [ - "/tests/corpus/2031-width-tuples.ts" - ], - "diags": [] - }, - "/tests/corpus/2032-cjs-export-assigned-class-expression/main.cjs": { - "order": [ - "/tests/corpus/2032-cjs-export-assigned-class-expression/anon.cjs", - "/tests/corpus/2032-cjs-export-assigned-class-expression/widget.cjs", - "/tests/corpus/2032-cjs-export-assigned-class-expression/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/2033-property-assigned-class-extends.cjs": { - "order": [ - "/tests/corpus/2033-property-assigned-class-extends.cjs" - ], - "diags": [] - }, - "/tests/corpus/2035-ternary-array-retag.cjs": { - "order": [ - "/tests/corpus/2035-ternary-array-retag.cjs" - ], - "diags": [] - }, - "/tests/corpus/2036-evolving-array-decl.cjs": { - "order": [ - "/tests/corpus/2036-evolving-array-decl.cjs" - ], - "diags": [] - }, - "/tests/corpus/2037-fn-decl-hoisting.cjs": { - "order": [ - "/tests/corpus/2037-fn-decl-hoisting.cjs" - ], - "diags": [] - }, - "/tests/corpus/2038-evolving-array-js.cjs": { - "order": [ - "/tests/corpus/2038-evolving-array-js.cjs" - ], - "diags": [] - }, - "/tests/corpus/2040-any-bindings.ts": { - "order": [ - "/tests/corpus/2040-any-bindings.ts" - ], - "diags": [] - }, - "/tests/corpus/2040-mixin-heritage.ts": { - "order": [ - "/tests/corpus/2040-mixin-heritage.ts" - ], - "diags": [] - }, - "/tests/corpus/2041-any-params-returns.ts": { - "order": [ - "/tests/corpus/2041-any-params-returns.ts" - ], - "diags": [] - }, - "/tests/corpus/2041-mixin-values.ts": { - "order": [ - "/tests/corpus/2041-mixin-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2042-any-flow-loops.ts": { - "order": [ - "/tests/corpus/2042-any-flow-loops.ts" - ], - "diags": [] - }, - "/tests/corpus/2042-mixin-modules/main.ts": { - "order": [ - "/tests/corpus/2042-mixin-modules/zoo.ts", - "/tests/corpus/2042-mixin-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2043-any-dom-values.ts": { - "order": [ - "/tests/corpus/2043-any-dom-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2043-mixin-rc-stress.ts": { - "order": [ - "/tests/corpus/2043-mixin-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/2044-vtable-sibling-slots.ts": { - "order": [ - "/tests/corpus/2044-vtable-sibling-slots.ts" - ], - "diags": [] - }, - "/tests/corpus/2045-objlit-accessors-basic.ts": { - "order": [ - "/tests/corpus/2045-objlit-accessors-basic.ts" - ], - "diags": [] - }, - "/tests/corpus/2045-parameter-properties.ts": { - "order": [ - "/tests/corpus/2045-parameter-properties.ts" - ], - "diags": [] - }, - "/tests/corpus/2046-abstract-classes.ts": { - "order": [ - "/tests/corpus/2046-abstract-classes.ts" - ], - "diags": [] - }, - "/tests/corpus/2046-objlit-accessors-effects.ts": { - "order": [ - "/tests/corpus/2046-objlit-accessors-effects.ts" - ], - "diags": [] - }, - "/tests/corpus/2047-objlit-accessors-shapes.ts": { - "order": [ - "/tests/corpus/2047-objlit-accessors-shapes.ts" - ], - "diags": [] - }, - "/tests/corpus/2047-optional-class-fields.ts": { - "order": [ - "/tests/corpus/2047-optional-class-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/2050-dynamic-import-own-module/main.ts": { - "order": [ - "/tests/corpus/2050-dynamic-import-own-module/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2051-dynamic-import-then/main.ts": { - "order": [ - "/tests/corpus/2051-dynamic-import-then/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2052-dynamic-import-self.ts": { - "order": [ - "/tests/corpus/2052-dynamic-import-self.ts" - ], - "diags": [] - }, - "/tests/corpus/2053-typeof-static-fold.ts": { - "order": [ - "/tests/corpus/2053-typeof-static-fold.ts" - ], - "diags": [] - }, - "/tests/corpus/2054-destructuring-island-source.ts": { - "order": [ - "/tests/corpus/2054-destructuring-island-source.ts" - ], - "diags": [] - }, - "/tests/corpus/2060-empty-tuple.ts": { - "order": [ - "/tests/corpus/2060-empty-tuple.ts" - ], - "diags": [] - }, - "/tests/corpus/2070-computed-key-folds.ts": { - "order": [ - "/tests/corpus/2070-computed-key-folds.ts" - ], - "diags": [] - }, - "/tests/corpus/2071-integer-key-enumeration-order.ts": { - "order": [ - "/tests/corpus/2071-integer-key-enumeration-order.ts" - ], - "diags": [] - }, - "/tests/corpus/2072-expando-function-members.ts": { - "order": [ - "/tests/corpus/2072-expando-function-members.ts" - ], - "diags": [] - }, - "/tests/corpus/2073-destructuring-assignment.ts": { - "order": [ - "/tests/corpus/2073-destructuring-assignment.ts" - ], - "diags": [] - }, - "/tests/corpus/2074-island-destructuring.ts": { - "order": [ - "/tests/corpus/2074-island-destructuring.ts" - ], - "diags": [] - }, - "/tests/corpus/2075-index-signature-runtime-keys.ts": { - "order": [ - "/tests/corpus/2075-index-signature-runtime-keys.ts" - ], - "diags": [] - }, - "/tests/corpus/2080-destructuring-defaults.ts": { - "order": [ - "/tests/corpus/2080-destructuring-defaults.ts" - ], - "diags": [] - }, - "/tests/corpus/2081-destructuring-rest.ts": { - "order": [ - "/tests/corpus/2081-destructuring-rest.ts" - ], - "diags": [] - }, - "/tests/corpus/2082-destructuring-assignment.ts": { - "order": [ - "/tests/corpus/2082-destructuring-assignment.ts" - ], - "diags": [] - }, - "/tests/corpus/2083-destructuring-island-decl.ts": { - "order": [ - "/tests/corpus/2083-destructuring-island-decl.ts" - ], - "diags": [] - }, - "/tests/corpus/2084-destructuring-primitive-sources.ts": { - "order": [ - "/tests/corpus/2084-destructuring-primitive-sources.ts" - ], - "diags": [] - }, - "/tests/corpus/2085-destructuring-heads-rest-params.ts": { - "order": [ - "/tests/corpus/2085-destructuring-heads-rest-params.ts" - ], - "diags": [] - }, - "/tests/corpus/2086-destructuring-island-globals.ts": { - "order": [ - "/tests/corpus/2086-destructuring-island-globals.ts" - ], - "diags": [] - }, - "/tests/corpus/2087-destructuring-for-heads.ts": { - "order": [ - "/tests/corpus/2087-destructuring-for-heads.ts" - ], - "diags": [] - }, - "/tests/corpus/2090-index-signature-number-keys.ts": { - "order": [ - "/tests/corpus/2090-index-signature-number-keys.ts" - ], - "diags": [] - }, - "/tests/corpus/2091-index-signature-string-intersection.ts": { - "order": [ - "/tests/corpus/2091-index-signature-string-intersection.ts" - ], - "diags": [] - }, - "/tests/corpus/2092-package-imports/main.ts": { - "order": [ - "/tests/corpus/2092-package-imports/src/util.ts", - "/tests/corpus/2092-package-imports/src/extra.ts", - "/tests/corpus/2092-package-imports/src/greet.ts", - "/tests/corpus/2092-package-imports/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2093-timers-promises.ts": { - "order": [ - "/tests/corpus/2093-timers-promises.ts" - ], - "diags": [] - }, - "/tests/corpus/2094-diagnostics-channel.ts": { - "order": [ - "/tests/corpus/2094-diagnostics-channel.ts" - ], - "diags": [] - }, - "/tests/corpus/2095-js-catch-unknown.js": { - "order": [ - "/tests/corpus/2095-js-catch-unknown.js" - ], - "diags": [] - }, - "/tests/corpus/2096-os-type.ts": { - "order": [ - "/tests/corpus/2096-os-type.ts" - ], - "diags": [] - }, - "/tests/corpus/2097-js-evolving-globals.js": { - "order": [ - "/tests/corpus/2097-js-evolving-globals.js" - ], - "diags": [] - }, - "/tests/corpus/210-string-methods.ts": { - "order": [ - "/tests/corpus/210-string-methods.ts" - ], - "diags": [] - }, - "/tests/corpus/2100-stream-default-hwm.ts": { - "order": [ - "/tests/corpus/2100-stream-default-hwm.ts" - ], - "diags": [] - }, - "/tests/corpus/2101-dyn-param-defaults.ts": { - "order": [ - "/tests/corpus/2101-dyn-param-defaults.ts" - ], - "diags": [] - }, - "/tests/corpus/2102-empty-pattern-decls.ts": { - "order": [ - "/tests/corpus/2102-empty-pattern-decls.ts" - ], - "diags": [] - }, - "/tests/corpus/2103-optional-tuple-elements.ts": { - "order": [ - "/tests/corpus/2103-optional-tuple-elements.ts" - ], - "diags": [] - }, - "/tests/corpus/2104-computed-key-destructuring.ts": { - "order": [ - "/tests/corpus/2104-computed-key-destructuring.ts" - ], - "diags": [] - }, - "/tests/corpus/2105-computed-key-static-folds.ts": { - "order": [ - "/tests/corpus/2105-computed-key-static-folds.ts" - ], - "diags": [] - }, - "/tests/corpus/2106-comma-expressions.ts": { - "order": [ - "/tests/corpus/2106-comma-expressions.ts" - ], - "diags": [] - }, - "/tests/corpus/211-string-unicode.ts": { - "order": [ - "/tests/corpus/211-string-unicode.ts" - ], - "diags": [] - }, - "/tests/corpus/2110-top-object-types.ts": { - "order": [ - "/tests/corpus/2110-top-object-types.ts" - ], - "diags": [] - }, - "/tests/corpus/2111-json-stringify-unknown.ts": { - "order": [ - "/tests/corpus/2111-json-stringify-unknown.ts" - ], - "diags": [] - }, - "/tests/corpus/2112-array-at-findlast.ts": { - "order": [ - "/tests/corpus/2112-array-at-findlast.ts" - ], - "diags": [] - }, - "/tests/corpus/2113-string-index-methods.js": { - "order": [ - "/tests/corpus/2113-string-index-methods.js" - ], - "diags": [] - }, - "/tests/corpus/212-string-aliasing-append.ts": { - "order": [ - "/tests/corpus/212-string-aliasing-append.ts" - ], - "diags": [] - }, - "/tests/corpus/2120-package-self-import/main.ts": { - "order": [ - "/tests/corpus/2120-package-self-import/sib.ts", - "/tests/corpus/2120-package-self-import/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2121-esm-cycle-inert-backedge/main.ts": { - "order": [ - "/tests/corpus/2121-esm-cycle-inert-backedge/peer.ts", - "/tests/corpus/2121-esm-cycle-inert-backedge/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2122-import-refusal-crash/main.ts": { - "order": [ - "/tests/corpus/2122-import-refusal-crash/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2123-ambient-import-crash/main.ts": { - "order": [ - "/tests/corpus/2123-ambient-import-crash/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2124-imports-field-wildcard/main.ts": { - "order": [ - "/tests/corpus/2124-imports-field-wildcard/src/x.ts", - "/tests/corpus/2124-imports-field-wildcard/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2130-overload-island-returns.ts": { - "order": [ - "/tests/corpus/2130-overload-island-returns.ts" - ], - "diags": [] - }, - "/tests/corpus/2140-uri-component-codecs.ts": { - "order": [ - "/tests/corpus/2140-uri-component-codecs.ts" - ], - "diags": [] - }, - "/tests/corpus/2160-dc-tracing-channel.cjs": { - "order": [ - "/tests/corpus/2160-dc-tracing-channel.cjs" - ], - "diags": [] - }, - "/tests/corpus/2161-js-object-literal-identity.cjs": { - "order": [ - "/tests/corpus/2161-js-object-literal-identity.cjs" - ], - "diags": [] - }, - "/tests/corpus/2162-js-dyn-destructure.cjs": { - "order": [ - "/tests/corpus/2162-js-dyn-destructure.cjs" - ], - "diags": [] - }, - "/tests/corpus/2163-js-selfref-const.cjs": { - "order": [ - "/tests/corpus/2163-js-selfref-const.cjs" - ], - "diags": [] - }, - "/tests/corpus/2164-js-then-dyn-handler.cjs": { - "order": [ - "/tests/corpus/2164-js-then-dyn-handler.cjs" - ], - "diags": [] - }, - "/tests/corpus/2165-js-throw-dyn.cjs": { - "order": [ - "/tests/corpus/2165-js-throw-dyn.cjs" - ], - "diags": [] - }, - "/tests/corpus/2166-cjs-getter-this/main.cjs": { - "order": [ - "/tests/corpus/2166-cjs-getter-this/lib.cjs", - "/tests/corpus/2166-cjs-getter-this/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/2170-island-array-exits.ts": { - "order": [ - "/tests/corpus/2170-island-array-exits.ts" - ], - "diags": [] - }, - "/tests/corpus/2171-island-json-stringify.ts": { - "order": [ - "/tests/corpus/2171-island-json-stringify.ts" - ], - "diags": [] - }, - "/tests/corpus/2172-island-regexp-boundary.ts": { - "order": [ - "/tests/corpus/2172-island-regexp-boundary.ts" - ], - "diags": [] - }, - "/tests/corpus/2190-new-object-and-string-wrappers.ts": { - "order": [ - "/tests/corpus/2190-new-object-and-string-wrappers.ts" - ], - "diags": [] - }, - "/tests/corpus/2191-uri-encoders.ts": { - "order": [ - "/tests/corpus/2191-uri-encoders.ts" - ], - "diags": [] - }, - "/tests/corpus/2192-object-default-tostring.ts": { - "order": [ - "/tests/corpus/2192-object-default-tostring.ts" - ], - "diags": [] - }, - "/tests/corpus/2193-discarded-stdlib-reads.ts": { - "order": [ - "/tests/corpus/2193-discarded-stdlib-reads.ts" - ], - "diags": [] - }, - "/tests/corpus/2194-ambient-undef-chains.ts": { - "order": [ - "/tests/corpus/2194-ambient-undef-chains.ts" - ], - "diags": [] - }, - "/tests/corpus/2195-require-missing-package/main.mjs": { - "order": [ - "/tests/corpus/2195-require-missing-package/lib.cjs", - "/tests/corpus/2195-require-missing-package/main.mjs" - ], - "diags": [] - }, - "/tests/corpus/2196-island-computed-key-chain.ts": { - "order": [ - "/tests/corpus/2196-island-computed-key-chain.ts" - ], - "diags": [] - }, - "/tests/corpus/2210-dyn-promise-crossing.cjs": { - "order": [ - "/tests/corpus/2210-dyn-promise-crossing.cjs" - ], - "diags": [] - }, - "/tests/corpus/2211-dc-trace-promise.cjs": { - "order": [ - "/tests/corpus/2211-dc-trace-promise.cjs" - ], - "diags": [] - }, - "/tests/corpus/2212-unhandled-rejection-listener.cjs": { - "order": [ - "/tests/corpus/2212-unhandled-rejection-listener.cjs" - ], - "diags": [] - }, - "/tests/corpus/2213-async-local-storage.cjs": { - "order": [ - "/tests/corpus/2213-async-local-storage.cjs" - ], - "diags": [] - }, - "/tests/corpus/2214-dc-bind-store.cjs": { - "order": [ - "/tests/corpus/2214-dc-bind-store.cjs" - ], - "diags": [] - }, - "/tests/corpus/2215-process-emit-warning-exit.cjs": { - "order": [ - "/tests/corpus/2215-process-emit-warning-exit.cjs" - ], - "diags": [] - }, - "/tests/corpus/2240-width-class-into-record.ts": { - "order": [ - "/tests/corpus/2240-width-class-into-record.ts" - ], - "diags": [] - }, - "/tests/corpus/2241-width-record-into-class.ts": { - "order": [ - "/tests/corpus/2241-width-record-into-class.ts" - ], - "diags": [] - }, - "/tests/corpus/2242-width-statics-into-record.ts": { - "order": [ - "/tests/corpus/2242-width-statics-into-record.ts" - ], - "diags": [] - }, - "/tests/corpus/2243-width-assert-satisfies-shapes.ts": { - "order": [ - "/tests/corpus/2243-width-assert-satisfies-shapes.ts" - ], - "diags": [] - }, - "/tests/corpus/2250-tagged-templates.ts": { - "order": [ - "/tests/corpus/2250-tagged-templates.ts" - ], - "diags": [] - }, - "/tests/corpus/2251-tagged-templates-dyn.ts": { - "order": [ - "/tests/corpus/2251-tagged-templates-dyn.ts" - ], - "diags": [] - }, - "/tests/corpus/2252-class-iterators.ts": { - "order": [ - "/tests/corpus/2252-class-iterators.ts" - ], - "diags": [] - }, - "/tests/corpus/2253-union-coercions.ts": { - "order": [ - "/tests/corpus/2253-union-coercions.ts" - ], - "diags": [] - }, - "/tests/corpus/2260-http2-constants.cjs": { - "order": [ - "/tests/corpus/2260-http2-constants.cjs" - ], - "diags": [] - }, - "/tests/corpus/2280-builtin-namespace-destructure.cjs": { - "order": [ - "/tests/corpus/2280-builtin-namespace-destructure.cjs" - ], - "diags": [] - }, - "/tests/corpus/2281-domexception-atob-btoa.cjs": { - "order": [ - "/tests/corpus/2281-domexception-atob-btoa.cjs" - ], - "diags": [] - }, - "/tests/corpus/2282-queue-microtask.cjs": { - "order": [ - "/tests/corpus/2282-queue-microtask.cjs" - ], - "diags": [] - }, - "/tests/corpus/2283-structured-clone.cjs": { - "order": [ - "/tests/corpus/2283-structured-clone.cjs" - ], - "diags": [] - }, - "/tests/corpus/2284-regexp-constructor.cjs": { - "order": [ - "/tests/corpus/2284-regexp-constructor.cjs" - ], - "diags": [] - }, - "/tests/corpus/2285-iferror-dyn.cjs": { - "order": [ - "/tests/corpus/2285-iferror-dyn.cjs" - ], - "diags": [] - }, - "/tests/corpus/2286-dyn-object-walks.cjs": { - "order": [ - "/tests/corpus/2286-dyn-object-walks.cjs" - ], - "diags": [] - }, - "/tests/corpus/2300-dyn-record-spread-and-keyed-access.cjs": { - "order": [ - "/tests/corpus/2300-dyn-record-spread-and-keyed-access.cjs" - ], - "diags": [] - }, - "/tests/corpus/2301-cjs-export-table-dom-attach.cjs": { - "order": [ - "/tests/corpus/2301-cjs-export-table-dom-attach.cjs" - ], - "diags": [] - }, - "/tests/corpus/2310-process-next-tick.ts": { - "order": [ - "/tests/corpus/2310-process-next-tick.ts" - ], - "diags": [] - }, - "/tests/corpus/2311-next-tick-js-callbacks.js": { - "order": [ - "/tests/corpus/2311-next-tick-js-callbacks.js" - ], - "diags": [] - }, - "/tests/corpus/2312-stream-underscore-assign.ts": { - "order": [ - "/tests/corpus/2312-stream-underscore-assign.ts" - ], - "diags": [] - }, - "/tests/corpus/2313-stream-underscore-assign-js.cjs": { - "order": [ - "/tests/corpus/2313-stream-underscore-assign-js.cjs" - ], - "diags": [] - }, - "/tests/corpus/2314-process-introspection.ts": { - "order": [ - "/tests/corpus/2314-process-introspection.ts" - ], - "diags": [] - }, - "/tests/corpus/2320-await-unit.ts": { - "order": [ - "/tests/corpus/2320-await-unit.ts" - ], - "diags": [] - }, - "/tests/corpus/2321-emitter-static-setmax.cjs": { - "order": [ - "/tests/corpus/2321-emitter-static-setmax.cjs" - ], - "diags": [] - }, - "/tests/corpus/2322-dyn-array-sort.cjs": { - "order": [ - "/tests/corpus/2322-dyn-array-sort.cjs" - ], - "diags": [] - }, - "/tests/corpus/2323-timer-callback-returns.ts": { - "order": [ - "/tests/corpus/2323-timer-callback-returns.ts" - ], - "diags": [] - }, - "/tests/corpus/2330-tls-server-runtime-options.cjs": { - "order": [ - "/tests/corpus/2330-tls-server-runtime-options.cjs" - ], - "diags": [] - }, - "/tests/corpus/2331-tls-server-options-typed.ts": { - "order": [ - "/tests/corpus/2331-tls-server-options-typed.ts" - ], - "diags": [] - }, - "/tests/corpus/2350-nan-global.ts": { - "order": [ - "/tests/corpus/2350-nan-global.ts" - ], - "diags": [] - }, - "/tests/corpus/2351-async-methods.ts": { - "order": [ - "/tests/corpus/2351-async-methods.ts" - ], - "diags": [] - }, - "/tests/corpus/2352-void-coercions.ts": { - "order": [ - "/tests/corpus/2352-void-coercions.ts" - ], - "diags": [] - }, - "/tests/corpus/2353-decorators-member-ambient.ts": { - "order": [ - "/tests/corpus/2353-decorators-member-ambient.ts" - ], - "diags": [] - }, - "/tests/corpus/2354-decorators-expression-ambient.ts": { - "order": [ - "/tests/corpus/2354-decorators-expression-ambient.ts" - ], - "diags": [] - }, - "/tests/corpus/2360-tuple-to-array.ts": { - "order": [ - "/tests/corpus/2360-tuple-to-array.ts" - ], - "diags": [] - }, - "/tests/corpus/2361-assign-index-record.ts": { - "order": [ - "/tests/corpus/2361-assign-index-record.ts" - ], - "diags": [] - }, - "/tests/corpus/2362-execsync-inherit.ts": { - "order": [ - "/tests/corpus/2362-execsync-inherit.ts" - ], - "diags": [] - }, - "/tests/corpus/2363-nullish-retag.ts": { - "order": [ - "/tests/corpus/2363-nullish-retag.ts" - ], - "diags": [] - }, - "/tests/corpus/2364-in-runtime-key.ts": { - "order": [ - "/tests/corpus/2364-in-runtime-key.ts" - ], - "diags": [] - }, - "/tests/corpus/2365-dyn-into-island.ts": { - "order": [ - "/tests/corpus/2365-dyn-into-island.ts" - ], - "diags": [] - }, - "/tests/corpus/2366-string-well-formed.ts": { - "order": [ - "/tests/corpus/2366-string-well-formed.ts" - ], - "diags": [] - }, - "/tests/corpus/2367-regexp-escape.ts": { - "order": [ - "/tests/corpus/2367-regexp-escape.ts" - ], - "diags": [] - }, - "/tests/corpus/2368-set-methods.ts": { - "order": [ - "/tests/corpus/2368-set-methods.ts" - ], - "diags": [] - }, - "/tests/corpus/2369-promise-try.ts": { - "order": [ - "/tests/corpus/2369-promise-try.ts" - ], - "diags": [] - }, - "/tests/corpus/2370-group-by.ts": { - "order": [ - "/tests/corpus/2370-group-by.ts" - ], - "diags": [] - }, - "/tests/corpus/2371-iterator-helpers.ts": { - "order": [ - "/tests/corpus/2371-iterator-helpers.ts" - ], - "diags": [] - }, - "/tests/corpus/2380-buffer-module-named-import.ts": { - "order": [ - "/tests/corpus/2380-buffer-module-named-import.ts" - ], - "diags": [] - }, - "/tests/corpus/2381-builtin-default-imports.js": { - "order": [ - "/tests/corpus/2381-builtin-default-imports.js" - ], - "diags": [] - }, - "/tests/corpus/2382-cycle-two-decl/main.ts": { - "order": [ - "/tests/corpus/2382-cycle-two-decl/b.ts", - "/tests/corpus/2382-cycle-two-decl/a.ts", - "/tests/corpus/2382-cycle-two-decl/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2383-cycle-assertdoc/main.js": { - "order": [ - "/tests/corpus/2383-cycle-assertdoc/assert-doc.js", - "/tests/corpus/2383-cycle-assertdoc/builders.js", - "/tests/corpus/2383-cycle-assertdoc/index.js", - "/tests/corpus/2383-cycle-assertdoc/main.js" - ], - "diags": [] - }, - "/tests/corpus/2384-cycle-mixed-bindings/main.ts": { - "order": [ - "/tests/corpus/2384-cycle-mixed-bindings/render.ts", - "/tests/corpus/2384-cycle-mixed-bindings/config.ts", - "/tests/corpus/2384-cycle-mixed-bindings/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2385-builtin-reexport-facade/main.ts": { - "order": [ - "/tests/corpus/2385-builtin-reexport-facade/facade.ts", - "/tests/corpus/2385-builtin-reexport-facade/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2386-string-to-chars.ts": { - "order": [ - "/tests/corpus/2386-string-to-chars.ts" - ], - "diags": [] - }, - "/tests/corpus/2387-tonumber-argv.ts": { - "order": [ - "/tests/corpus/2387-tonumber-argv.ts" - ], - "diags": [] - }, - "/tests/corpus/2388-tonumber-grammar-zoo.ts": { - "order": [ - "/tests/corpus/2388-tonumber-grammar-zoo.ts" - ], - "diags": [] - }, - "/tests/corpus/2389-tonumber-unary-plus.ts": { - "order": [ - "/tests/corpus/2389-tonumber-unary-plus.ts" - ], - "diags": [] - }, - "/tests/corpus/2390-dot-requires/main.cjs": { - "order": [ - "/tests/corpus/2390-dot-requires/shared.cjs", - "/tests/corpus/2390-dot-requires/sub/index.cjs", - "/tests/corpus/2390-dot-requires/sub/child.cjs", - "/tests/corpus/2390-dot-requires/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/2391-default-builtin-imports/main.ts": { - "order": [ - "/tests/corpus/2391-default-builtin-imports/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2392-block-guard-alias-scope.ts": { - "order": [ - "/tests/corpus/2392-block-guard-alias-scope.ts" - ], - "diags": [] - }, - "/tests/corpus/2393-loop-exit-guard-narrow.ts": { - "order": [ - "/tests/corpus/2393-loop-exit-guard-narrow.ts" - ], - "diags": [] - }, - "/tests/corpus/2394-loop-narrow-containment.ts": { - "order": [ - "/tests/corpus/2394-loop-narrow-containment.ts" - ], - "diags": [] - }, - "/tests/corpus/2395-while-cond-guard.ts": { - "order": [ - "/tests/corpus/2395-while-cond-guard.ts" - ], - "diags": [] - }, - "/tests/corpus/2396-born-narrowed-decl.ts": { - "order": [ - "/tests/corpus/2396-born-narrowed-decl.ts" - ], - "diags": [] - }, - "/tests/corpus/2397-branch-kill-merge.ts": { - "order": [ - "/tests/corpus/2397-branch-kill-merge.ts" - ], - "diags": [] - }, - "/tests/corpus/2398-switch-arm-kill.ts": { - "order": [ - "/tests/corpus/2398-switch-arm-kill.ts" - ], - "diags": [] - }, - "/tests/corpus/2399-reassign-kill-polarity.ts": { - "order": [ - "/tests/corpus/2399-reassign-kill-polarity.ts" - ], - "diags": [] - }, - "/tests/corpus/240-stdout-write.ts": { - "order": [ - "/tests/corpus/240-stdout-write.ts" - ], - "diags": [] - }, - "/tests/corpus/2400-kill-return-edge.ts": { - "order": [ - "/tests/corpus/2400-kill-return-edge.ts" - ], - "diags": [] - }, - "/tests/corpus/2401-kill-break-staging.ts": { - "order": [ - "/tests/corpus/2401-kill-break-staging.ts" - ], - "diags": [] - }, - "/tests/corpus/2402-labeled-break-kill.ts": { - "order": [ - "/tests/corpus/2402-labeled-break-kill.ts" - ], - "diags": [] - }, - "/tests/corpus/2403-kill-continue-backedge.ts": { - "order": [ - "/tests/corpus/2403-kill-continue-backedge.ts" - ], - "diags": [] - }, - "/tests/corpus/2404-kill-throw-catch.ts": { - "order": [ - "/tests/corpus/2404-kill-throw-catch.ts" - ], - "diags": [] - }, - "/tests/corpus/2405-sibling-arm-narrow.ts": { - "order": [ - "/tests/corpus/2405-sibling-arm-narrow.ts" - ], - "diags": [] - }, - "/tests/corpus/2406-switch-clause-sibling-narrow.ts": { - "order": [ - "/tests/corpus/2406-switch-clause-sibling-narrow.ts" - ], - "diags": [] - }, - "/tests/corpus/2407-infinite-loop-seal.ts": { - "order": [ - "/tests/corpus/2407-infinite-loop-seal.ts" - ], - "diags": [] - }, - "/tests/corpus/2408-loop-terminality-reopen.ts": { - "order": [ - "/tests/corpus/2408-loop-terminality-reopen.ts" - ], - "diags": [] - }, - "/tests/corpus/2409-loop-body-return-not-terminal.ts": { - "order": [ - "/tests/corpus/2409-loop-body-return-not-terminal.ts" - ], - "diags": [] - }, - "/tests/corpus/2410-stacked-cases-terminality.ts": { - "order": [ - "/tests/corpus/2410-stacked-cases-terminality.ts" - ], - "diags": [] - }, - "/tests/corpus/2411-exhaustive-switch-terminality.ts": { - "order": [ - "/tests/corpus/2411-exhaustive-switch-terminality.ts" - ], - "diags": [] - }, - "/tests/corpus/2412-dowhile-guard-trailing-test.ts": { - "order": [ - "/tests/corpus/2412-dowhile-guard-trailing-test.ts" - ], - "diags": [] - }, - "/tests/corpus/2413-dowhile-kill-renarrow.ts": { - "order": [ - "/tests/corpus/2413-dowhile-kill-renarrow.ts" - ], - "diags": [] - }, - "/tests/corpus/2414-dowhile-continue-kill.ts": { - "order": [ - "/tests/corpus/2414-dowhile-continue-kill.ts" - ], - "diags": [] - }, - "/tests/corpus/2415-dowhile-break-trailing-test.ts": { - "order": [ - "/tests/corpus/2415-dowhile-break-trailing-test.ts" - ], - "diags": [] - }, - "/tests/corpus/2416-spread-ternary-positions.ts": { - "order": [ - "/tests/corpus/2416-spread-ternary-positions.ts" - ], - "diags": [] - }, - "/tests/corpus/2417-ternary-local-inference.ts": { - "order": [ - "/tests/corpus/2417-ternary-local-inference.ts" - ], - "diags": [] - }, - "/tests/corpus/2418-wrapped-ternary-arms.ts": { - "order": [ - "/tests/corpus/2418-wrapped-ternary-arms.ts" - ], - "diags": [] - }, - "/tests/corpus/2419-selector-ternary-union.ts": { - "order": [ - "/tests/corpus/2419-selector-ternary-union.ts" - ], - "diags": [] - }, - "/tests/corpus/2420-nullish-null-identity.ts": { - "order": [ - "/tests/corpus/2420-nullish-null-identity.ts" - ], - "diags": [] - }, - "/tests/corpus/2421-float-lane-inference.ts": { - "order": [ - "/tests/corpus/2421-float-lane-inference.ts" - ], - "diags": [] - }, - "/tests/corpus/2422-ieee-div-rem-corners.ts": { - "order": [ - "/tests/corpus/2422-ieee-div-rem-corners.ts" - ], - "diags": [] - }, - "/tests/corpus/2423-param-null-reassign.ts": { - "order": [ - "/tests/corpus/2423-param-null-reassign.ts" - ], - "diags": [] - }, - "/tests/corpus/2424-ternary-miss-first-narrowing.ts": { - "order": [ - "/tests/corpus/2424-ternary-miss-first-narrowing.ts" - ], - "diags": [] - }, - "/tests/corpus/2425-elseif-head-exit-narrow.ts": { - "order": [ - "/tests/corpus/2425-elseif-head-exit-narrow.ts" - ], - "diags": [] - }, - "/tests/corpus/2426-default-snapshot-mutable/main.ts": { - "order": [ - "/tests/corpus/2426-default-snapshot-mutable/m.ts", - "/tests/corpus/2426-default-snapshot-mutable/live.ts", - "/tests/corpus/2426-default-snapshot-mutable/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2427-perf-hooks-now.ts": { - "order": [ - "/tests/corpus/2427-perf-hooks-now.ts" - ], - "diags": [] - }, - "/tests/corpus/2428-field-redeclare-inherited.ts": { - "order": [ - "/tests/corpus/2428-field-redeclare-inherited.ts" - ], - "diags": [] - }, - "/tests/corpus/2429-destructure-class-instance.ts": { - "order": [ - "/tests/corpus/2429-destructure-class-instance.ts" - ], - "diags": [] - }, - "/tests/corpus/2430-empty-literal-unknown-field.js": { - "order": [ - "/tests/corpus/2430-empty-literal-unknown-field.js" - ], - "diags": [] - }, - "/tests/corpus/2431-primitive-ctor-values.ts": { - "order": [ - "/tests/corpus/2431-primitive-ctor-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2432-generic-member-fields-async.ts": { - "order": [ - "/tests/corpus/2432-generic-member-fields-async.ts" - ], - "diags": [] - }, - "/tests/corpus/2433-as-const-command-tables.ts": { - "order": [ - "/tests/corpus/2433-as-const-command-tables.ts" - ], - "diags": [] - }, - "/tests/corpus/2434-deferred-init-fields.ts": { - "order": [ - "/tests/corpus/2434-deferred-init-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/2435-loose-same-kind-equality.ts": { - "order": [ - "/tests/corpus/2435-loose-same-kind-equality.ts" - ], - "diags": [] - }, - "/tests/corpus/2440-console-inspect-args.ts": { - "order": [ - "/tests/corpus/2440-console-inspect-args.ts" - ], - "diags": [] - }, - "/tests/corpus/2441-console-process-argv.ts": { - "order": [ - "/tests/corpus/2441-console-process-argv.ts" - ], - "diags": [] - }, - "/tests/corpus/2442-union-literal-arm-widening.ts": { - "order": [ - "/tests/corpus/2442-union-literal-arm-widening.ts" - ], - "diags": [] - }, - "/tests/corpus/2443-union-literal-shadow-narrowing.ts": { - "order": [ - "/tests/corpus/2443-union-literal-shadow-narrowing.ts" - ], - "diags": [] - }, - "/tests/corpus/2444-union-literal-reducer-spread.ts": { - "order": [ - "/tests/corpus/2444-union-literal-reducer-spread.ts" - ], - "diags": [] - }, - "/tests/corpus/2445-math-minmax-nary.ts": { - "order": [ - "/tests/corpus/2445-math-minmax-nary.ts" - ], - "diags": [] - }, - "/tests/corpus/2446-performance-global.ts": { - "order": [ - "/tests/corpus/2446-performance-global.ts" - ], - "diags": [] - }, - "/tests/corpus/2447-island-boundary-slots/main.ts": { - "order": [ - "/tests/corpus/2447-island-boundary-slots/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2448-entries-null-arms-regex-arrays.ts": { - "order": [ - "/tests/corpus/2448-entries-null-arms-regex-arrays.ts" - ], - "diags": [] - }, - "/tests/corpus/2449-js-dyn-worlds/main.js": { - "order": [ - "/tests/corpus/2449-js-dyn-worlds/walker.js", - "/tests/corpus/2449-js-dyn-worlds/main.js" - ], - "diags": [] - }, - "/tests/corpus/2450-private-instance-methods.ts": { - "order": [ - "/tests/corpus/2450-private-instance-methods.ts" - ], - "diags": [] - }, - "/tests/corpus/2451-private-fields.ts": { - "order": [ - "/tests/corpus/2451-private-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/2452-private-statics.ts": { - "order": [ - "/tests/corpus/2452-private-statics.ts" - ], - "diags": [] - }, - "/tests/corpus/2453-private-accessors.ts": { - "order": [ - "/tests/corpus/2453-private-accessors.ts" - ], - "diags": [] - }, - "/tests/corpus/2454-private-generator-methods.ts": { - "order": [ - "/tests/corpus/2454-private-generator-methods.ts" - ], - "diags": [] - }, - "/tests/corpus/2455-private-brand-checks.ts": { - "order": [ - "/tests/corpus/2455-private-brand-checks.ts" - ], - "diags": [] - }, - "/tests/corpus/2456-private-async-methods.ts": { - "order": [ - "/tests/corpus/2456-private-async-methods.ts" - ], - "diags": [] - }, - "/tests/corpus/2457-private-members.js": { - "order": [ - "/tests/corpus/2457-private-members.js" - ], - "diags": [] - }, - "/tests/corpus/2460-qs-parse-grammar.ts": { - "order": [ - "/tests/corpus/2460-qs-parse-grammar.ts" - ], - "diags": [] - }, - "/tests/corpus/2461-qs-parse-options.ts": { - "order": [ - "/tests/corpus/2461-qs-parse-options.ts" - ], - "diags": [] - }, - "/tests/corpus/2462-qs-stringify.ts": { - "order": [ - "/tests/corpus/2462-qs-stringify.ts" - ], - "diags": [] - }, - "/tests/corpus/2463-qs-escape-unescape.ts": { - "order": [ - "/tests/corpus/2463-qs-escape-unescape.ts" - ], - "diags": [] - }, - "/tests/corpus/2464-qs-require-forms.cjs": { - "order": [ - "/tests/corpus/2464-qs-require-forms.cjs" - ], - "diags": [] - }, - "/tests/corpus/2470-mockable-module-shape.js": { - "order": [ - "/tests/corpus/2470-mockable-module-shape.js" - ], - "diags": [] - }, - "/tests/corpus/2471-record-keyed-write-hasown.js": { - "order": [ - "/tests/corpus/2471-record-keyed-write-hasown.js" - ], - "diags": [] - }, - "/tests/corpus/2472-string-regexp-union.ts": { - "order": [ - "/tests/corpus/2472-string-regexp-union.ts" - ], - "diags": [] - }, - "/tests/corpus/2473-option-table-widths.js": { - "order": [ - "/tests/corpus/2473-option-table-widths.js" - ], - "diags": [] - }, - "/tests/corpus/2474-island-literal-forms.ts": { - "order": [ - "/tests/corpus/2474-island-literal-forms.ts" - ], - "diags": [] - }, - "/tests/corpus/2475-variadic-wrapper-island.js": { - "order": [ - "/tests/corpus/2475-variadic-wrapper-island.js" - ], - "diags": [] - }, - "/tests/corpus/2476-map-regex-values.ts": { - "order": [ - "/tests/corpus/2476-map-regex-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2480-recursive-record-tree.ts": { - "order": [ - "/tests/corpus/2480-recursive-record-tree.ts" - ], - "diags": [] - }, - "/tests/corpus/2481-mutual-recursive-records.ts": { - "order": [ - "/tests/corpus/2481-mutual-recursive-records.ts" - ], - "diags": [] - }, - "/tests/corpus/2482-recursive-union-tree.ts": { - "order": [ - "/tests/corpus/2482-recursive-union-tree.ts" - ], - "diags": [] - }, - "/tests/corpus/2483-recursive-record-cycles.ts": { - "order": [ - "/tests/corpus/2483-recursive-record-cycles.ts" - ], - "diags": [] - }, - "/tests/corpus/2484-json-stringify-circular.ts": { - "order": [ - "/tests/corpus/2484-json-stringify-circular.ts" - ], - "diags": [] - }, - "/tests/corpus/2485-inspect-circular-refs.ts": { - "order": [ - "/tests/corpus/2485-inspect-circular-refs.ts" - ], - "diags": [] - }, - "/tests/corpus/2486-recursive-record-boundaries.ts": { - "order": [ - "/tests/corpus/2486-recursive-record-boundaries.ts" - ], - "diags": [] - }, - "/tests/corpus/2487-recursive-deep-equal.ts": { - "order": [ - "/tests/corpus/2487-recursive-deep-equal.ts" - ], - "diags": [] - }, - "/tests/corpus/2488-ast-walker.ts": { - "order": [ - "/tests/corpus/2488-ast-walker.ts" - ], - "diags": [] - }, - "/tests/corpus/2490-find-miss-null-compare.ts": { - "order": [ - "/tests/corpus/2490-find-miss-null-compare.ts" - ], - "diags": [] - }, - "/tests/corpus/2491-strict-unit-compare-no-arm.ts": { - "order": [ - "/tests/corpus/2491-strict-unit-compare-no-arm.ts" - ], - "diags": [] - }, - "/tests/corpus/2492-loose-null-compare-unions.ts": { - "order": [ - "/tests/corpus/2492-loose-null-compare-unions.ts" - ], - "diags": [] - }, - "/tests/corpus/2493-switch-unit-cases.ts": { - "order": [ - "/tests/corpus/2493-switch-unit-cases.ts" - ], - "diags": [] - }, - "/tests/corpus/2494-no-arm-compare-effects.ts": { - "order": [ - "/tests/corpus/2494-no-arm-compare-effects.ts" - ], - "diags": [] - }, - "/tests/corpus/2500-net-autosel-timeout.ts": { - "order": [ - "/tests/corpus/2500-net-autosel-timeout.ts" - ], - "diags": [] - }, - "/tests/corpus/2510-dyn-evolving-array-map.ts": { - "order": [ - "/tests/corpus/2510-dyn-evolving-array-map.ts" - ], - "diags": [] - }, - "/tests/corpus/2511-dyn-evolving-array-filter-foreach.ts": { - "order": [ - "/tests/corpus/2511-dyn-evolving-array-filter-foreach.ts" - ], - "diags": [] - }, - "/tests/corpus/2512-dyn-evolving-array-mixed-push.ts": { - "order": [ - "/tests/corpus/2512-dyn-evolving-array-mixed-push.ts" - ], - "diags": [] - }, - "/tests/corpus/2513-dyn-evolving-array-derived.ts": { - "order": [ - "/tests/corpus/2513-dyn-evolving-array-derived.ts" - ], - "diags": [] - }, - "/tests/corpus/2520-private-statics-class-name-calls.ts": { - "order": [ - "/tests/corpus/2520-private-statics-class-name-calls.ts" - ], - "diags": [] - }, - "/tests/corpus/2521-private-statics-class-expression.ts": { - "order": [ - "/tests/corpus/2521-private-statics-class-expression.ts" - ], - "diags": [] - }, - "/tests/corpus/2522-private-statics-decorated.ts": { - "order": [ - "/tests/corpus/2522-private-statics-decorated.ts" - ], - "diags": [] - }, - "/tests/corpus/2523-private-statics-aliased-class.ts": { - "order": [ - "/tests/corpus/2523-private-statics-aliased-class.ts" - ], - "diags": [] - }, - "/tests/corpus/2530-object-destructuring-decl.ts": { - "order": [ - "/tests/corpus/2530-object-destructuring-decl.ts" - ], - "diags": [] - }, - "/tests/corpus/2531-array-tuple-destructuring-decl.ts": { - "order": [ - "/tests/corpus/2531-array-tuple-destructuring-decl.ts" - ], - "diags": [] - }, - "/tests/corpus/2532-param-destructuring-options.ts": { - "order": [ - "/tests/corpus/2532-param-destructuring-options.ts" - ], - "diags": [] - }, - "/tests/corpus/2533-forof-destructuring.ts": { - "order": [ - "/tests/corpus/2533-forof-destructuring.ts" - ], - "diags": [] - }, - "/tests/corpus/2534-object-rest-decl.ts": { - "order": [ - "/tests/corpus/2534-object-rest-decl.ts" - ], - "diags": [] - }, - "/tests/corpus/2535-destructuring-assign-basics.ts": { - "order": [ - "/tests/corpus/2535-destructuring-assign-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/2536-destructuring-assign-nested.ts": { - "order": [ - "/tests/corpus/2536-destructuring-assign-nested.ts" - ], - "diags": [] - }, - "/tests/corpus/2537-destructuring-assign-member-targets.ts": { - "order": [ - "/tests/corpus/2537-destructuring-assign-member-targets.ts" - ], - "diags": [] - }, - "/tests/corpus/2538-destructuring-assign-class-source.ts": { - "order": [ - "/tests/corpus/2538-destructuring-assign-class-source.ts" - ], - "diags": [] - }, - "/tests/corpus/2539-class-instance-rest.ts": { - "order": [ - "/tests/corpus/2539-class-instance-rest.ts" - ], - "diags": [] - }, - "/tests/corpus/2540-accessor-destructuring-defaults.ts": { - "order": [ - "/tests/corpus/2540-accessor-destructuring-defaults.ts" - ], - "diags": [] - }, - "/tests/corpus/2541-destructuring-eval-order.ts": { - "order": [ - "/tests/corpus/2541-destructuring-eval-order.ts" - ], - "diags": [] - }, - "/tests/corpus/2550-generics-keyof-pick.ts": { - "order": [ - "/tests/corpus/2550-generics-keyof-pick.ts" - ], - "diags": [] - }, - "/tests/corpus/2551-generics-value-aliases.ts": { - "order": [ - "/tests/corpus/2551-generics-value-aliases.ts" - ], - "diags": [] - }, - "/tests/corpus/2552-generics-iface-methods.ts": { - "order": [ - "/tests/corpus/2552-generics-iface-methods.ts" - ], - "diags": [] - }, - "/tests/corpus/2553-generics-signature-bindings.ts": { - "order": [ - "/tests/corpus/2553-generics-signature-bindings.ts" - ], - "diags": [] - }, - "/tests/corpus/2554-generics-frontier-mix.ts": { - "order": [ - "/tests/corpus/2554-generics-frontier-mix.ts" - ], - "diags": [] - }, - "/tests/corpus/2555-generics-keyof-writes.ts": { - "order": [ - "/tests/corpus/2555-generics-keyof-writes.ts" - ], - "diags": [] - }, - "/tests/corpus/2556-crypto-introspection.ts": { - "order": [ - "/tests/corpus/2556-crypto-introspection.ts" - ], - "diags": [] - }, - "/tests/corpus/2556-width-hybrid-shapes.ts": { - "order": [ - "/tests/corpus/2556-width-hybrid-shapes.ts" - ], - "diags": [] - }, - "/tests/corpus/2557-tls-ca-store.ts": { - "order": [ - "/tests/corpus/2557-tls-ca-store.ts" - ], - "diags": [] - }, - "/tests/corpus/2557-width-field-lifts.ts": { - "order": [ - "/tests/corpus/2557-width-field-lifts.ts" - ], - "diags": [] - }, - "/tests/corpus/2558-index-signature-func-values.ts": { - "order": [ - "/tests/corpus/2558-index-signature-func-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2558-rejection-events.cjs": { - "order": [ - "/tests/corpus/2558-rejection-events.cjs" - ], - "diags": [] - }, - "/tests/corpus/2559-index-signature-container-values.ts": { - "order": [ - "/tests/corpus/2559-index-signature-container-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2560-arraybuffer-dataview-set.ts": { - "order": [ - "/tests/corpus/2560-arraybuffer-dataview-set.ts" - ], - "diags": [] - }, - "/tests/corpus/2561-object-is.ts": { - "order": [ - "/tests/corpus/2561-object-is.ts" - ], - "diags": [] - }, - "/tests/corpus/2562-intl-numberformat-en-us.ts": { - "order": [ - "/tests/corpus/2562-intl-numberformat-en-us.ts" - ], - "diags": [] - }, - "/tests/corpus/2563-stream-promises-pipeline.ts": { - "order": [ - "/tests/corpus/2563-stream-promises-pipeline.ts" - ], - "diags": [] - }, - "/tests/corpus/2564-stream-promises-finished.ts": { - "order": [ - "/tests/corpus/2564-stream-promises-finished.ts" - ], - "diags": [] - }, - "/tests/corpus/2565-stream-promises-js.cjs": { - "order": [ - "/tests/corpus/2565-stream-promises-js.cjs" - ], - "diags": [] - }, - "/tests/corpus/2566-promise-reject-dyn-reason.js": { - "order": [ - "/tests/corpus/2566-promise-reject-dyn-reason.js" - ], - "diags": [] - }, - "/tests/corpus/2567-rest-spread-forward.js": { - "order": [ - "/tests/corpus/2567-rest-spread-forward.js" - ], - "diags": [] - }, - "/tests/corpus/2568-rest-spread-forward-dynamic.js": { - "order": [ - "/tests/corpus/2568-rest-spread-forward-dynamic.js" - ], - "diags": [] - }, - "/tests/corpus/2569-upcast-identity.ts": { - "order": [ - "/tests/corpus/2569-upcast-identity.ts" - ], - "diags": [] - }, - "/tests/corpus/2570-buffer-arg-validation.cjs": { - "order": [ - "/tests/corpus/2570-buffer-arg-validation.cjs" - ], - "diags": [] - }, - "/tests/corpus/2571-searchparams-arg-validation.cjs": { - "order": [ - "/tests/corpus/2571-searchparams-arg-validation.cjs" - ], - "diags": [] - }, - "/tests/corpus/2572-readable-emitted-readable-flag.cjs": { - "order": [ - "/tests/corpus/2572-readable-emitted-readable-flag.cjs" - ], - "diags": [] - }, - "/tests/corpus/2573-fs-url-arg-ladders.cjs": { - "order": [ - "/tests/corpus/2573-fs-url-arg-ladders.cjs" - ], - "diags": [] - }, - "/tests/corpus/2574-emitter-max-listeners-ladders.cjs": { - "order": [ - "/tests/corpus/2574-emitter-max-listeners-ladders.cjs" - ], - "diags": [] - }, - "/tests/corpus/2575-string-destructuring-decl.ts": { - "order": [ - "/tests/corpus/2575-string-destructuring-decl.ts" - ], - "diags": [] - }, - "/tests/corpus/2576-string-destructuring-assign.ts": { - "order": [ - "/tests/corpus/2576-string-destructuring-assign.ts" - ], - "diags": [] - }, - "/tests/corpus/2577-builtin-global-destructuring.js": { - "order": [ - "/tests/corpus/2577-builtin-global-destructuring.js" - ], - "diags": [] - }, - "/tests/corpus/2578-jsval-into-unknown-rows.ts": { - "order": [ - "/tests/corpus/2578-jsval-into-unknown-rows.ts" - ], - "diags": [] - }, - "/tests/corpus/2579-jsval-object-param-crossing.js": { - "order": [ - "/tests/corpus/2579-jsval-object-param-crossing.js" - ], - "diags": [] - }, - "/tests/corpus/2580-jsval-routed-keyed-ops.js": { - "order": [ - "/tests/corpus/2580-jsval-routed-keyed-ops.js" - ], - "diags": [] - }, - "/tests/corpus/2581-jsval-routed-calls.js": { - "order": [ - "/tests/corpus/2581-jsval-routed-calls.js" - ], - "diags": [] - }, - "/tests/corpus/2582-jsval-object-statics.js": { - "order": [ - "/tests/corpus/2582-jsval-object-statics.js" - ], - "diags": [] - }, - "/tests/corpus/2582-jsval-routed-keyed-ops.js": { - "order": [ - "/tests/corpus/2582-jsval-routed-keyed-ops.js" - ], - "diags": [] - }, - "/tests/corpus/2583-dyn-nullish-coalesce.js": { - "order": [ - "/tests/corpus/2583-dyn-nullish-coalesce.js" - ], - "diags": [] - }, - "/tests/corpus/2583-jsval-routed-calls.js": { - "order": [ - "/tests/corpus/2583-jsval-routed-calls.js" - ], - "diags": [] - }, - "/tests/corpus/2584-jsval-object-statics.js": { - "order": [ - "/tests/corpus/2584-jsval-object-statics.js" - ], - "diags": [] - }, - "/tests/corpus/2584-union-dyn-collapse.ts": { - "order": [ - "/tests/corpus/2584-union-dyn-collapse.ts" - ], - "diags": [] - }, - "/tests/corpus/2585-dyn-nullish-coalesce.js": { - "order": [ - "/tests/corpus/2585-dyn-nullish-coalesce.js" - ], - "diags": [] - }, - "/tests/corpus/2585-unknown-array.ts": { - "order": [ - "/tests/corpus/2585-unknown-array.ts" - ], - "diags": [] - }, - "/tests/corpus/2586-object-assign-spread.js": { - "order": [ - "/tests/corpus/2586-object-assign-spread.js" - ], - "diags": [] - }, - "/tests/corpus/2587-array-entries-forof.ts": { - "order": [ - "/tests/corpus/2587-array-entries-forof.ts" - ], - "diags": [] - }, - "/tests/corpus/2588-array-entries-chains.ts": { - "order": [ - "/tests/corpus/2588-array-entries-chains.ts" - ], - "diags": [] - }, - "/tests/corpus/2589-object-create-null.cjs": { - "order": [ - "/tests/corpus/2589-object-create-null.cjs" - ], - "diags": [] - }, - "/tests/corpus/2590-object-create-dynamic.js": { - "order": [ - "/tests/corpus/2590-object-create-dynamic.js" - ], - "diags": [] - }, - "/tests/corpus/2591-ambient-generic-traps.ts": { - "order": [ - "/tests/corpus/2591-ambient-generic-traps.ts" - ], - "diags": [] - }, - "/tests/corpus/2592-ambient-trap-uncaught.ts": { - "order": [ - "/tests/corpus/2592-ambient-trap-uncaught.ts" - ], - "diags": [] - }, - "/tests/corpus/2593-generic-inert-bindings.ts": { - "order": [ - "/tests/corpus/2593-generic-inert-bindings.ts" - ], - "diags": [] - }, - "/tests/corpus/2594-nullish-generic-bindings.ts": { - "order": [ - "/tests/corpus/2594-nullish-generic-bindings.ts" - ], - "diags": [] - }, - "/tests/corpus/2595-fs-arg-ladders.cjs": { - "order": [ - "/tests/corpus/2595-fs-arg-ladders.cjs" - ], - "diags": [] - }, - "/tests/corpus/2596-net-arg-ladders.cjs": { - "order": [ - "/tests/corpus/2596-net-arg-ladders.cjs" - ], - "diags": [] - }, - "/tests/corpus/2597-dgram-send-ladders.cjs": { - "order": [ - "/tests/corpus/2597-dgram-send-ladders.cjs" - ], - "diags": [] - }, - "/tests/corpus/2598-tls-arg-ladders.cjs": { - "order": [ - "/tests/corpus/2598-tls-arg-ladders.cjs" - ], - "diags": [] - }, - "/tests/corpus/2599-stream-arg-ladders.cjs": { - "order": [ - "/tests/corpus/2599-stream-arg-ladders.cjs" - ], - "diags": [] - }, - "/tests/corpus/2600-dyn-keyed-write-harness.js": { - "order": [ - "/tests/corpus/2600-dyn-keyed-write-harness.js" - ], - "diags": [] - }, - "/tests/corpus/2601-dyn-keyed-write-ops.js": { - "order": [ - "/tests/corpus/2601-dyn-keyed-write-ops.js" - ], - "diags": [] - }, - "/tests/corpus/2602-dyn-array-destructure.js": { - "order": [ - "/tests/corpus/2602-dyn-array-destructure.js" - ], - "diags": [] - }, - "/tests/corpus/2603-island-keyed-write-dyn.js": { - "order": [ - "/tests/corpus/2603-island-keyed-write-dyn.js" - ], - "diags": [] - }, - "/tests/corpus/2604-cycle-classes-mutual/main.ts": { - "order": [ - "/tests/corpus/2604-cycle-classes-mutual/group.ts", - "/tests/corpus/2604-cycle-classes-mutual/item.ts", - "/tests/corpus/2604-cycle-classes-mutual/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2605-cycle-three-module/main.ts": { - "order": [ - "/tests/corpus/2605-cycle-three-module/c.ts", - "/tests/corpus/2605-cycle-three-module/b.ts", - "/tests/corpus/2605-cycle-three-module/a.ts", - "/tests/corpus/2605-cycle-three-module/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2606-dynamic-import-cycle/main.ts": { - "order": [ - "/tests/corpus/2606-dynamic-import-cycle/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2608-regex-named-groups.ts": { - "order": [ - "/tests/corpus/2608-regex-named-groups.ts" - ], - "diags": [] - }, - "/tests/corpus/2609-regex-named-replace.ts": { - "order": [ - "/tests/corpus/2609-regex-named-replace.ts" - ], - "diags": [] - }, - "/tests/corpus/2610-regex-named-matchall.ts": { - "order": [ - "/tests/corpus/2610-regex-named-matchall.ts" - ], - "diags": [] - }, - "/tests/corpus/2611-regex-named-groups-js.cjs": { - "order": [ - "/tests/corpus/2611-regex-named-groups-js.cjs" - ], - "diags": [] - }, - "/tests/corpus/2613-for-init-uninitialized-let.ts": { - "order": [ - "/tests/corpus/2613-for-init-uninitialized-let.ts" - ], - "diags": [] - }, - "/tests/corpus/2614-trap-binding-later-writes.ts": { - "order": [ - "/tests/corpus/2614-trap-binding-later-writes.ts" - ], - "diags": [] - }, - "/tests/corpus/2615-nullish-field-record-binding.ts": { - "order": [ - "/tests/corpus/2615-nullish-field-record-binding.ts" - ], - "diags": [] - }, - "/tests/corpus/2616-js-collect-probe-defers.js": { - "order": [ - "/tests/corpus/2616-js-collect-probe-defers.js" - ], - "diags": [] - }, - "/tests/corpus/2617-enum-static-field-import/main.ts": { - "order": [ - "/tests/corpus/2617-enum-static-field-import/a.ts", - "/tests/corpus/2617-enum-static-field-import/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2618-ee-emit-override.ts": { - "order": [ - "/tests/corpus/2618-ee-emit-override.ts" - ], - "diags": [] - }, - "/tests/corpus/2619-ee-override-chain.ts": { - "order": [ - "/tests/corpus/2619-ee-override-chain.ts" - ], - "diags": [] - }, - "/tests/corpus/2620-ee-override-once-order.ts": { - "order": [ - "/tests/corpus/2620-ee-override-once-order.ts" - ], - "diags": [] - }, - "/tests/corpus/2621-ee-override-error-throw.ts": { - "order": [ - "/tests/corpus/2621-ee-override-error-throw.ts" - ], - "diags": [] - }, - "/tests/corpus/2622-ee-override-filter.ts": { - "order": [ - "/tests/corpus/2622-ee-override-filter.ts" - ], - "diags": [] - }, - "/tests/corpus/2623-ee-job-queue.ts": { - "order": [ - "/tests/corpus/2623-ee-job-queue.ts" - ], - "diags": [] - }, - "/tests/corpus/2624-ee-override-js.cjs": { - "order": [ - "/tests/corpus/2624-ee-override-js.cjs" - ], - "diags": [] - }, - "/tests/corpus/2625-bytes-views.ts": { - "order": [ - "/tests/corpus/2625-bytes-views.ts" - ], - "diags": [] - }, - "/tests/corpus/2626-stream-event-names.ts": { - "order": [ - "/tests/corpus/2626-stream-event-names.ts" - ], - "diags": [] - }, - "/tests/corpus/2627-stream-ticks-are-nextticks.ts": { - "order": [ - "/tests/corpus/2627-stream-ticks-are-nextticks.ts" - ], - "diags": [] - }, - "/tests/corpus/2628-stream-push-encodings.cjs": { - "order": [ - "/tests/corpus/2628-stream-push-encodings.cjs" - ], - "diags": [] - }, - "/tests/corpus/2629-stream-consumers.ts": { - "order": [ - "/tests/corpus/2629-stream-consumers.ts" - ], - "diags": [] - }, - "/tests/corpus/2630-stream-consumers-errors.ts": { - "order": [ - "/tests/corpus/2630-stream-consumers-errors.ts" - ], - "diags": [] - }, - "/tests/corpus/2631-create-require/main.ts": { - "order": [ - "/tests/corpus/2631-create-require/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2632-dyn-jsval-iterate.js": { - "order": [ - "/tests/corpus/2632-dyn-jsval-iterate.js" - ], - "diags": [] - }, - "/tests/corpus/2633-island-promise-crossing.js": { - "order": [ - "/tests/corpus/2633-island-promise-crossing.js" - ], - "diags": [] - }, - "/tests/corpus/2634-stream-pipeline-arg-ladders.cjs": { - "order": [ - "/tests/corpus/2634-stream-pipeline-arg-ladders.cjs" - ], - "diags": [] - }, - "/tests/corpus/2635-trap-binding-unmappable-written.ts": { - "order": [ - "/tests/corpus/2635-trap-binding-unmappable-written.ts" - ], - "diags": [] - }, - "/tests/corpus/2636-trap-binding-ambient-rooted-rewrite.ts": { - "order": [ - "/tests/corpus/2636-trap-binding-ambient-rooted-rewrite.ts" - ], - "diags": [] - }, - "/tests/corpus/2637-create-require-bare/main.ts": { - "order": [ - "/tests/corpus/2637-create-require-bare/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2638-http-dyn-res-compat.cjs": { - "order": [ - "/tests/corpus/2638-http-dyn-res-compat.cjs" - ], - "diags": [] - }, - "/tests/corpus/2639-http-dyn-req-pause.cjs": { - "order": [ - "/tests/corpus/2639-http-dyn-req-pause.cjs" - ], - "diags": [] - }, - "/tests/corpus/2640-net-dyn-socket-compat.cjs": { - "order": [ - "/tests/corpus/2640-net-dyn-socket-compat.cjs" - ], - "diags": [] - }, - "/tests/corpus/2641-http-agent-surface.cjs": { - "order": [ - "/tests/corpus/2641-http-agent-surface.cjs" - ], - "diags": [] - }, - "/tests/corpus/2642-http-agent-maxsockets.cjs": { - "order": [ - "/tests/corpus/2642-http-agent-maxsockets.cjs" - ], - "diags": [] - }, - "/tests/corpus/2643-or-default-retag.ts": { - "order": [ - "/tests/corpus/2643-or-default-retag.ts" - ], - "diags": [] - }, - "/tests/corpus/2644-http-client-url-argument.ts": { - "order": [ - "/tests/corpus/2644-http-client-url-argument.ts" - ], - "diags": [] - }, - "/tests/corpus/2645-https-client-url-argument.ts": { - "order": [ - "/tests/corpus/2645-https-client-url-argument.ts" - ], - "diags": [] - }, - "/tests/corpus/2646-top-level-await.ts": { - "order": [ - "/tests/corpus/2646-top-level-await.ts" - ], - "diags": [] - }, - "/tests/corpus/2647-top-level-await-modules/main.ts": { - "order": [ - "/tests/corpus/2647-top-level-await-modules/shared.ts", - "/tests/corpus/2647-top-level-await-modules/left.ts", - "/tests/corpus/2647-top-level-await-modules/sibling.ts", - "/tests/corpus/2647-top-level-await-modules/right.ts", - "/tests/corpus/2647-top-level-await-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2648-top-level-await-rejection.ts": { - "order": [ - "/tests/corpus/2648-top-level-await-rejection.ts" - ], - "diags": [] - }, - "/tests/corpus/2649-top-level-await-pending.ts": { - "order": [ - "/tests/corpus/2649-top-level-await-pending.ts" - ], - "diags": [] - }, - "/tests/corpus/2650-top-level-await-self-import.ts": { - "order": [ - "/tests/corpus/2650-top-level-await-self-import.ts" - ], - "diags": [] - }, - "/tests/corpus/2651-top-level-await-pending-unhandled.ts": { - "order": [ - "/tests/corpus/2651-top-level-await-pending-unhandled.ts" - ], - "diags": [] - }, - "/tests/corpus/2652-top-level-await-dynamic/main.ts": { - "order": [ - "/tests/corpus/2652-top-level-await-dynamic/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2653-top-level-await-rejection-stops-loop.ts": { - "order": [ - "/tests/corpus/2653-top-level-await-rejection-stops-loop.ts" - ], - "diags": [] - }, - "/tests/corpus/2654-top-level-await-unrelated-rejection.ts": { - "order": [ - "/tests/corpus/2654-top-level-await-unrelated-rejection.ts" - ], - "diags": [] - }, - "/tests/corpus/2655-top-level-await-cycle/main.ts": { - "order": [ - "/tests/corpus/2655-top-level-await-cycle/b.ts", - "/tests/corpus/2655-top-level-await-cycle/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2656-top-level-await-cycle-order/main.ts": { - "order": [ - "/tests/corpus/2656-top-level-await-cycle-order/a.ts", - "/tests/corpus/2656-top-level-await-cycle-order/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2657-top-level-await-cycle-dynamic/main.ts": { - "order": [ - "/tests/corpus/2657-top-level-await-cycle-dynamic/b.ts", - "/tests/corpus/2657-top-level-await-cycle-dynamic/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2658-top-level-await-sync-completion/main.ts": { - "order": [ - "/tests/corpus/2658-top-level-await-sync-completion/dep.ts", - "/tests/corpus/2658-top-level-await-sync-completion/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2659-top-level-await-dynamic-cycle/main.ts": { - "order": [ - "/tests/corpus/2659-top-level-await-dynamic-cycle/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2660-top-level-await-cycle-rejection/main.ts": { - "order": [ - "/tests/corpus/2660-top-level-await-cycle-rejection/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2661-top-level-await-dynamic-runtime-root/main.ts": { - "order": [ - "/tests/corpus/2661-top-level-await-dynamic-runtime-root/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2662-top-level-await-cycle-external-wait/main.ts": { - "order": [ - "/tests/corpus/2662-top-level-await-cycle-external-wait/b.ts", - "/tests/corpus/2662-top-level-await-cycle-external-wait/a.ts", - "/tests/corpus/2662-top-level-await-cycle-external-wait/waiter.ts", - "/tests/corpus/2662-top-level-await-cycle-external-wait/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2663-top-level-await-dependency-errors/main.ts": { - "order": [ - "/tests/corpus/2663-top-level-await-dependency-errors/listener.ts", - "/tests/corpus/2663-top-level-await-dependency-errors/async-bad.ts", - "/tests/corpus/2663-top-level-await-dependency-errors/sync-bad.ts", - "/tests/corpus/2663-top-level-await-dependency-errors/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2664-top-level-await-same-checkpoint-rejection.ts": { - "order": [ - "/tests/corpus/2664-top-level-await-same-checkpoint-rejection.ts" - ], - "diags": [] - }, - "/tests/corpus/2665-top-level-await-unhandled-listener-liveness.ts": { - "order": [ - "/tests/corpus/2665-top-level-await-unhandled-listener-liveness.ts" - ], - "diags": [] - }, - "/tests/corpus/2666-array-to-sorted.ts": { - "order": [ - "/tests/corpus/2666-array-to-sorted.ts" - ], - "diags": [] - }, - "/tests/corpus/2667-array-to-sorted-any.ts": { - "order": [ - "/tests/corpus/2667-array-to-sorted-any.ts" - ], - "diags": [] - }, - "/tests/corpus/2668-stored-number-array-iterator.ts": { - "order": [ - "/tests/corpus/2668-stored-number-array-iterator.ts" - ], - "diags": [] - }, - "/tests/corpus/2669-array-copying-methods.ts": { - "order": [ - "/tests/corpus/2669-array-copying-methods.ts" - ], - "diags": [] - }, - "/tests/corpus/2670-uint8array-copy-iterate.ts": { - "order": [ - "/tests/corpus/2670-uint8array-copy-iterate.ts" - ], - "diags": [] - }, - "/tests/corpus/2671-array-copying-js.cjs": { - "order": [ - "/tests/corpus/2671-array-copying-js.cjs" - ], - "diags": [] - }, - "/tests/corpus/2672-http-request-response-callback.ts": { - "order": [ - "/tests/corpus/2672-http-request-response-callback.ts" - ], - "diags": [] - }, - "/tests/corpus/2673-top-level-await-implicit-module.ts": { - "order": [ - "/tests/corpus/2673-top-level-await-implicit-module.ts" - ], - "diags": [] - }, - "/tests/corpus/2674-top-level-for-await-implicit-module.ts": { - "order": [ - "/tests/corpus/2674-top-level-for-await-implicit-module.ts" - ], - "diags": [] - }, - "/tests/corpus/2675-create-require-nested-esm.js": { - "order": [ - "/tests/corpus/2675-create-require-nested-esm.js" - ], - "diags": [] - }, - "/tests/corpus/2675-process-self-reexec.ts": { - "order": [ - "/tests/corpus/2675-process-self-reexec.ts" - ], - "diags": [] - }, - "/tests/corpus/2676-indexed-read-strict-equality.ts": { - "order": [ - "/tests/corpus/2676-indexed-read-strict-equality.ts" - ], - "diags": [] - }, - "/tests/corpus/2676-record-clone-overrides.ts": { - "order": [ - "/tests/corpus/2676-record-clone-overrides.ts" - ], - "diags": [] - }, - "/tests/corpus/2676-top-level-await-ambiguous/main.ts": { - "order": [ - "/tests/corpus/2676-top-level-await-ambiguous/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2677-runtime-optional-closure.ts": { - "order": [ - "/tests/corpus/2677-runtime-optional-closure.ts" - ], - "diags": [] - }, - "/tests/corpus/2677-top-level-await-module-scope/main.ts": { - "order": [ - "/tests/corpus/2677-top-level-await-module-scope/a.ts", - "/tests/corpus/2677-top-level-await-module-scope/b.ts", - "/tests/corpus/2677-top-level-await-module-scope/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2678-date-instances.ts": { - "order": [ - "/tests/corpus/2678-date-instances.ts" - ], - "diags": [] - }, - "/tests/corpus/2678-large-string-sparse-index.ts": { - "order": [ - "/tests/corpus/2678-large-string-sparse-index.ts" - ], - "diags": [] - }, - "/tests/corpus/2678-util-parseargs.ts": { - "order": [ - "/tests/corpus/2678-util-parseargs.ts" - ], - "diags": [] - }, - "/tests/corpus/2679-util-parseargs-cjs.cjs": { - "order": [ - "/tests/corpus/2679-util-parseargs-cjs.cjs" - ], - "diags": [] - }, - "/tests/corpus/2680-util-parseargs-default.ts": { - "order": [ - "/tests/corpus/2680-util-parseargs-default.ts" - ], - "diags": [] - }, - "/tests/corpus/2681-util-parseargs-dynamic.js": { - "order": [ - "/tests/corpus/2681-util-parseargs-dynamic.js" - ], - "diags": [] - }, - "/tests/corpus/2682-fs-rename.ts": { - "order": [ - "/tests/corpus/2682-fs-rename.ts" - ], - "diags": [] - }, - "/tests/corpus/2683-filter-truthy-predicate.ts": { - "order": [ - "/tests/corpus/2683-filter-truthy-predicate.ts" - ], - "diags": [] - }, - "/tests/corpus/2683-fs-rename-js.cjs": { - "order": [ - "/tests/corpus/2683-fs-rename-js.cjs" - ], - "diags": [] - }, - "/tests/corpus/2684-filter-no-predicate-dyn.cjs": { - "order": [ - "/tests/corpus/2684-filter-no-predicate-dyn.cjs" - ], - "diags": [] - }, - "/tests/corpus/2684-fs-rename-abort.ts": { - "order": [ - "/tests/corpus/2684-fs-rename-abort.ts" - ], - "diags": [] - }, - "/tests/corpus/2685-array-unshift-reverse.ts": { - "order": [ - "/tests/corpus/2685-array-unshift-reverse.ts" - ], - "diags": [] - }, - "/tests/corpus/2685-fs-write-sync.ts": { - "order": [ - "/tests/corpus/2685-fs-write-sync.ts" - ], - "diags": [] - }, - "/tests/corpus/2686-fs-file-handle.ts": { - "order": [ - "/tests/corpus/2686-fs-file-handle.ts" - ], - "diags": [] - }, - "/tests/corpus/2687-fsp-write-file-options.ts": { - "order": [ - "/tests/corpus/2687-fsp-write-file-options.ts" - ], - "diags": [] - }, - "/tests/corpus/2687-process-write-args.ts": { - "order": [ - "/tests/corpus/2687-process-write-args.ts" - ], - "diags": [] - }, - "/tests/corpus/2688-fs-stats-disk-fields.ts": { - "order": [ - "/tests/corpus/2688-fs-stats-disk-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/2689-http-server-timeout-properties.ts": { - "order": [ - "/tests/corpus/2689-http-server-timeout-properties.ts" - ], - "diags": [] - }, - "/tests/corpus/2690-https-server-timeout-option.ts": { - "order": [ - "/tests/corpus/2690-https-server-timeout-option.ts" - ], - "diags": [] - }, - "/tests/corpus/2691-retained-lowering-record-order.ts": { - "order": [ - "/tests/corpus/2691-retained-lowering-record-order.ts" - ], - "diags": [] - }, - "/tests/corpus/2692-inline-record-assert-index.ts": { - "order": [ - "/tests/corpus/2692-inline-record-assert-index.ts" - ], - "diags": [] - }, - "/tests/corpus/2692-string-accumulation.ts": { - "order": [ - "/tests/corpus/2692-string-accumulation.ts" - ], - "diags": [] - }, - "/tests/corpus/2693-math-constants.ts": { - "order": [ - "/tests/corpus/2693-math-constants.ts" - ], - "diags": [] - }, - "/tests/corpus/2700-array-sort-complexity.ts": { - "order": [ - "/tests/corpus/2700-array-sort-complexity.ts" - ], - "diags": [] - }, - "/tests/corpus/2700-http-static-trailers.ts": { - "order": [ - "/tests/corpus/2700-http-static-trailers.ts" - ], - "diags": [] - }, - "/tests/corpus/2700-wasi-core.ts": { - "order": [ - "/tests/corpus/2700-wasi-core.ts" - ], - "diags": [] - }, - "/tests/corpus/2701-array-sort-snapshot.ts": { - "order": [ - "/tests/corpus/2701-array-sort-snapshot.ts" - ], - "diags": [] - }, - "/tests/corpus/2701-http-static-trailer-wire.ts": { - "order": [ - "/tests/corpus/2701-http-static-trailer-wire.ts" - ], - "diags": [] - }, - "/tests/corpus/2701-import-meta/main.mjs": { - "order": [ - "/tests/corpus/2701-import-meta/module with space.mjs", - "/tests/corpus/2701-import-meta/main.mjs" - ], - "diags": [] - }, - "/tests/corpus/2702-http-static-trailer-end.ts": { - "order": [ - "/tests/corpus/2702-http-static-trailer-end.ts" - ], - "diags": [] - }, - "/tests/corpus/2702-type-import-link-static/main.ts": { - "order": [ - "/tests/corpus/2702-type-import-link-static/types.ts", - "/tests/corpus/2702-type-import-link-static/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2702-uint8array-to-sorted.ts": { - "order": [ - "/tests/corpus/2702-uint8array-to-sorted.ts" - ], - "diags": [] - }, - "/tests/corpus/2703-array-sparse-sort.ts": { - "order": [ - "/tests/corpus/2703-array-sparse-sort.ts" - ], - "diags": [] - }, - "/tests/corpus/2703-type-import-link-static-reexport/main.ts": { - "order": [ - "/tests/corpus/2703-type-import-link-static-reexport/types.ts", - "/tests/corpus/2703-type-import-link-static-reexport/middle.ts", - "/tests/corpus/2703-type-import-link-static-reexport/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2704-array-sparse-to-sorted.ts": { - "order": [ - "/tests/corpus/2704-array-sparse-to-sorted.ts" - ], - "diags": [] - }, - "/tests/corpus/2704-type-import-link-static-success/main.ts": { - "order": [ - "/tests/corpus/2704-type-import-link-static-success/types.ts", - "/tests/corpus/2704-type-import-link-static-success/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2705-array-sparse-sort-append.ts": { - "order": [ - "/tests/corpus/2705-array-sparse-sort-append.ts" - ], - "diags": [] - }, - "/tests/corpus/2705-type-import-link-dynamic/main.ts": { - "order": [ - "/tests/corpus/2705-type-import-link-dynamic/types.ts", - "/tests/corpus/2705-type-import-link-dynamic/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2706-array-search-missing-needle.ts": { - "order": [ - "/tests/corpus/2706-array-search-missing-needle.ts" - ], - "diags": [] - }, - "/tests/corpus/2706-type-import-link-dynamic-success/main.ts": { - "order": [ - "/tests/corpus/2706-type-import-link-dynamic-success/types.ts", - "/tests/corpus/2706-type-import-link-dynamic-success/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2707-array-search-huge-sparse.ts": { - "order": [ - "/tests/corpus/2707-array-search-huge-sparse.ts" - ], - "diags": [] - }, - "/tests/corpus/2707-type-import-link-static-default-reexport/main.ts": { - "order": [ - "/tests/corpus/2707-type-import-link-static-default-reexport/types.ts", - "/tests/corpus/2707-type-import-link-static-default-reexport/reexport.ts", - "/tests/corpus/2707-type-import-link-static-default-reexport/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2708-type-import-link-dynamic/main.ts": { - "order": [ - "/tests/corpus/2708-type-import-link-dynamic/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2720-array-read-parity.ts": { - "order": [ - "/tests/corpus/2720-array-read-parity.ts" - ], - "diags": [] - }, - "/tests/corpus/2721-array-nested-missing-receiver.ts": { - "order": [ - "/tests/corpus/2721-array-nested-missing-receiver.ts" - ], - "diags": [] - }, - "/tests/corpus/2750-array-sparse-foundation.ts": { - "order": [ - "/tests/corpus/2750-array-sparse-foundation.ts" - ], - "diags": [] - }, - "/tests/corpus/2751-buffer-concat-sparse-list.ts": { - "order": [ - "/tests/corpus/2751-buffer-concat-sparse-list.ts" - ], - "diags": [] - }, - "/tests/corpus/2752-array-optional-stores.ts": { - "order": [ - "/tests/corpus/2752-array-optional-stores.ts" - ], - "diags": [] - }, - "/tests/corpus/2753-array-optional-method-values.ts": { - "order": [ - "/tests/corpus/2753-array-optional-method-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2754-array-property-undefined.ts": { - "order": [ - "/tests/corpus/2754-array-property-undefined.ts" - ], - "diags": [] - }, - "/tests/corpus/2755-array-optional-literal-forwarding.ts": { - "order": [ - "/tests/corpus/2755-array-optional-literal-forwarding.ts" - ], - "diags": [] - }, - "/tests/corpus/2780-array-parity-composition.ts": { - "order": [ - "/tests/corpus/2780-array-parity-composition.ts" - ], - "diags": [] - }, - "/tests/corpus/2781-array-missing-value-escape.ts": { - "order": [ - "/tests/corpus/2781-array-missing-value-escape.ts" - ], - "diags": [] - }, - "/tests/corpus/2782-array-sparse-callbacks.ts": { - "order": [ - "/tests/corpus/2782-array-sparse-callbacks.ts" - ], - "diags": [] - }, - "/tests/corpus/2783-array-defaults-rest.ts": { - "order": [ - "/tests/corpus/2783-array-defaults-rest.ts" - ], - "diags": [] - }, - "/tests/corpus/2784-array-reduce-missing-result.ts": { - "order": [ - "/tests/corpus/2784-array-reduce-missing-result.ts" - ], - "diags": [] - }, - "/tests/corpus/2785-array-missing-destructuring.ts": { - "order": [ - "/tests/corpus/2785-array-missing-destructuring.ts" - ], - "diags": [] - }, - "/tests/corpus/2786-array-sparse-serialization.ts": { - "order": [ - "/tests/corpus/2786-array-sparse-serialization.ts" - ], - "diags": [] - }, - "/tests/corpus/2787-array-missing-string-arithmetic.ts": { - "order": [ - "/tests/corpus/2787-array-missing-string-arithmetic.ts" - ], - "diags": [] - }, - "/tests/corpus/2788-array-missing-builtin-conversions.ts": { - "order": [ - "/tests/corpus/2788-array-missing-builtin-conversions.ts" - ], - "diags": [] - }, - "/tests/corpus/2789-array-missing-optional-tostring.ts": { - "order": [ - "/tests/corpus/2789-array-missing-optional-tostring.ts" - ], - "diags": [] - }, - "/tests/corpus/2790-array-missing-tagged-substitutions.ts": { - "order": [ - "/tests/corpus/2790-array-missing-tagged-substitutions.ts" - ], - "diags": [] - }, - "/tests/corpus/2790-dynamic-import-self-name/main.ts": { - "order": [ - "/tests/corpus/2790-dynamic-import-self-name/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2791-record-optional-keys.ts": { - "order": [ - "/tests/corpus/2791-record-optional-keys.ts" - ], - "diags": [] - }, - "/tests/corpus/2792-record-optional-spread-entries.ts": { - "order": [ - "/tests/corpus/2792-record-optional-spread-entries.ts" - ], - "diags": [] - }, - "/tests/corpus/2793-union-conversion-identity-capture.ts": { - "order": [ - "/tests/corpus/2793-union-conversion-identity-capture.ts" - ], - "diags": [] - }, - "/tests/corpus/2794-array-generic-callback-values.ts": { - "order": [ - "/tests/corpus/2794-array-generic-callback-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2795-array-optional-typedarray-source.ts": { - "order": [ - "/tests/corpus/2795-array-optional-typedarray-source.ts" - ], - "diags": [] - }, - "/tests/corpus/2796-array-sparse-class-value-instanceof.ts": { - "order": [ - "/tests/corpus/2796-array-sparse-class-value-instanceof.ts" - ], - "diags": [] - }, - "/tests/corpus/2800-array-expression-consumers.ts": { - "order": [ - "/tests/corpus/2800-array-expression-consumers.ts" - ], - "diags": [] - }, - "/tests/corpus/2801-array-switch-consumers.ts": { - "order": [ - "/tests/corpus/2801-array-switch-consumers.ts" - ], - "diags": [] - }, - "/tests/corpus/2820-array-missing-method-receivers.ts": { - "order": [ - "/tests/corpus/2820-array-missing-method-receivers.ts" - ], - "diags": [] - }, - "/tests/corpus/2821-array-optional-numeric-comparisons.ts": { - "order": [ - "/tests/corpus/2821-array-optional-numeric-comparisons.ts" - ], - "diags": [] - }, - "/tests/corpus/2830-cjs-require-self-name/main.cjs": { - "order": [ - "/tests/corpus/2830-cjs-require-self-name/lib.cjs", - "/tests/corpus/2830-cjs-require-self-name/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/2840-finally-completions.ts": { - "order": [ - "/tests/corpus/2840-finally-completions.ts" - ], - "diags": [] - }, - "/tests/corpus/2841-using-sync.ts": { - "order": [ - "/tests/corpus/2841-using-sync.ts" - ], - "diags": [] - }, - "/tests/corpus/2842-await-using.ts": { - "order": [ - "/tests/corpus/2842-await-using.ts" - ], - "diags": [] - }, - "/tests/corpus/2843-using-suppressed-error.ts": { - "order": [ - "/tests/corpus/2843-using-suppressed-error.ts" - ], - "diags": [] - }, - "/tests/corpus/2844-node-disposable-resources.ts": { - "order": [ - "/tests/corpus/2844-node-disposable-resources.ts" - ], - "diags": [] - }, - "/tests/corpus/2845-for-using-of.ts": { - "order": [ - "/tests/corpus/2845-for-using-of.ts" - ], - "diags": [] - }, - "/tests/corpus/2846-generator-using.ts": { - "order": [ - "/tests/corpus/2846-generator-using.ts" - ], - "diags": [] - }, - "/tests/corpus/2850-async-generators-protocol.ts": { - "order": [ - "/tests/corpus/2850-async-generators-protocol.ts" - ], - "diags": [] - }, - "/tests/corpus/2851-async-generators-values.ts": { - "order": [ - "/tests/corpus/2851-async-generators-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2852-timers-promises-interval.ts": { - "order": [ - "/tests/corpus/2852-timers-promises-interval.ts" - ], - "diags": [] - }, - "/tests/corpus/2854-leading-bom-literals.ts": { - "order": [ - "/tests/corpus/2854-leading-bom-literals.ts" - ], - "diags": [] - }, - "/tests/corpus/2855-searchparams-sort-complexity.ts": { - "order": [ - "/tests/corpus/2855-searchparams-sort-complexity.ts" - ], - "diags": [] - }, - "/tests/corpus/2856-dynamic-any-local-operators.ts": { - "order": [ - "/tests/corpus/2856-dynamic-any-local-operators.ts" - ], - "diags": [] - }, - "/tests/corpus/2857-branded-primitives.ts": { - "order": [ - "/tests/corpus/2857-branded-primitives.ts" - ], - "diags": [] - }, - "/tests/corpus/2858-import-meta-resolve/main.mjs": { - "order": [ - "/tests/corpus/2858-import-meta-resolve/main.mjs" - ], - "diags": [] - }, - "/tests/corpus/2859-import-meta-resolve-dynamic/main.mjs": { - "order": [ - "/tests/corpus/2859-import-meta-resolve-dynamic/main.mjs" - ], - "diags": [] - }, - "/tests/corpus/2860-require-resolve/main.cjs": { - "order": [ - "/tests/corpus/2860-require-resolve/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/2861-readable-iterator-close.ts": { - "order": [ - "/tests/corpus/2861-readable-iterator-close.ts" - ], - "diags": [] - }, - "/tests/corpus/2862-web-readable-async-iteration.ts": { - "order": [ - "/tests/corpus/2862-web-readable-async-iteration.ts" - ], - "diags": [] - }, - "/tests/corpus/2863-class-async-iterator.ts": { - "order": [ - "/tests/corpus/2863-class-async-iterator.ts" - ], - "diags": [] - }, - "/tests/corpus/2864-array-class-method-receivers.ts": { - "order": [ - "/tests/corpus/2864-array-class-method-receivers.ts" - ], - "diags": [] - }, - "/tests/corpus/2865-cjs-process-alias.cjs": { - "order": [ - "/tests/corpus/2865-cjs-process-alias.cjs" - ], - "diags": [] - }, - "/tests/corpus/2866-dyn-switch.ts": { - "order": [ - "/tests/corpus/2866-dyn-switch.ts" - ], - "diags": [] - }, - "/tests/corpus/2867-array-shift-length.js": { - "order": [ - "/tests/corpus/2867-array-shift-length.js" - ], - "diags": [] - }, - "/tests/corpus/2868-empty-record-promise-presence.js": { - "order": [ - "/tests/corpus/2868-empty-record-promise-presence.js" - ], - "diags": [] - }, - "/tests/corpus/2869-nullish-mixed-lazy.ts": { - "order": [ - "/tests/corpus/2869-nullish-mixed-lazy.ts" - ], - "diags": [] - }, - "/tests/corpus/2870-and-dropped-truthy-arm.ts": { - "order": [ - "/tests/corpus/2870-and-dropped-truthy-arm.ts" - ], - "diags": [] - }, - "/tests/corpus/2871-optional-promise-to-unknown.ts": { - "order": [ - "/tests/corpus/2871-optional-promise-to-unknown.ts" - ], - "diags": [] - }, - "/tests/corpus/2872-unobserved-dynamic-event.ts": { - "order": [ - "/tests/corpus/2872-unobserved-dynamic-event.ts" - ], - "diags": [] - }, - "/tests/corpus/2873-optional-receiver-loop-lifetime.js": { - "order": [ - "/tests/corpus/2873-optional-receiver-loop-lifetime.js" - ], - "diags": [] - }, - "/tests/corpus/2874-nullable-callback-field-cycle.js": { - "order": [ - "/tests/corpus/2874-nullable-callback-field-cycle.js" - ], - "diags": [] - }, - "/tests/corpus/2875-evolving-let-read-before-write.js": { - "order": [ - "/tests/corpus/2875-evolving-let-read-before-write.js" - ], - "diags": [] - }, - "/tests/corpus/2876-class-unknown-roundtrip.ts": { - "order": [ - "/tests/corpus/2876-class-unknown-roundtrip.ts" - ], - "diags": [] - }, - "/tests/corpus/2877-child-unknown-roundtrip.ts": { - "order": [ - "/tests/corpus/2877-child-unknown-roundtrip.ts" - ], - "diags": [] - }, - "/tests/corpus/2878-class-private-unknown.cjs": { - "order": [ - "/tests/corpus/2878-class-private-unknown.cjs" - ], - "diags": [] - }, - "/tests/corpus/2880-cjs-module-graph/main.cjs": { - "order": [ - "/tests/corpus/2880-cjs-module-graph/leaf.cjs", - "/tests/corpus/2880-cjs-module-graph/child.cjs", - "/tests/corpus/2880-cjs-module-graph/failed.cjs", - "/tests/corpus/2880-cjs-module-graph/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/2890-crypto-static-utility.ts": { - "order": [ - "/tests/corpus/2890-crypto-static-utility.ts" - ], - "diags": [] - }, - "/tests/corpus/2891-json-record-key-escapes.ts": { - "order": [ - "/tests/corpus/2891-json-record-key-escapes.ts" - ], - "diags": [] - }, - "/tests/corpus/2892-windows-console-unicode.ts": { - "order": [ - "/tests/corpus/2892-windows-console-unicode.ts" - ], - "diags": [] - }, - "/tests/corpus/2893-child-stdin-duplex.ts": { - "order": [ - "/tests/corpus/2893-child-stdin-duplex.ts" - ], - "diags": [] - }, - "/tests/corpus/2894-child-stdin-backpressure.ts": { - "order": [ - "/tests/corpus/2894-child-stdin-backpressure.ts" - ], - "diags": [] - }, - "/tests/corpus/2895-child-stdin-write-after-end.ts": { - "order": [ - "/tests/corpus/2895-child-stdin-write-after-end.ts" - ], - "diags": [] - }, - "/tests/corpus/2896-child-stdin-write-after-finish.ts": { - "order": [ - "/tests/corpus/2896-child-stdin-write-after-finish.ts" - ], - "diags": [] - }, - "/tests/corpus/2897-child-stdin-destroy.ts": { - "order": [ - "/tests/corpus/2897-child-stdin-destroy.ts" - ], - "diags": [] - }, - "/tests/corpus/2898-child-stdin-spawn-failure.ts": { - "order": [ - "/tests/corpus/2898-child-stdin-spawn-failure.ts" - ], - "diags": [] - }, - "/tests/corpus/2899-nested-mutual-recursion.ts": { - "order": [ - "/tests/corpus/2899-nested-mutual-recursion.ts" - ], - "diags": [] - }, - "/tests/corpus/2900-float64array-static.ts": { - "order": [ - "/tests/corpus/2900-float64array-static.ts" - ], - "diags": [] - }, - "/tests/corpus/2900-void-conditional-arrow.ts": { - "order": [ - "/tests/corpus/2900-void-conditional-arrow.ts" - ], - "diags": [] - }, - "/tests/corpus/2901-bigint-core.ts": { - "order": [ - "/tests/corpus/2901-bigint-core.ts" - ], - "diags": [] - }, - "/tests/corpus/2902-bigint-bytes.ts": { - "order": [ - "/tests/corpus/2902-bigint-bytes.ts" - ], - "diags": [] - }, - "/tests/corpus/2903-bigint-storage.ts": { - "order": [ - "/tests/corpus/2903-bigint-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/2904-bigint-errors.ts": { - "order": [ - "/tests/corpus/2904-bigint-errors.ts" - ], - "diags": [] - }, - "/tests/corpus/2905-bigint-edges.ts": { - "order": [ - "/tests/corpus/2905-bigint-edges.ts" - ], - "diags": [] - }, - "/tests/corpus/2906-bigint-wasi-width.ts": { - "order": [ - "/tests/corpus/2906-bigint-wasi-width.ts" - ], - "diags": [] - }, - "/tests/corpus/2910-overloaded-callable-alias.ts": { - "order": [ - "/tests/corpus/2910-overloaded-callable-alias.ts" - ], - "diags": [] - }, - "/tests/corpus/2911-execfile-callback.ts": { - "order": [ - "/tests/corpus/2911-execfile-callback.ts" - ], - "diags": [] - }, - "/tests/corpus/2912-execfile-callback-options.ts": { - "order": [ - "/tests/corpus/2912-execfile-callback-options.ts" - ], - "diags": [] - }, - "/tests/corpus/2912-promisify-fs-readfile.ts": { - "order": [ - "/tests/corpus/2912-promisify-fs-readfile.ts" - ], - "diags": [] - }, - "/tests/corpus/2913-builtin-callable-alias.ts": { - "order": [ - "/tests/corpus/2913-builtin-callable-alias.ts" - ], - "diags": [] - }, - "/tests/corpus/2914-fixed-tuple-call-spread.ts": { - "order": [ - "/tests/corpus/2914-fixed-tuple-call-spread.ts" - ], - "diags": [] - }, - "/tests/corpus/2915-path-function-values.ts": { - "order": [ - "/tests/corpus/2915-path-function-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2916-path-function-values-cjs.ts": { - "order": [ - "/tests/corpus/2916-path-function-values-cjs.ts" - ], - "diags": [] - }, - "/tests/corpus/2917-builtin-callable-widths.ts": { - "order": [ - "/tests/corpus/2917-builtin-callable-widths.ts" - ], - "diags": [] - }, - "/tests/corpus/2918-builtin-callable-widths-cjs.ts": { - "order": [ - "/tests/corpus/2918-builtin-callable-widths-cjs.ts" - ], - "diags": [] - }, - "/tests/corpus/2919-fs-function-values.ts": { - "order": [ - "/tests/corpus/2919-fs-function-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2920-fs-promises-function-values.ts": { - "order": [ - "/tests/corpus/2920-fs-promises-function-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2921-zlib-callbacks.ts": { - "order": [ - "/tests/corpus/2921-zlib-callbacks.ts" - ], - "diags": [] - }, - "/tests/corpus/2922-dyn-bitwise-not.cjs": { - "order": [ - "/tests/corpus/2922-dyn-bitwise-not.cjs" - ], - "diags": [] - }, - "/tests/corpus/2923-cjs-factory-export/main.cjs": { - "order": [ - "/tests/corpus/2923-cjs-factory-export/factory.cjs", - "/tests/corpus/2923-cjs-factory-export/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/2930-union-receiver-calls.ts": { - "order": [ - "/tests/corpus/2930-union-receiver-calls.ts" - ], - "diags": [] - }, - "/tests/corpus/2931-union-dynamic-field-call.js": { - "order": [ - "/tests/corpus/2931-union-dynamic-field-call.js" - ], - "diags": [] - }, - "/tests/corpus/2932-create-require-program/main.ts": { - "order": [ - "/tests/corpus/2932-create-require-program/local.cjs", - "/tests/corpus/2932-create-require-program/factory.cjs", - "/tests/corpus/2932-create-require-program/side.cjs", - "/tests/corpus/2932-create-require-program/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2933-static-dynamic-import/main.ts": { - "order": [ - "/tests/corpus/2933-static-dynamic-import/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2934-static-import-stored.ts": { - "order": [ - "/tests/corpus/2934-static-import-stored.ts" - ], - "diags": [] - }, - "/tests/corpus/2935-module-namespace-values/main.ts": { - "order": [ - "/tests/corpus/2935-module-namespace-values/mod.ts", - "/tests/corpus/2935-module-namespace-values/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2936-static-loose-equality.ts": { - "order": [ - "/tests/corpus/2936-static-loose-equality.ts" - ], - "diags": [] - }, - "/tests/corpus/2937-bitwise-hot-loop.ts": { - "order": [ - "/tests/corpus/2937-bitwise-hot-loop.ts" - ], - "diags": [] - }, - "/tests/corpus/2938-fs-sync-overloads.cjs": { - "order": [ - "/tests/corpus/2938-fs-sync-overloads.cjs" - ], - "diags": [] - }, - "/tests/corpus/2939-child-shell-text.ts": { - "order": [ - "/tests/corpus/2939-child-shell-text.ts" - ], - "diags": [] - }, - "/tests/corpus/2940-date-parse.ts": { - "order": [ - "/tests/corpus/2940-date-parse.ts" - ], - "diags": [] - }, - "/tests/corpus/2940-fsp-realpath.ts": { - "order": [ - "/tests/corpus/2940-fsp-realpath.ts" - ], - "diags": [] - }, - "/tests/corpus/2941-fsp-lstat-identity.ts": { - "order": [ - "/tests/corpus/2941-fsp-lstat-identity.ts" - ], - "diags": [] - }, - "/tests/corpus/2941-process-exit-code.ts": { - "order": [ - "/tests/corpus/2941-process-exit-code.ts" - ], - "diags": [] - }, - "/tests/corpus/2942-fsp-readdir-dirent.ts": { - "order": [ - "/tests/corpus/2942-fsp-readdir-dirent.ts" - ], - "diags": [] - }, - "/tests/corpus/2942-process-exit-code-override.ts": { - "order": [ - "/tests/corpus/2942-process-exit-code-override.ts" - ], - "diags": [] - }, - "/tests/corpus/2943-process-exit-code-invalid.ts": { - "order": [ - "/tests/corpus/2943-process-exit-code-invalid.ts" - ], - "diags": [] - }, - "/tests/corpus/2944-process-exit-code-wrap.ts": { - "order": [ - "/tests/corpus/2944-process-exit-code-wrap.ts" - ], - "diags": [] - }, - "/tests/corpus/2945-url-origin-username.ts": { - "order": [ - "/tests/corpus/2945-url-origin-username.ts" - ], - "diags": [] - }, - "/tests/corpus/2946-child-fork-ipc/main.ts": { - "order": [ - "/tests/corpus/2946-child-fork-ipc/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2946-url-port-hash.ts": { - "order": [ - "/tests/corpus/2946-url-port-hash.ts" - ], - "diags": [] - }, - "/tests/corpus/2947-set-readonly-seeds.ts": { - "order": [ - "/tests/corpus/2947-set-readonly-seeds.ts" - ], - "diags": [] - }, - "/tests/corpus/2948-child-fork-eof-callback/main.ts": { - "order": [ - "/tests/corpus/2948-child-fork-eof-callback/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2948-stdio-callback-record.ts": { - "order": [ - "/tests/corpus/2948-stdio-callback-record.ts" - ], - "diags": [] - }, - "/tests/corpus/2949-child-fork-default/main.mjs": { - "order": [ - "/tests/corpus/2949-child-fork-default/main.mjs" - ], - "diags": [] - }, - "/tests/corpus/2949-url-password.ts": { - "order": [ - "/tests/corpus/2949-url-password.ts" - ], - "diags": [] - }, - "/tests/corpus/2950-fs-descriptor-publication.ts": { - "order": [ - "/tests/corpus/2950-fs-descriptor-publication.ts" - ], - "diags": [] - }, - "/tests/corpus/2951-math-static-analytic.ts": { - "order": [ - "/tests/corpus/2951-math-static-analytic.ts" - ], - "diags": [] - }, - "/tests/corpus/2952-math-static-remaining.ts": { - "order": [ - "/tests/corpus/2952-math-static-remaining.ts" - ], - "diags": [] - }, - "/tests/corpus/2953-http-header-validation.ts": { - "order": [ - "/tests/corpus/2953-http-header-validation.ts" - ], - "diags": [] - }, - "/tests/corpus/2954-http-outgoing-headers.ts": { - "order": [ - "/tests/corpus/2954-http-outgoing-headers.ts" - ], - "diags": [] - }, - "/tests/corpus/2955-http-static-state.ts": { - "order": [ - "/tests/corpus/2955-http-static-state.ts" - ], - "diags": [] - }, - "/tests/corpus/2956-http-static-informational.ts": { - "order": [ - "/tests/corpus/2956-http-static-informational.ts" - ], - "diags": [] - }, - "/tests/corpus/2957-http-static-response-controls.ts": { - "order": [ - "/tests/corpus/2957-http-static-response-controls.ts" - ], - "diags": [] - }, - "/tests/corpus/2961-emitter-computed-names.cjs": { - "order": [ - "/tests/corpus/2961-emitter-computed-names.cjs" - ], - "diags": [] - }, - "/tests/corpus/2962-emitter-computed-optional.ts": { - "order": [ - "/tests/corpus/2962-emitter-computed-optional.ts" - ], - "diags": [] - }, - "/tests/corpus/2963-child-fork-dispatch/main.ts": { - "order": [ - "/tests/corpus/2963-child-fork-dispatch/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2964-indexed-compound.ts": { - "order": [ - "/tests/corpus/2964-indexed-compound.ts" - ], - "diags": [] - }, - "/tests/corpus/2966-numeric-array-read-fusion.ts": { - "order": [ - "/tests/corpus/2966-numeric-array-read-fusion.ts" - ], - "diags": [] - }, - "/tests/corpus/2967-numeric-array-read-lifetime.ts": { - "order": [ - "/tests/corpus/2967-numeric-array-read-lifetime.ts" - ], - "diags": [] - }, - "/tests/corpus/2968-numeric-array-borrow.ts": { - "order": [ - "/tests/corpus/2968-numeric-array-borrow.ts" - ], - "diags": [] - }, - "/tests/corpus/2969-scalar-record-results.ts": { - "order": [ - "/tests/corpus/2969-scalar-record-results.ts" - ], - "diags": [] - }, - "/tests/corpus/2970-constant-numeric-tables.ts": { - "order": [ - "/tests/corpus/2970-constant-numeric-tables.ts" - ], - "diags": [] - }, - "/tests/corpus/2971-constant-table-modules/main.ts": { - "order": [ - "/tests/corpus/2971-constant-table-modules/tables.ts", - "/tests/corpus/2971-constant-table-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/2972-http-static-distinct-snapshots.ts": { - "order": [ - "/tests/corpus/2972-http-static-distinct-snapshots.ts" - ], - "diags": [] - }, - "/tests/corpus/2972-math-receiver-borrow.ts": { - "order": [ - "/tests/corpus/2972-math-receiver-borrow.ts" - ], - "diags": [] - }, - "/tests/corpus/2973-http-static-agent.ts": { - "order": [ - "/tests/corpus/2973-http-static-agent.ts" - ], - "diags": [] - }, - "/tests/corpus/2973-integer-bitwise-arithmetic.ts": { - "order": [ - "/tests/corpus/2973-integer-bitwise-arithmetic.ts" - ], - "diags": [] - }, - "/tests/corpus/2974-array-search-from-index.ts": { - "order": [ - "/tests/corpus/2974-array-search-from-index.ts" - ], - "diags": [] - }, - "/tests/corpus/2974-http-static-module-values.ts": { - "order": [ - "/tests/corpus/2974-http-static-module-values.ts" - ], - "diags": [] - }, - "/tests/corpus/2974-numeric-remainder.ts": { - "order": [ - "/tests/corpus/2974-numeric-remainder.ts" - ], - "diags": [] - }, - "/tests/corpus/2975-bigint-default-radix.ts": { - "order": [ - "/tests/corpus/2975-bigint-default-radix.ts" - ], - "diags": [] - }, - "/tests/corpus/2975-http-static-client-controls.ts": { - "order": [ - "/tests/corpus/2975-http-static-client-controls.ts" - ], - "diags": [] - }, - "/tests/corpus/2976-http-static-incoming-state.ts": { - "order": [ - "/tests/corpus/2976-http-static-incoming-state.ts" - ], - "diags": [] - }, - "/tests/corpus/2976-json-stringify-no-arguments.js": { - "order": [ - "/tests/corpus/2976-json-stringify-no-arguments.js" - ], - "diags": [] - }, - "/tests/corpus/2977-http-static-incoming-timeout.ts": { - "order": [ - "/tests/corpus/2977-http-static-incoming-timeout.ts" - ], - "diags": [] - }, - "/tests/corpus/2977-nested-array-binding-defaults.js": { - "order": [ - "/tests/corpus/2977-nested-array-binding-defaults.js" - ], - "diags": [] - }, - "/tests/corpus/2978-http-static-client-timeout.ts": { - "order": [ - "/tests/corpus/2978-http-static-client-timeout.ts" - ], - "diags": [] - }, - "/tests/corpus/2978-regexp-optional-subject.js": { - "order": [ - "/tests/corpus/2978-regexp-optional-subject.js" - ], - "diags": [] - }, - "/tests/corpus/2979-array-search-mixed-needles.js": { - "order": [ - "/tests/corpus/2979-array-search-mixed-needles.js" - ], - "diags": [] - }, - "/tests/corpus/2979-http-static-server-timeout.ts": { - "order": [ - "/tests/corpus/2979-http-static-server-timeout.ts" - ], - "diags": [] - }, - "/tests/corpus/2980-http-static-server-timeout-default.ts": { - "order": [ - "/tests/corpus/2980-http-static-server-timeout-default.ts" - ], - "diags": [] - }, - "/tests/corpus/2980-string-position-arguments.js": { - "order": [ - "/tests/corpus/2980-string-position-arguments.js" - ], - "diags": [] - }, - "/tests/corpus/2981-http-static-events.ts": { - "order": [ - "/tests/corpus/2981-http-static-events.ts" - ], - "diags": [] - }, - "/tests/corpus/2981-string-optional-positions.ts": { - "order": [ - "/tests/corpus/2981-string-optional-positions.ts" - ], - "diags": [] - }, - "/tests/corpus/2982-http-static-close-all.ts": { - "order": [ - "/tests/corpus/2982-http-static-close-all.ts" - ], - "diags": [] - }, - "/tests/corpus/2982-string-position-coercion-order.js": { - "order": [ - "/tests/corpus/2982-string-position-coercion-order.js" - ], - "diags": [] - }, - "/tests/corpus/2983-http-static-close-idle.ts": { - "order": [ - "/tests/corpus/2983-http-static-close-idle.ts" - ], - "diags": [] - }, - "/tests/corpus/2984-http-static-close-upgrade.ts": { - "order": [ - "/tests/corpus/2984-http-static-close-upgrade.ts" - ], - "diags": [] - }, - "/tests/corpus/2985-http-static-message-destroy.ts": { - "order": [ - "/tests/corpus/2985-http-static-message-destroy.ts" - ], - "diags": [] - }, - "/tests/corpus/2986-http-static-client-socket-finish.ts": { - "order": [ - "/tests/corpus/2986-http-static-client-socket-finish.ts" - ], - "diags": [] - }, - "/tests/corpus/2987-http-static-timeout-errors.ts": { - "order": [ - "/tests/corpus/2987-http-static-timeout-errors.ts" - ], - "diags": [] - }, - "/tests/corpus/2988-http-static-client-abort.ts": { - "order": [ - "/tests/corpus/2988-http-static-client-abort.ts" - ], - "diags": [] - }, - "/tests/corpus/2989-http-static-response-timeout-handled.ts": { - "order": [ - "/tests/corpus/2989-http-static-response-timeout-handled.ts" - ], - "diags": [] - }, - "/tests/corpus/2990-http-static-request-timeout-handled.ts": { - "order": [ - "/tests/corpus/2990-http-static-request-timeout-handled.ts" - ], - "diags": [] - }, - "/tests/corpus/2991-array-indexed-equality.ts": { - "order": [ - "/tests/corpus/2991-array-indexed-equality.ts" - ], - "diags": [] - }, - "/tests/corpus/2992-stream-rows.ts": { - "order": [ - "/tests/corpus/2992-stream-rows.ts" - ], - "diags": [] - }, - "/tests/corpus/2993-fiber-stack-lifetimes.ts": { - "order": [ - "/tests/corpus/2993-fiber-stack-lifetimes.ts" - ], - "diags": [] - }, - "/tests/corpus/2994-fromcharcode-scalar.ts": { - "order": [ - "/tests/corpus/2994-fromcharcode-scalar.ts" - ], - "diags": [] - }, - "/tests/corpus/2995-math-hyperbolic.ts": { - "order": [ - "/tests/corpus/2995-math-hyperbolic.ts" - ], - "diags": [] - }, - "/tests/corpus/2996-math-near-one.ts": { - "order": [ - "/tests/corpus/2996-math-near-one.ts" - ], - "diags": [] - }, - "/tests/corpus/2997-math-integer-float.ts": { - "order": [ - "/tests/corpus/2997-math-integer-float.ts" - ], - "diags": [] - }, - "/tests/corpus/300-if-else.ts": { - "order": [ - "/tests/corpus/300-if-else.ts" - ], - "diags": [] - }, - "/tests/corpus/3001-caught-typeof-object.js": { - "order": [ - "/tests/corpus/3001-caught-typeof-object.js" - ], - "diags": [] - }, - "/tests/corpus/3002-promise-then-two.ts": { - "order": [ - "/tests/corpus/3002-promise-then-two.ts" - ], - "diags": [] - }, - "/tests/corpus/301-while.ts": { - "order": [ - "/tests/corpus/301-while.ts" - ], - "diags": [] - }, - "/tests/corpus/302-for.ts": { - "order": [ - "/tests/corpus/302-for.ts" - ], - "diags": [] - }, - "/tests/corpus/3020-string-last-index-position.ts": { - "order": [ - "/tests/corpus/3020-string-last-index-position.ts" - ], - "diags": [] - }, - "/tests/corpus/3021-buffer-union-narrow-callback.ts": { - "order": [ - "/tests/corpus/3021-buffer-union-narrow-callback.ts" - ], - "diags": [] - }, - "/tests/corpus/3022-string-affix-positions.ts": { - "order": [ - "/tests/corpus/3022-string-affix-positions.ts" - ], - "diags": [] - }, - "/tests/corpus/3023-string-affix-position-coercion.js": { - "order": [ - "/tests/corpus/3023-string-affix-position-coercion.js" - ], - "diags": [] - }, - "/tests/corpus/3024-string-number-narrow-for-in.ts": { - "order": [ - "/tests/corpus/3024-string-number-narrow-for-in.ts" - ], - "diags": [] - }, - "/tests/corpus/3025-string-search-position-coercion.js": { - "order": [ - "/tests/corpus/3025-string-search-position-coercion.js" - ], - "diags": [] - }, - "/tests/corpus/3026-array-last-index-of.js": { - "order": [ - "/tests/corpus/3026-array-last-index-of.js" - ], - "diags": [] - }, - "/tests/corpus/3027-array-last-index-of-records.ts": { - "order": [ - "/tests/corpus/3027-array-last-index-of-records.ts" - ], - "diags": [] - }, - "/tests/corpus/3028-string-search-dynamic-needle.js": { - "order": [ - "/tests/corpus/3028-string-search-dynamic-needle.js" - ], - "diags": [] - }, - "/tests/corpus/3029-string-search-union-needle.js": { - "order": [ - "/tests/corpus/3029-string-search-union-needle.js" - ], - "diags": [] - }, - "/tests/corpus/303-break-continue.ts": { - "order": [ - "/tests/corpus/303-break-continue.ts" - ], - "diags": [] - }, - "/tests/corpus/3030-array-search-no-arg.js": { - "order": [ - "/tests/corpus/3030-array-search-no-arg.js" - ], - "diags": [] - }, - "/tests/corpus/3031-array-relative-index-coercion.js": { - "order": [ - "/tests/corpus/3031-array-relative-index-coercion.js" - ], - "diags": [] - }, - "/tests/corpus/3031-string-last-index-search-value.js": { - "order": [ - "/tests/corpus/3031-string-last-index-search-value.js" - ], - "diags": [] - }, - "/tests/corpus/3032-string-search-value.js": { - "order": [ - "/tests/corpus/3032-string-search-value.js" - ], - "diags": [] - }, - "/tests/corpus/3033-string-search-needle-coercion.js": { - "order": [ - "/tests/corpus/3033-string-search-needle-coercion.js" - ], - "diags": [] - }, - "/tests/corpus/3034-arguments-with-parameters.js": { - "order": [ - "/tests/corpus/3034-arguments-with-parameters.js" - ], - "diags": [] - }, - "/tests/corpus/3035-string-positioned-search-value.js": { - "order": [ - "/tests/corpus/3035-string-positioned-search-value.js" - ], - "diags": [] - }, - "/tests/corpus/3036-string-object-search-value.js": { - "order": [ - "/tests/corpus/3036-string-object-search-value.js" - ], - "diags": [] - }, - "/tests/corpus/3037-number-nullish-conversion.js": { - "order": [ - "/tests/corpus/3037-number-nullish-conversion.js" - ], - "diags": [] - }, - "/tests/corpus/3038-number-scalar-unions.ts": { - "order": [ - "/tests/corpus/3038-number-scalar-unions.ts" - ], - "diags": [] - }, - "/tests/corpus/3039-string-repeat-count.js": { - "order": [ - "/tests/corpus/3039-string-repeat-count.js" - ], - "diags": [] - }, - "/tests/corpus/304-compound-incdec.ts": { - "order": [ - "/tests/corpus/304-compound-incdec.ts" - ], - "diags": [] - }, - "/tests/corpus/3040-string-prototype-call.js": { - "order": [ - "/tests/corpus/3040-string-prototype-call.js" - ], - "diags": [] - }, - "/tests/corpus/3041-string-prototype-object-call.js": { - "order": [ - "/tests/corpus/3041-string-prototype-object-call.js" - ], - "diags": [] - }, - "/tests/corpus/3042-string-padding-coercion.js": { - "order": [ - "/tests/corpus/3042-string-padding-coercion.js" - ], - "diags": [] - }, - "/tests/corpus/3043-string-split-arguments.js": { - "order": [ - "/tests/corpus/3043-string-split-arguments.js" - ], - "diags": [] - }, - "/tests/corpus/3044-array-slice-splice-positions.js": { - "order": [ - "/tests/corpus/3044-array-slice-splice-positions.js" - ], - "diags": [] - }, - "/tests/corpus/3045-array-indexed-mutation.js": { - "order": [ - "/tests/corpus/3045-array-indexed-mutation.js" - ], - "diags": [] - }, - "/tests/corpus/3046-array-indexed-ref-identity.ts": { - "order": [ - "/tests/corpus/3046-array-indexed-ref-identity.ts" - ], - "diags": [] - }, - "/tests/corpus/3047-object-prototype-tag.js": { - "order": [ - "/tests/corpus/3047-object-prototype-tag.js" - ], - "diags": [] - }, - "/tests/corpus/3048-object-own-prototype.ts": { - "order": [ - "/tests/corpus/3048-object-own-prototype.ts" - ], - "diags": [] - }, - "/tests/corpus/3049-array-flat-depth.ts": { - "order": [ - "/tests/corpus/3049-array-flat-depth.ts" - ], - "diags": [] - }, - "/tests/corpus/305-truthiness.ts": { - "order": [ - "/tests/corpus/305-truthiness.ts" - ], - "diags": [] - }, - "/tests/corpus/3050-array-splice-insert.ts": { - "order": [ - "/tests/corpus/3050-array-splice-insert.ts" - ], - "diags": [] - }, - "/tests/corpus/3051-array-join-default.ts": { - "order": [ - "/tests/corpus/3051-array-join-default.ts" - ], - "diags": [] - }, - "/tests/corpus/3052-array-construction.ts": { - "order": [ - "/tests/corpus/3052-array-construction.ts" - ], - "diags": [] - }, - "/tests/corpus/3053-array-construction-js.js": { - "order": [ - "/tests/corpus/3053-array-construction-js.js" - ], - "diags": [] - }, - "/tests/corpus/3054-dynamic-abort-record.ts": { - "order": [ - "/tests/corpus/3054-dynamic-abort-record.ts" - ], - "diags": [] - }, - "/tests/corpus/3055-default-builtin-nodenext/main.ts": { - "order": [ - "/tests/corpus/3055-default-builtin-nodenext/main.ts" - ], - "diags": [] - }, - "/tests/corpus/3056-default-builtin-bundler/main.ts": { - "order": [ - "/tests/corpus/3056-default-builtin-bundler/main.ts" - ], - "diags": [] - }, - "/tests/corpus/3057-default-builtin-nodenext-dynamic/main.ts": { - "order": [ - "/tests/corpus/3057-default-builtin-nodenext-dynamic/main.ts" - ], - "diags": [] - }, - "/tests/corpus/3058-optional-array-chain-join.ts": { - "order": [ - "/tests/corpus/3058-optional-array-chain-join.ts" - ], - "diags": [] - }, - "/tests/corpus/3059-arguments-property-names.ts": { - "order": [ - "/tests/corpus/3059-arguments-property-names.ts" - ], - "diags": [] - }, - "/tests/corpus/3060-dynamic-host-global.ts": { - "order": [ - "/tests/corpus/3060-dynamic-host-global.ts" - ], - "diags": [] - }, - "/tests/corpus/3061-concurrent-fiber-stacks.ts": { - "order": [ - "/tests/corpus/3061-concurrent-fiber-stacks.ts" - ], - "diags": [] - }, - "/tests/corpus/3062-runtime-optional-record-guards.ts": { - "order": [ - "/tests/corpus/3062-runtime-optional-record-guards.ts" - ], - "diags": [] - }, - "/tests/corpus/3063-runtime-optional-class-guards.ts": { - "order": [ - "/tests/corpus/3063-runtime-optional-class-guards.ts" - ], - "diags": [] - }, - "/tests/corpus/3064-installed-entry-imports/main.ts": { - "order": [ - "/tests/corpus/3064-installed-entry-imports/state.ts", - "/tests/corpus/3064-installed-entry-imports/core/run.ts", - "/tests/corpus/3064-installed-entry-imports/core/index.ts", - "/tests/corpus/3064-installed-entry-imports/main.ts" - ], - "diags": [] - }, - "/tests/corpus/3065-installed-entry-js/main.js": { - "order": [ - "/tests/corpus/3065-installed-entry-js/value.js", - "/tests/corpus/3065-installed-entry-js/lib/index.js", - "/tests/corpus/3065-installed-entry-js/main.js" - ], - "diags": [] - }, - "/tests/corpus/3066-source-debugging/main.ts": { - "order": [ - "/tests/corpus/3066-source-debugging/helper.ts", - "/tests/corpus/3066-source-debugging/main.ts" - ], - "diags": [] - }, - "/tests/corpus/3067-cjs-function-export-require/main.cjs": { - "order": [ - "/tests/corpus/3067-cjs-function-export-require/dependency.cjs", - "/tests/corpus/3067-cjs-function-export-require/member.cjs", - "/tests/corpus/3067-cjs-function-export-require/single.cjs", - "/tests/corpus/3067-cjs-function-export-require/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/3068-debug-variables/main.ts": { - "order": [ - "/tests/corpus/3068-debug-variables/other.ts", - "/tests/corpus/3068-debug-variables/main.ts" - ], - "diags": [] - }, - "/tests/corpus/3068-url-checked-identity.ts": { - "order": [ - "/tests/corpus/3068-url-checked-identity.ts" - ], - "diags": [] - }, - "/tests/corpus/3069-set-checked-seed.js": { - "order": [ - "/tests/corpus/3069-set-checked-seed.js" - ], - "diags": [] - }, - "/tests/corpus/3069-tuple-spread.ts": { - "order": [ - "/tests/corpus/3069-tuple-spread.ts" - ], - "diags": [] - }, - "/tests/corpus/3070-checked-object-accessors.js": { - "order": [ - "/tests/corpus/3070-checked-object-accessors.js" - ], - "diags": [] - }, - "/tests/corpus/3070-collection-views.ts": { - "order": [ - "/tests/corpus/3070-collection-views.ts" - ], - "diags": [] - }, - "/tests/corpus/3071-checked-specialization-narrowing.js": { - "order": [ - "/tests/corpus/3071-checked-specialization-narrowing.js" - ], - "diags": [] - }, - "/tests/corpus/3071-map-contextual-record-seeds.ts": { - "order": [ - "/tests/corpus/3071-map-contextual-record-seeds.ts" - ], - "diags": [] - }, - "/tests/corpus/3072-optional-union-receivers.ts": { - "order": [ - "/tests/corpus/3072-optional-union-receivers.ts" - ], - "diags": [] - }, - "/tests/corpus/3072-weak-process-streams.js": { - "order": [ - "/tests/corpus/3072-weak-process-streams.js" - ], - "diags": [] - }, - "/tests/corpus/3073-optional-callable-module.js": { - "order": [ - "/tests/corpus/3073-optional-callable-module.js" - ], - "diags": [] - }, - "/tests/corpus/3073-union-keyed-reads.ts": { - "order": [ - "/tests/corpus/3073-union-keyed-reads.ts" - ], - "diags": [] - }, - "/tests/corpus/3074-discriminated-intersections.ts": { - "order": [ - "/tests/corpus/3074-discriminated-intersections.ts" - ], - "diags": [] - }, - "/tests/corpus/3075-recursive-contextual-literals.ts": { - "order": [ - "/tests/corpus/3075-recursive-contextual-literals.ts" - ], - "diags": [] - }, - "/tests/corpus/3076-nullish-record-defaults.ts": { - "order": [ - "/tests/corpus/3076-nullish-record-defaults.ts" - ], - "diags": [] - }, - "/tests/corpus/3077-optional-union-array-reads.ts": { - "order": [ - "/tests/corpus/3077-optional-union-array-reads.ts" - ], - "diags": [] - }, - "/tests/corpus/3078-forward-mutable-captures.ts": { - "order": [ - "/tests/corpus/3078-forward-mutable-captures.ts" - ], - "diags": [] - }, - "/tests/corpus/3079-forward-mutable-tdz.ts": { - "order": [ - "/tests/corpus/3079-forward-mutable-tdz.ts" - ], - "diags": [] - }, - "/tests/corpus/3080-exhaustive-never-bindings.ts": { - "order": [ - "/tests/corpus/3080-exhaustive-never-bindings.ts" - ], - "diags": [] - }, - "/tests/corpus/3081-recursive-array-destinations.ts": { - "order": [ - "/tests/corpus/3081-recursive-array-destinations.ts" - ], - "diags": [] - }, - "/tests/corpus/3082-forward-write-unwind.ts": { - "order": [ - "/tests/corpus/3082-forward-write-unwind.ts" - ], - "diags": [] - }, - "/tests/corpus/3083-set-string-seed.ts": { - "order": [ - "/tests/corpus/3083-set-string-seed.ts" - ], - "diags": [] - }, - "/tests/corpus/3084-record-own-membership.ts": { - "order": [ - "/tests/corpus/3084-record-own-membership.ts" - ], - "diags": [] - }, - "/tests/corpus/3085-conditional-record-construction.ts": { - "order": [ - "/tests/corpus/3085-conditional-record-construction.ts" - ], - "diags": [] - }, - "/tests/corpus/3086-error-constructor-options.ts": { - "order": [ - "/tests/corpus/3086-error-constructor-options.ts" - ], - "diags": [] - }, - "/tests/corpus/3087-error-options-lifetime.ts": { - "order": [ - "/tests/corpus/3087-error-options-lifetime.ts" - ], - "diags": [] - }, - "/tests/corpus/3088-array-wide-callbacks.ts": { - "order": [ - "/tests/corpus/3088-array-wide-callbacks.ts" - ], - "diags": [] - }, - "/tests/corpus/3089-array-find-narrowing.ts": { - "order": [ - "/tests/corpus/3089-array-find-narrowing.ts" - ], - "diags": [] - }, - "/tests/corpus/3090-json-discriminated-records.ts": { - "order": [ - "/tests/corpus/3090-json-discriminated-records.ts" - ], - "diags": [] - }, - "/tests/corpus/3091-json-recursive-discriminants.ts": { - "order": [ - "/tests/corpus/3091-json-recursive-discriminants.ts" - ], - "diags": [] - }, - "/tests/corpus/3092-number-union-predicates.ts": { - "order": [ - "/tests/corpus/3092-number-union-predicates.ts" - ], - "diags": [] - }, - "/tests/corpus/3093-error-option-data.ts": { - "order": [ - "/tests/corpus/3093-error-option-data.ts" - ], - "diags": [] - }, - "/tests/corpus/3094-json-replacer-traversal.ts": { - "order": [ - "/tests/corpus/3094-json-replacer-traversal.ts" - ], - "diags": [] - }, - "/tests/corpus/3095-json-reviver-traversal.ts": { - "order": [ - "/tests/corpus/3095-json-reviver-traversal.ts" - ], - "diags": [] - }, - "/tests/corpus/3096-json-callback-nonfinite.ts": { - "order": [ - "/tests/corpus/3096-json-callback-nonfinite.ts" - ], - "diags": [] - }, - "/tests/corpus/3097-json-callback-reentrancy.ts": { - "order": [ - "/tests/corpus/3097-json-callback-reentrancy.ts" - ], - "diags": [] - }, - "/tests/corpus/3098-json-callback-space.ts": { - "order": [ - "/tests/corpus/3098-json-callback-space.ts" - ], - "diags": [] - }, - "/tests/corpus/3099-json-callback-functions.ts": { - "order": [ - "/tests/corpus/3099-json-callback-functions.ts" - ], - "diags": [] - }, - "/tests/corpus/3100-json-callback-holder.js": { - "order": [ - "/tests/corpus/3100-json-callback-holder.js" - ], - "diags": [] - }, - "/tests/corpus/3101-json-callback-bytes.ts": { - "order": [ - "/tests/corpus/3101-json-callback-bytes.ts" - ], - "diags": [] - }, - "/tests/corpus/3102-json-unknown-fields.ts": { - "order": [ - "/tests/corpus/3102-json-unknown-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/3103-scalar-record-nested-control-flow.ts": { - "order": [ - "/tests/corpus/3103-scalar-record-nested-control-flow.ts" - ], - "diags": [] - }, - "/tests/corpus/3104-native-analysis-tables-loops.ts": { - "order": [ - "/tests/corpus/3104-native-analysis-tables-loops.ts" - ], - "diags": [] - }, - "/tests/corpus/3105-nullable-collections.ts": { - "order": [ - "/tests/corpus/3105-nullable-collections.ts" - ], - "diags": [] - }, - "/tests/corpus/3106-mixed-insertion-spreads.ts": { - "order": [ - "/tests/corpus/3106-mixed-insertion-spreads.ts" - ], - "diags": [] - }, - "/tests/corpus/3107-nullable-collection-lifetimes.ts": { - "order": [ - "/tests/corpus/3107-nullable-collection-lifetimes.ts" - ], - "diags": [] - }, - "/tests/corpus/3108-for-await-sync-arrays.js": { - "order": [ - "/tests/corpus/3108-for-await-sync-arrays.js" - ], - "diags": [] - }, - "/tests/corpus/3108-identity-map-keys.ts": { - "order": [ - "/tests/corpus/3108-identity-map-keys.ts" - ], - "diags": [] - }, - "/tests/corpus/3109-destructuring-unknown-defaults.js": { - "order": [ - "/tests/corpus/3109-destructuring-unknown-defaults.js" - ], - "diags": [] - }, - "/tests/corpus/3109-identity-union-collections.ts": { - "order": [ - "/tests/corpus/3109-identity-union-collections.ts" - ], - "diags": [] - }, - "/tests/corpus/3110-builtin-error-families.ts": { - "order": [ - "/tests/corpus/3110-builtin-error-families.ts" - ], - "diags": [] - }, - "/tests/corpus/3110-identity-collection-mutation.ts": { - "order": [ - "/tests/corpus/3110-identity-collection-mutation.ts" - ], - "diags": [] - }, - "/tests/corpus/3111-identity-collection-cycles.ts": { - "order": [ - "/tests/corpus/3111-identity-collection-cycles.ts" - ], - "diags": [] - }, - "/tests/corpus/3112-union-switch-control-flow.ts": { - "order": [ - "/tests/corpus/3112-union-switch-control-flow.ts" - ], - "diags": [] - }, - "/tests/corpus/3113-union-array-removal.ts": { - "order": [ - "/tests/corpus/3113-union-array-removal.ts" - ], - "diags": [] - }, - "/tests/corpus/3114-union-record-field-write.ts": { - "order": [ - "/tests/corpus/3114-union-record-field-write.ts" - ], - "diags": [] - }, - "/tests/corpus/3115-zlib-static-compression-levels.ts": { - "order": [ - "/tests/corpus/3115-zlib-static-compression-levels.ts" - ], - "diags": [] - }, - "/tests/corpus/3116-sequence-expression-lifetimes.ts": { - "order": [ - "/tests/corpus/3116-sequence-expression-lifetimes.ts" - ], - "diags": [] - }, - "/tests/corpus/3117-unknown-switch-control-flow.ts": { - "order": [ - "/tests/corpus/3117-unknown-switch-control-flow.ts" - ], - "diags": [] - }, - "/tests/corpus/3118-recursive-union-spread.ts": { - "order": [ - "/tests/corpus/3118-recursive-union-spread.ts" - ], - "diags": [] - }, - "/tests/corpus/3119-runtime-optional-spread.ts": { - "order": [ - "/tests/corpus/3119-runtime-optional-spread.ts" - ], - "diags": [] - }, - "/tests/corpus/3120-dynamic-property-descriptors.js": { - "order": [ - "/tests/corpus/3120-dynamic-property-descriptors.js" - ], - "diags": [] - }, - "/tests/corpus/3120-generator-method-loop-bindings.ts": { - "order": [ - "/tests/corpus/3120-generator-method-loop-bindings.ts" - ], - "diags": [] - }, - "/tests/corpus/3120-ir-nonfinite-numbers.ts": { - "order": [ - "/tests/corpus/3120-ir-nonfinite-numbers.ts" - ], - "diags": [] - }, - "/tests/corpus/3121-compound-assignment-values.js": { - "order": [ - "/tests/corpus/3121-compound-assignment-values.js" - ], - "diags": [] - }, - "/tests/corpus/3121-dynamic-accessor-descriptors.js": { - "order": [ - "/tests/corpus/3121-dynamic-accessor-descriptors.js" - ], - "diags": [] - }, - "/tests/corpus/3122-dynamic-delete-descriptors.cjs": { - "order": [ - "/tests/corpus/3122-dynamic-delete-descriptors.cjs" - ], - "diags": [] - }, - "/tests/corpus/3122-dynamic-delete-descriptors.js": { - "order": [ - "/tests/corpus/3122-dynamic-delete-descriptors.js" - ], - "diags": [] - }, - "/tests/corpus/3122-js-async-class-methods.js": { - "order": [ - "/tests/corpus/3122-js-async-class-methods.js" - ], - "diags": [] - }, - "/tests/corpus/3123-destructured-global-tdz.js": { - "order": [ - "/tests/corpus/3123-destructured-global-tdz.js" - ], - "diags": [] - }, - "/tests/corpus/3124-array-prototype-borrow.js": { - "order": [ - "/tests/corpus/3124-array-prototype-borrow.js" - ], - "diags": [] - }, - "/tests/corpus/3125-regex-global-match.ts": { - "order": [ - "/tests/corpus/3125-regex-global-match.ts" - ], - "diags": [] - }, - "/tests/corpus/3126-js-number-radix/main.ts": { - "order": [ - "/tests/corpus/3126-js-number-radix/format.js", - "/tests/corpus/3126-js-number-radix/main.ts" - ], - "diags": [] - }, - "/tests/corpus/3127-spawn-runtime-options.ts": { - "order": [ - "/tests/corpus/3127-spawn-runtime-options.ts" - ], - "diags": [] - }, - "/tests/corpus/3128-regex-last-index.ts": { - "order": [ - "/tests/corpus/3128-regex-last-index.ts" - ], - "diags": [] - }, - "/tests/corpus/3129-js-token-union/main.ts": { - "order": [ - "/tests/corpus/3129-js-token-union/lexer.js", - "/tests/corpus/3129-js-token-union/main.ts" - ], - "diags": [] - }, - "/tests/corpus/3130-child-generic-streams.ts": { - "order": [ - "/tests/corpus/3130-child-generic-streams.ts" - ], - "diags": [] - }, - "/tests/corpus/3131-child-rest-listeners.js": { - "order": [ - "/tests/corpus/3131-child-rest-listeners.js" - ], - "diags": [] - }, - "/tests/corpus/3132-child-generic-stream-completion.ts": { - "order": [ - "/tests/corpus/3132-child-generic-stream-completion.ts" - ], - "diags": [] - }, - "/tests/corpus/3133-text-decoder-streaming.ts": { - "order": [ - "/tests/corpus/3133-text-decoder-streaming.ts" - ], - "diags": [] - }, - "/tests/corpus/3134-fs-vectors.ts": { - "order": [ - "/tests/corpus/3134-fs-vectors.ts" - ], - "diags": [] - }, - "/tests/corpus/3135-fs-file-handle-controls.ts": { - "order": [ - "/tests/corpus/3135-fs-file-handle-controls.ts" - ], - "diags": [] - }, - "/tests/corpus/3136-fs-file-handle-options.ts": { - "order": [ - "/tests/corpus/3136-fs-file-handle-options.ts" - ], - "diags": [] - }, - "/tests/corpus/3137-fs-vector-callbacks.cjs": { - "order": [ - "/tests/corpus/3137-fs-vector-callbacks.cjs" - ], - "diags": [] - }, - "/tests/corpus/400-fib.ts": { - "order": [ - "/tests/corpus/400-fib.ts" - ], - "diags": [] - }, - "/tests/corpus/401-mutual-recursion.ts": { - "order": [ - "/tests/corpus/401-mutual-recursion.ts" - ], - "diags": [] - }, - "/tests/corpus/402-string-functions.ts": { - "order": [ - "/tests/corpus/402-string-functions.ts" - ], - "diags": [] - }, - "/tests/corpus/403-void-and-params.ts": { - "order": [ - "/tests/corpus/403-void-and-params.ts" - ], - "diags": [] - }, - "/tests/corpus/4030-runtime-object-truthiness.ts": { - "order": [ - "/tests/corpus/4030-runtime-object-truthiness.ts" - ], - "diags": [] - }, - "/tests/corpus/4031-event-emitter-long-tuples.ts": { - "order": [ - "/tests/corpus/4031-event-emitter-long-tuples.ts" - ], - "diags": [] - }, - "/tests/corpus/404-rc-stress.ts": { - "order": [ - "/tests/corpus/404-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/405-params-optional.ts": { - "order": [ - "/tests/corpus/405-params-optional.ts" - ], - "diags": [] - }, - "/tests/corpus/406-params-defaults.ts": { - "order": [ - "/tests/corpus/406-params-defaults.ts" - ], - "diags": [] - }, - "/tests/corpus/407-params-rest.ts": { - "order": [ - "/tests/corpus/407-params-rest.ts" - ], - "diags": [] - }, - "/tests/corpus/408-params-ctors-inheritance.ts": { - "order": [ - "/tests/corpus/408-params-ctors-inheritance.ts" - ], - "diags": [] - }, - "/tests/corpus/409-params-async-generics.ts": { - "order": [ - "/tests/corpus/409-params-async-generics.ts" - ], - "diags": [] - }, - "/tests/corpus/410-params-rc-stress.ts": { - "order": [ - "/tests/corpus/410-params-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/420-dead-strip-modules/main.ts": { - "order": [ - "/tests/corpus/420-dead-strip-modules/side.ts", - "/tests/corpus/420-dead-strip-modules/lib.ts", - "/tests/corpus/420-dead-strip-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/4413-cycle-old-late-death.ts": { - "order": [ - "/tests/corpus/4413-cycle-old-late-death.ts" - ], - "diags": [] - }, - "/tests/corpus/4414-cycle-old-weak-keys.ts": { - "order": [ - "/tests/corpus/4414-cycle-old-weak-keys.ts" - ], - "diags": [] - }, - "/tests/corpus/500-array-basics.ts": { - "order": [ - "/tests/corpus/500-array-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/501-array-push-pop.ts": { - "order": [ - "/tests/corpus/501-array-push-pop.ts" - ], - "diags": [] - }, - "/tests/corpus/502-array-for-of.ts": { - "order": [ - "/tests/corpus/502-array-for-of.ts" - ], - "diags": [] - }, - "/tests/corpus/503-array-functions.ts": { - "order": [ - "/tests/corpus/503-array-functions.ts" - ], - "diags": [] - }, - "/tests/corpus/504-array-rc-stress.ts": { - "order": [ - "/tests/corpus/504-array-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/510-array-map-filter-foreach.ts": { - "order": [ - "/tests/corpus/510-array-map-filter-foreach.ts" - ], - "diags": [] - }, - "/tests/corpus/511-array-indexof-includes.ts": { - "order": [ - "/tests/corpus/511-array-indexof-includes.ts" - ], - "diags": [] - }, - "/tests/corpus/512-array-join-chains.ts": { - "order": [ - "/tests/corpus/512-array-join-chains.ts" - ], - "diags": [] - }, - "/tests/corpus/513-array-methods-rc-stress.ts": { - "order": [ - "/tests/corpus/513-array-methods-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/514-array-find-some-every.ts": { - "order": [ - "/tests/corpus/514-array-find-some-every.ts" - ], - "diags": [] - }, - "/tests/corpus/515-array-flatmap.ts": { - "order": [ - "/tests/corpus/515-array-flatmap.ts" - ], - "diags": [] - }, - "/tests/corpus/516-array-reduce.ts": { - "order": [ - "/tests/corpus/516-array-reduce.ts" - ], - "diags": [] - }, - "/tests/corpus/517-array-hof-index-args.ts": { - "order": [ - "/tests/corpus/517-array-hof-index-args.ts" - ], - "diags": [] - }, - "/tests/corpus/518-array-sort.ts": { - "order": [ - "/tests/corpus/518-array-sort.ts" - ], - "diags": [] - }, - "/tests/corpus/518-promise-void-union-callbacks.ts": { - "order": [ - "/tests/corpus/518-promise-void-union-callbacks.ts" - ], - "diags": [] - }, - "/tests/corpus/519-array-from-length.ts": { - "order": [ - "/tests/corpus/519-array-from-length.ts" - ], - "diags": [] - }, - "/tests/corpus/519-promise-union-await-values.ts": { - "order": [ - "/tests/corpus/519-promise-union-await-values.ts" - ], - "diags": [] - }, - "/tests/corpus/520-map-basics.ts": { - "order": [ - "/tests/corpus/520-map-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/521-map-number-keys.ts": { - "order": [ - "/tests/corpus/521-map-number-keys.ts" - ], - "diags": [] - }, - "/tests/corpus/522-map-foreach.ts": { - "order": [ - "/tests/corpus/522-map-foreach.ts" - ], - "diags": [] - }, - "/tests/corpus/523-map-ref-values.ts": { - "order": [ - "/tests/corpus/523-map-ref-values.ts" - ], - "diags": [] - }, - "/tests/corpus/524-map-cycles.ts": { - "order": [ - "/tests/corpus/524-map-cycles.ts" - ], - "diags": [] - }, - "/tests/corpus/525-map-rc-stress.ts": { - "order": [ - "/tests/corpus/525-map-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/526-set-basics.ts": { - "order": [ - "/tests/corpus/526-set-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/527-set-foreach.ts": { - "order": [ - "/tests/corpus/527-set-foreach.ts" - ], - "diags": [] - }, - "/tests/corpus/528-set-seeded.ts": { - "order": [ - "/tests/corpus/528-set-seeded.ts" - ], - "diags": [] - }, - "/tests/corpus/529-map-seeded.ts": { - "order": [ - "/tests/corpus/529-map-seeded.ts" - ], - "diags": [] - }, - "/tests/corpus/530-record-arrays.ts": { - "order": [ - "/tests/corpus/530-record-arrays.ts" - ], - "diags": [] - }, - "/tests/corpus/531-record-array-hofs.ts": { - "order": [ - "/tests/corpus/531-record-array-hofs.ts" - ], - "diags": [] - }, - "/tests/corpus/532-record-arrays-rc-stress.ts": { - "order": [ - "/tests/corpus/532-record-arrays-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/533-array-element-cycles.ts": { - "order": [ - "/tests/corpus/533-array-element-cycles.ts" - ], - "diags": [] - }, - "/tests/corpus/534-record-width-subtyping.ts": { - "order": [ - "/tests/corpus/534-record-width-subtyping.ts" - ], - "diags": [] - }, - "/tests/corpus/535-object-statics.ts": { - "order": [ - "/tests/corpus/535-object-statics.ts" - ], - "diags": [] - }, - "/tests/corpus/536-map-seed-array.ts": { - "order": [ - "/tests/corpus/536-map-seed-array.ts" - ], - "diags": [] - }, - "/tests/corpus/537-map-iter-drains.ts": { - "order": [ - "/tests/corpus/537-map-iter-drains.ts" - ], - "diags": [] - }, - "/tests/corpus/538-map-set-for-of.ts": { - "order": [ - "/tests/corpus/538-map-set-for-of.ts" - ], - "diags": [] - }, - "/tests/corpus/540-tuples-basics.ts": { - "order": [ - "/tests/corpus/540-tuples-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/541-ref-array-json.ts": { - "order": [ - "/tests/corpus/541-ref-array-json.ts" - ], - "diags": [] - }, - "/tests/corpus/542-union-element-arrays.ts": { - "order": [ - "/tests/corpus/542-union-element-arrays.ts" - ], - "diags": [] - }, - "/tests/corpus/600-closures-basic.ts": { - "order": [ - "/tests/corpus/600-closures-basic.ts" - ], - "diags": [] - }, - "/tests/corpus/601-closures-loops.ts": { - "order": [ - "/tests/corpus/601-closures-loops.ts" - ], - "diags": [] - }, - "/tests/corpus/602-closures-identity-recursion.ts": { - "order": [ - "/tests/corpus/602-closures-identity-recursion.ts" - ], - "diags": [] - }, - "/tests/corpus/603-closures-rc-stress.ts": { - "order": [ - "/tests/corpus/603-closures-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/604-closures-for-of.ts": { - "order": [ - "/tests/corpus/604-closures-for-of.ts" - ], - "diags": [] - }, - "/tests/corpus/605-closures-forward-capture-tdz.ts": { - "order": [ - "/tests/corpus/605-closures-forward-capture-tdz.ts" - ], - "diags": [] - }, - "/tests/corpus/700-classes-basic.ts": { - "order": [ - "/tests/corpus/700-classes-basic.ts" - ], - "diags": [] - }, - "/tests/corpus/701-classes-composition.ts": { - "order": [ - "/tests/corpus/701-classes-composition.ts" - ], - "diags": [] - }, - "/tests/corpus/702-classes-this-capture.ts": { - "order": [ - "/tests/corpus/702-classes-this-capture.ts" - ], - "diags": [] - }, - "/tests/corpus/703-classes-rc-stress.ts": { - "order": [ - "/tests/corpus/703-classes-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/710-inheritance-basics.ts": { - "order": [ - "/tests/corpus/710-inheritance-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/711-inheritance-dispatch.ts": { - "order": [ - "/tests/corpus/711-inheritance-dispatch.ts" - ], - "diags": [] - }, - "/tests/corpus/712-inheritance-instanceof.ts": { - "order": [ - "/tests/corpus/712-inheritance-instanceof.ts" - ], - "diags": [] - }, - "/tests/corpus/713-inheritance-rc-stress.ts": { - "order": [ - "/tests/corpus/713-inheritance-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/720-accessors-basics.ts": { - "order": [ - "/tests/corpus/720-accessors-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/721-accessors-eval-order.ts": { - "order": [ - "/tests/corpus/721-accessors-eval-order.ts" - ], - "diags": [] - }, - "/tests/corpus/722-accessors-inheritance.ts": { - "order": [ - "/tests/corpus/722-accessors-inheritance.ts" - ], - "diags": [] - }, - "/tests/corpus/723-accessors-rc-stress.ts": { - "order": [ - "/tests/corpus/723-accessors-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/750-cycle-closure-box.ts": { - "order": [ - "/tests/corpus/750-cycle-closure-box.ts" - ], - "diags": [] - }, - "/tests/corpus/751-cycle-records-mutual.ts": { - "order": [ - "/tests/corpus/751-cycle-records-mutual.ts" - ], - "diags": [] - }, - "/tests/corpus/752-cycle-classes.ts": { - "order": [ - "/tests/corpus/752-cycle-classes.ts" - ], - "diags": [] - }, - "/tests/corpus/753-cycle-owned-arrays.ts": { - "order": [ - "/tests/corpus/753-cycle-owned-arrays.ts" - ], - "diags": [] - }, - "/tests/corpus/754-cycle-external-ref.ts": { - "order": [ - "/tests/corpus/754-cycle-external-ref.ts" - ], - "diags": [] - }, - "/tests/corpus/755-cycle-async-promise.ts": { - "order": [ - "/tests/corpus/755-cycle-async-promise.ts" - ], - "diags": [] - }, - "/tests/corpus/756-cycle-inheritance.ts": { - "order": [ - "/tests/corpus/756-cycle-inheritance.ts" - ], - "diags": [] - }, - "/tests/corpus/757-cycle-cross-generation.ts": { - "order": [ - "/tests/corpus/757-cycle-cross-generation.ts" - ], - "diags": [] - }, - "/tests/corpus/760-any-arithmetic.ts": { - "order": [ - "/tests/corpus/760-any-arithmetic.ts" - ], - "diags": [] - }, - "/tests/corpus/761-any-objects.ts": { - "order": [ - "/tests/corpus/761-any-objects.ts" - ], - "diags": [] - }, - "/tests/corpus/762-any-boundary.ts": { - "order": [ - "/tests/corpus/762-any-boundary.ts" - ], - "diags": [] - }, - "/tests/corpus/763-any-flow.ts": { - "order": [ - "/tests/corpus/763-any-flow.ts" - ], - "diags": [] - }, - "/tests/corpus/764-any-async.ts": { - "order": [ - "/tests/corpus/764-any-async.ts" - ], - "diags": [] - }, - "/tests/corpus/765-any-optional-chain.ts": { - "order": [ - "/tests/corpus/765-any-optional-chain.ts" - ], - "diags": [] - }, - "/tests/corpus/766-any-union-boundary.ts": { - "order": [ - "/tests/corpus/766-any-union-boundary.ts" - ], - "diags": [] - }, - "/tests/corpus/767-string-literal-keys.ts": { - "order": [ - "/tests/corpus/767-string-literal-keys.ts" - ], - "diags": [] - }, - "/tests/corpus/768-any-uninitialized.ts": { - "order": [ - "/tests/corpus/768-any-uninitialized.ts" - ], - "diags": [] - }, - "/tests/corpus/800-switch-basics.ts": { - "order": [ - "/tests/corpus/800-switch-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/801-switch-lazy-tests.ts": { - "order": [ - "/tests/corpus/801-switch-lazy-tests.ts" - ], - "diags": [] - }, - "/tests/corpus/802-switch-loops.ts": { - "order": [ - "/tests/corpus/802-switch-loops.ts" - ], - "diags": [] - }, - "/tests/corpus/803-switch-rc-stress.ts": { - "order": [ - "/tests/corpus/803-switch-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/804-switch-braced-blocks.ts": { - "order": [ - "/tests/corpus/804-switch-braced-blocks.ts" - ], - "diags": [] - }, - "/tests/corpus/810-do-while.ts": { - "order": [ - "/tests/corpus/810-do-while.ts" - ], - "diags": [] - }, - "/tests/corpus/820-multi-decl.ts": { - "order": [ - "/tests/corpus/820-multi-decl.ts" - ], - "diags": [] - }, - "/tests/corpus/830-let-uninitialized.ts": { - "order": [ - "/tests/corpus/830-let-uninitialized.ts" - ], - "diags": [] - }, - "/tests/corpus/900-records-basics.ts": { - "order": [ - "/tests/corpus/900-records-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/901-records-eval-order.ts": { - "order": [ - "/tests/corpus/901-records-eval-order.ts" - ], - "diags": [] - }, - "/tests/corpus/902-records-functions-closures.ts": { - "order": [ - "/tests/corpus/902-records-functions-closures.ts" - ], - "diags": [] - }, - "/tests/corpus/903-records-rc-stress.ts": { - "order": [ - "/tests/corpus/903-records-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/904-records-optional-fields.ts": { - "order": [ - "/tests/corpus/904-records-optional-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/905-records-optional-rc-stress.ts": { - "order": [ - "/tests/corpus/905-records-optional-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/906-records-utility-types.ts": { - "order": [ - "/tests/corpus/906-records-utility-types.ts" - ], - "diags": [] - }, - "/tests/corpus/907-records-utility-generics.ts": { - "order": [ - "/tests/corpus/907-records-utility-generics.ts" - ], - "diags": [] - }, - "/tests/corpus/908-records-index-signatures.ts": { - "order": [ - "/tests/corpus/908-records-index-signatures.ts" - ], - "diags": [] - }, - "/tests/corpus/909-records-index-json.ts": { - "order": [ - "/tests/corpus/909-records-index-json.ts" - ], - "diags": [] - }, - "/tests/corpus/910-records-index-rc-stress.ts": { - "order": [ - "/tests/corpus/910-records-index-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/911-records-index-dot-access.ts": { - "order": [ - "/tests/corpus/911-records-index-dot-access.ts" - ], - "diags": [] - }, - "/tests/corpus/912-unknown-slots.ts": { - "order": [ - "/tests/corpus/912-unknown-slots.ts" - ], - "diags": [] - }, - "/tests/corpus/913-records-index-iteration.ts": { - "order": [ - "/tests/corpus/913-records-index-iteration.ts" - ], - "diags": [] - }, - "/tests/corpus/914-records-from-entries.ts": { - "order": [ - "/tests/corpus/914-records-from-entries.ts" - ], - "diags": [] - }, - "/tests/corpus/915-unknown-tostring-eq.ts": { - "order": [ - "/tests/corpus/915-unknown-tostring-eq.ts" - ], - "diags": [] - }, - "/tests/corpus/916-unknown-bytes.ts": { - "order": [ - "/tests/corpus/916-unknown-bytes.ts" - ], - "diags": [] - }, - "/tests/corpus/917-record-array-index-dot.ts": { - "order": [ - "/tests/corpus/917-record-array-index-dot.ts" - ], - "diags": [] - }, - "/tests/corpus/950-modules-basic/main.ts": { - "order": [ - "/tests/corpus/950-modules-basic/util.ts", - "/tests/corpus/950-modules-basic/main.ts" - ], - "diags": [] - }, - "/tests/corpus/951-modules-diamond/main.ts": { - "order": [ - "/tests/corpus/951-modules-diamond/shared.ts", - "/tests/corpus/951-modules-diamond/a.ts", - "/tests/corpus/951-modules-diamond/b.ts", - "/tests/corpus/951-modules-diamond/main.ts" - ], - "diags": [] - }, - "/tests/corpus/952-modules-cross/main.ts": { - "order": [ - "/tests/corpus/952-modules-cross/shapes.ts", - "/tests/corpus/952-modules-cross/ops.ts", - "/tests/corpus/952-modules-cross/main.ts" - ], - "diags": [] - }, - "/tests/corpus/953-modules-default/main.ts": { - "order": [ - "/tests/corpus/953-modules-default/colors.ts", - "/tests/corpus/953-modules-default/side.ts", - "/tests/corpus/953-modules-default/answer.ts", - "/tests/corpus/953-modules-default/main.ts" - ], - "diags": [] - }, - "/tests/corpus/954-modules-reexport/main.ts": { - "order": [ - "/tests/corpus/954-modules-reexport/base.ts", - "/tests/corpus/954-modules-reexport/hub.ts", - "/tests/corpus/954-modules-reexport/star.ts", - "/tests/corpus/954-modules-reexport/main.ts" - ], - "diags": [] - }, - "/tests/corpus/957-builtins-namespace.ts": { - "order": [ - "/tests/corpus/957-builtins-namespace.ts" - ], - "diags": [] - }, - "/tests/corpus/960-generics-basics.ts": { - "order": [ - "/tests/corpus/960-generics-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/961-generics-recursion.ts": { - "order": [ - "/tests/corpus/961-generics-recursion.ts" - ], - "diags": [] - }, - "/tests/corpus/962-generics-closures.ts": { - "order": [ - "/tests/corpus/962-generics-closures.ts" - ], - "diags": [] - }, - "/tests/corpus/963-generics-modules/main.ts": { - "order": [ - "/tests/corpus/963-generics-modules/util.ts", - "/tests/corpus/963-generics-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/964-generics-rc-stress.ts": { - "order": [ - "/tests/corpus/964-generics-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/965-generics-async.ts": { - "order": [ - "/tests/corpus/965-generics-async.ts" - ], - "diags": [] - }, - "/tests/corpus/965-unions-retag.ts": { - "order": [ - "/tests/corpus/965-unions-retag.ts" - ], - "diags": [] - }, - "/tests/corpus/966-unions-retag-rc-stress.ts": { - "order": [ - "/tests/corpus/966-unions-retag-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/967-record-field-widening.ts": { - "order": [ - "/tests/corpus/967-record-field-widening.ts" - ], - "diags": [] - }, - "/tests/corpus/968-jsval-lift.ts": { - "order": [ - "/tests/corpus/968-jsval-lift.ts" - ], - "diags": [] - }, - "/tests/corpus/969-unions-arm-matrix.ts": { - "order": [ - "/tests/corpus/969-unions-arm-matrix.ts" - ], - "diags": [] - }, - "/tests/corpus/970-unions-basics.ts": { - "order": [ - "/tests/corpus/970-unions-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/971-unions-switch.ts": { - "order": [ - "/tests/corpus/971-unions-switch.ts" - ], - "diags": [] - }, - "/tests/corpus/972-unions-nested.ts": { - "order": [ - "/tests/corpus/972-unions-nested.ts" - ], - "diags": [] - }, - "/tests/corpus/973-unions-rc-stress.ts": { - "order": [ - "/tests/corpus/973-unions-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/974-unions-modules/main.ts": { - "order": [ - "/tests/corpus/974-unions-modules/result.ts", - "/tests/corpus/974-unions-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/975-unions-undefined.ts": { - "order": [ - "/tests/corpus/975-unions-undefined.ts" - ], - "diags": [] - }, - "/tests/corpus/976-unions-null.ts": { - "order": [ - "/tests/corpus/976-unions-null.ts" - ], - "diags": [] - }, - "/tests/corpus/977-unions-unit-rc-stress.ts": { - "order": [ - "/tests/corpus/977-unions-unit-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/978-unions-nullish.ts": { - "order": [ - "/tests/corpus/978-unions-nullish.ts" - ], - "diags": [] - }, - "/tests/corpus/979-unions-optional-chaining.ts": { - "order": [ - "/tests/corpus/979-unions-optional-chaining.ts" - ], - "diags": [] - }, - "/tests/corpus/980-exceptions-basics.ts": { - "order": [ - "/tests/corpus/980-exceptions-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/981-exceptions-values.ts": { - "order": [ - "/tests/corpus/981-exceptions-values.ts" - ], - "diags": [] - }, - "/tests/corpus/982-exceptions-rc-stress.ts": { - "order": [ - "/tests/corpus/982-exceptions-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/983-exceptions-control-flow.ts": { - "order": [ - "/tests/corpus/983-exceptions-control-flow.ts" - ], - "diags": [] - }, - "/tests/corpus/984-exceptions-finally.ts": { - "order": [ - "/tests/corpus/984-exceptions-finally.ts" - ], - "diags": [] - }, - "/tests/corpus/985-exceptions-call-chains.ts": { - "order": [ - "/tests/corpus/985-exceptions-call-chains.ts" - ], - "diags": [] - }, - "/tests/corpus/986-exceptions-uncaught.ts": { - "order": [ - "/tests/corpus/986-exceptions-uncaught.ts" - ], - "diags": [] - }, - "/tests/corpus/987-exceptions-result-unions.ts": { - "order": [ - "/tests/corpus/987-exceptions-result-unions.ts" - ], - "diags": [] - }, - "/tests/corpus/990-process-basics.ts": { - "order": [ - "/tests/corpus/990-process-basics.ts" - ], - "diags": [] - }, - "/tests/corpus/991-process-exit.ts": { - "order": [ - "/tests/corpus/991-process-exit.ts" - ], - "diags": [] - }, - "/tests/corpus/992-fs-roundtrip.ts": { - "order": [ - "/tests/corpus/992-fs-roundtrip.ts" - ], - "diags": [] - }, - "/tests/corpus/993-fs-readdir.ts": { - "order": [ - "/tests/corpus/993-fs-readdir.ts" - ], - "diags": [] - }, - "/tests/corpus/994-fs-errors.ts": { - "order": [ - "/tests/corpus/994-fs-errors.ts" - ], - "diags": [] - }, - "/tests/corpus/995-fs-uncaught.ts": { - "order": [ - "/tests/corpus/995-fs-uncaught.ts" - ], - "diags": [] - }, - "/tests/corpus/996-fs-rc-stress.ts": { - "order": [ - "/tests/corpus/996-fs-rc-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/997-fs-modules/main.ts": { - "order": [ - "/tests/corpus/997-fs-modules/store.ts", - "/tests/corpus/997-fs-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/998-process-env.ts": { - "order": [ - "/tests/corpus/998-process-env.ts" - ], - "diags": [] - }, - "/tests/corpus/abstract-property-dispatch.ts": { - "order": [ - "/tests/corpus/abstract-property-dispatch.ts" - ], - "diags": [] - }, - "/tests/corpus/arguments-arrow-capture.mjs": { - "order": [ - "/tests/corpus/arguments-arrow-capture.mjs" - ], - "diags": [] - }, - "/tests/corpus/arguments-reexport/main.ts": { - "order": [ - "/tests/corpus/arguments-reexport/core.js", - "/tests/corpus/arguments-reexport/barrel.js", - "/tests/corpus/arguments-reexport/main.ts" - ], - "diags": [] - }, - "/tests/corpus/array-buffer-conversions.js": { - "order": [ - "/tests/corpus/array-buffer-conversions.js" - ], - "diags": [] - }, - "/tests/corpus/array-buffer-storage.ts": { - "order": [ - "/tests/corpus/array-buffer-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/array-checked-callback-results.mjs": { - "order": [ - "/tests/corpus/array-checked-callback-results.mjs" - ], - "diags": [] - }, - "/tests/corpus/array-checked-constructor.js": { - "order": [ - "/tests/corpus/array-checked-constructor.js" - ], - "diags": [] - }, - "/tests/corpus/array-concat-widening.ts": { - "order": [ - "/tests/corpus/array-concat-widening.ts" - ], - "diags": [] - }, - "/tests/corpus/array-fill-unit-values.ts": { - "order": [ - "/tests/corpus/array-fill-unit-values.ts" - ], - "diags": [] - }, - "/tests/corpus/array-from-checked.js": { - "order": [ - "/tests/corpus/array-from-checked.js" - ], - "diags": [] - }, - "/tests/corpus/array-from-value.mjs": { - "order": [ - "/tests/corpus/array-from-value.mjs" - ], - "diags": [] - }, - "/tests/corpus/array-isarray-value/main.js": { - "order": [ - "/tests/corpus/array-isarray-value/main.js" - ], - "diags": [] - }, - "/tests/corpus/array-optional-number-write-index.ts": { - "order": [ - "/tests/corpus/array-optional-number-write-index.ts" - ], - "diags": [] - }, - "/tests/corpus/array-refined-storage.ts": { - "order": [ - "/tests/corpus/array-refined-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/array-sort-unknown-comparator.ts": { - "order": [ - "/tests/corpus/array-sort-unknown-comparator.ts" - ], - "diags": [] - }, - "/tests/corpus/array-truncate-reuse.ts": { - "order": [ - "/tests/corpus/array-truncate-reuse.ts" - ], - "diags": [] - }, - "/tests/corpus/async-backend-factory.mjs": { - "order": [ - "/tests/corpus/async-backend-factory.mjs" - ], - "diags": [] - }, - "/tests/corpus/async-local-typed-results.ts": { - "order": [ - "/tests/corpus/async-local-typed-results.ts" - ], - "diags": [] - }, - "/tests/corpus/bigint-checked-casts.ts": { - "order": [ - "/tests/corpus/bigint-checked-casts.ts" - ], - "diags": [] - }, - "/tests/corpus/bigint-checked-storage.js": { - "order": [ - "/tests/corpus/bigint-checked-storage.js" - ], - "diags": [] - }, - "/tests/corpus/bigint-union-conversion.ts": { - "order": [ - "/tests/corpus/bigint-union-conversion.ts" - ], - "diags": [] - }, - "/tests/corpus/boxed-error-rethrows.mjs": { - "order": [ - "/tests/corpus/boxed-error-rethrows.mjs" - ], - "diags": [] - }, - "/tests/corpus/buffer-primitive-predicate.ts": { - "order": [ - "/tests/corpus/buffer-primitive-predicate.ts" - ], - "diags": [] - }, - "/tests/corpus/builtin-prototype-method-values.mjs": { - "order": [ - "/tests/corpus/builtin-prototype-method-values.mjs" - ], - "diags": [] - }, - "/tests/corpus/callable-module-members.mjs": { - "order": [ - "/tests/corpus/callable-module-members.mjs" - ], - "diags": [] - }, - "/tests/corpus/callable-properties.mjs": { - "order": [ - "/tests/corpus/callable-properties.mjs" - ], - "diags": [] - }, - "/tests/corpus/callable-property-cycles.js": { - "order": [ - "/tests/corpus/callable-property-cycles.js" - ], - "diags": [] - }, - "/tests/corpus/callable-reexport/main.ts": { - "order": [ - "/tests/corpus/callable-reexport/core.js", - "/tests/corpus/callable-reexport/barrel.js", - "/tests/corpus/callable-reexport/main.ts" - ], - "diags": [] - }, - "/tests/corpus/catch-capture.ts": { - "order": [ - "/tests/corpus/catch-capture.ts" - ], - "diags": [] - }, - "/tests/corpus/caught-standalone-class.ts": { - "order": [ - "/tests/corpus/caught-standalone-class.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-addition.js": { - "order": [ - "/tests/corpus/checked-addition.js" - ], - "diags": [] - }, - "/tests/corpus/checked-any-addition.ts": { - "order": [ - "/tests/corpus/checked-any-addition.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-array-assignment.ts": { - "order": [ - "/tests/corpus/checked-array-assignment.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-array-flat/main.ts": { - "order": [ - "/tests/corpus/checked-array-flat/operations.mjs", - "/tests/corpus/checked-array-flat/main.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-bitwise/main.js": { - "order": [ - "/tests/corpus/checked-bitwise/main.js" - ], - "diags": [] - }, - "/tests/corpus/checked-builder-cycles.js": { - "order": [ - "/tests/corpus/checked-builder-cycles.js" - ], - "diags": [] - }, - "/tests/corpus/checked-byte-storage/main.ts": { - "order": [ - "/tests/corpus/checked-byte-storage/values.js", - "/tests/corpus/checked-byte-storage/main.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-callback-options.ts": { - "order": [ - "/tests/corpus/checked-callback-options.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-class-descriptors.mjs": { - "order": [ - "/tests/corpus/checked-class-descriptors.mjs" - ], - "diags": [] - }, - "/tests/corpus/checked-class-factory.mjs": { - "order": [ - "/tests/corpus/checked-class-factory.mjs" - ], - "diags": [] - }, - "/tests/corpus/checked-collection-iterators.ts": { - "order": [ - "/tests/corpus/checked-collection-iterators.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-collection-symbol-methods.ts": { - "order": [ - "/tests/corpus/checked-collection-symbol-methods.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-increment/main.js": { - "order": [ - "/tests/corpus/checked-increment/main.js" - ], - "diags": [] - }, - "/tests/corpus/checked-inherited-fields.ts": { - "order": [ - "/tests/corpus/checked-inherited-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-numeric-arithmetic.js": { - "order": [ - "/tests/corpus/checked-numeric-arithmetic.js" - ], - "diags": [] - }, - "/tests/corpus/checked-object-module-alias.js": { - "order": [ - "/tests/corpus/checked-object-module-alias.js" - ], - "diags": [] - }, - "/tests/corpus/checked-optional-calls.mjs": { - "order": [ - "/tests/corpus/checked-optional-calls.mjs" - ], - "diags": [] - }, - "/tests/corpus/checked-promise-recovery.ts": { - "order": [ - "/tests/corpus/checked-promise-recovery.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-proxy-callback/main.ts": { - "order": [ - "/tests/corpus/checked-proxy-callback/operations.mjs", - "/tests/corpus/checked-proxy-callback/main.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-record-constructor.ts": { - "order": [ - "/tests/corpus/checked-record-constructor.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-renderer-defaults.js": { - "order": [ - "/tests/corpus/checked-renderer-defaults.js" - ], - "diags": [] - }, - "/tests/corpus/checked-rest-function-adapters.js": { - "order": [ - "/tests/corpus/checked-rest-function-adapters.js" - ], - "diags": [] - }, - "/tests/corpus/checked-symbol-array.ts": { - "order": [ - "/tests/corpus/checked-symbol-array.ts" - ], - "diags": [] - }, - "/tests/corpus/class-accessor-returned-function.js": { - "order": [ - "/tests/corpus/class-accessor-returned-function.js" - ], - "diags": [] - }, - "/tests/corpus/class-array-optional-return.ts": { - "order": [ - "/tests/corpus/class-array-optional-return.ts" - ], - "diags": [] - }, - "/tests/corpus/class-bracket-method-calls.js": { - "order": [ - "/tests/corpus/class-bracket-method-calls.js" - ], - "diags": [] - }, - "/tests/corpus/class-brand-overload.js": { - "order": [ - "/tests/corpus/class-brand-overload.js" - ], - "diags": [] - }, - "/tests/corpus/class-callback-replacement.js": { - "order": [ - "/tests/corpus/class-callback-replacement.js" - ], - "diags": [] - }, - "/tests/corpus/class-checked-composites.ts": { - "order": [ - "/tests/corpus/class-checked-composites.ts" - ], - "diags": [] - }, - "/tests/corpus/class-checked-upcast.ts": { - "order": [ - "/tests/corpus/class-checked-upcast.ts" - ], - "diags": [] - }, - "/tests/corpus/class-computed-presence.ts": { - "order": [ - "/tests/corpus/class-computed-presence.ts" - ], - "diags": [] - }, - "/tests/corpus/class-computed-symbols.js": { - "order": [ - "/tests/corpus/class-computed-symbols.js" - ], - "diags": [] - }, - "/tests/corpus/class-curried-factory.mjs": { - "order": [ - "/tests/corpus/class-curried-factory.mjs" - ], - "diags": [] - }, - "/tests/corpus/class-data-descriptors.js": { - "order": [ - "/tests/corpus/class-data-descriptors.js" - ], - "diags": [] - }, - "/tests/corpus/class-factory-inherited-statics.mjs": { - "order": [ - "/tests/corpus/class-factory-inherited-statics.mjs" - ], - "diags": [] - }, - "/tests/corpus/class-factory-parameter-base.mjs": { - "order": [ - "/tests/corpus/class-factory-parameter-base.mjs" - ], - "diags": [] - }, - "/tests/corpus/class-factory-record-base.mjs": { - "order": [ - "/tests/corpus/class-factory-record-base.mjs" - ], - "diags": [] - }, - "/tests/corpus/class-factory-recursive-statics.mjs": { - "order": [ - "/tests/corpus/class-factory-recursive-statics.mjs" - ], - "diags": [] - }, - "/tests/corpus/class-factory-static-members.mjs": { - "order": [ - "/tests/corpus/class-factory-static-members.mjs" - ], - "diags": [] - }, - "/tests/corpus/class-function-base/main.js": { - "order": [ - "/tests/corpus/class-function-base/base.js", - "/tests/corpus/class-function-base/main.js" - ], - "diags": [] - }, - "/tests/corpus/class-instance-constructor.js": { - "order": [ - "/tests/corpus/class-instance-constructor.js" - ], - "diags": [] - }, - "/tests/corpus/class-interface-refinements.ts": { - "order": [ - "/tests/corpus/class-interface-refinements.ts" - ], - "diags": [] - }, - "/tests/corpus/class-json-checked.ts": { - "order": [ - "/tests/corpus/class-json-checked.ts" - ], - "diags": [] - }, - "/tests/corpus/class-local-function-base.mjs": { - "order": [ - "/tests/corpus/class-local-function-base.mjs" - ], - "diags": [] - }, - "/tests/corpus/class-method-spreads.ts": { - "order": [ - "/tests/corpus/class-method-spreads.ts" - ], - "diags": [] - }, - "/tests/corpus/class-property-call-values.mjs": { - "order": [ - "/tests/corpus/class-property-call-values.mjs" - ], - "diags": [] - }, - "/tests/corpus/class-prototype-data.js": { - "order": [ - "/tests/corpus/class-prototype-data.js" - ], - "diags": [] - }, - "/tests/corpus/class-prototype-descriptor-copy.mjs": { - "order": [ - "/tests/corpus/class-prototype-descriptor-copy.mjs" - ], - "diags": [] - }, - "/tests/corpus/class-specialized-computed-base.mjs": { - "order": [ - "/tests/corpus/class-specialized-computed-base.mjs" - ], - "diags": [] - }, - "/tests/corpus/class-static-data.js": { - "order": [ - "/tests/corpus/class-static-data.js" - ], - "diags": [] - }, - "/tests/corpus/class-super-surplus-spread.mjs": { - "order": [ - "/tests/corpus/class-super-surplus-spread.mjs" - ], - "diags": [] - }, - "/tests/corpus/class-symbol-accessors.ts": { - "order": [ - "/tests/corpus/class-symbol-accessors.ts" - ], - "diags": [] - }, - "/tests/corpus/class-symbol-cache.mjs": { - "order": [ - "/tests/corpus/class-symbol-cache.mjs" - ], - "diags": [] - }, - "/tests/corpus/class-value-constructor-exceptions.ts": { - "order": [ - "/tests/corpus/class-value-constructor-exceptions.ts" - ], - "diags": [] - }, - "/tests/corpus/closure-nullable-union-return.ts": { - "order": [ - "/tests/corpus/closure-nullable-union-return.ts" - ], - "diags": [] - }, - "/tests/corpus/collection-array-cycles.ts": { - "order": [ - "/tests/corpus/collection-array-cycles.ts" - ], - "diags": [] - }, - "/tests/corpus/collection-array-maps.ts": { - "order": [ - "/tests/corpus/collection-array-maps.ts" - ], - "diags": [] - }, - "/tests/corpus/collection-array-missing.ts": { - "order": [ - "/tests/corpus/collection-array-missing.ts" - ], - "diags": [] - }, - "/tests/corpus/collection-array-sets.ts": { - "order": [ - "/tests/corpus/collection-array-sets.ts" - ], - "diags": [] - }, - "/tests/corpus/collection-copy-identities.ts": { - "order": [ - "/tests/corpus/collection-copy-identities.ts" - ], - "diags": [] - }, - "/tests/corpus/compound-field-receivers.ts": { - "order": [ - "/tests/corpus/compound-field-receivers.ts" - ], - "diags": [] - }, - "/tests/corpus/compound-presence-guards.ts": { - "order": [ - "/tests/corpus/compound-presence-guards.ts" - ], - "diags": [] - }, - "/tests/corpus/conditional-tuple-destructuring.ts": { - "order": [ - "/tests/corpus/conditional-tuple-destructuring.ts" - ], - "diags": [] - }, - "/tests/corpus/console-imports.cjs": { - "order": [ - "/tests/corpus/console-imports.cjs" - ], - "diags": [] - }, - "/tests/corpus/console-native-value.js": { - "order": [ - "/tests/corpus/console-native-value.js" - ], - "diags": [] - }, - "/tests/corpus/contextual-array-union-write.ts": { - "order": [ - "/tests/corpus/contextual-array-union-write.ts" - ], - "diags": [] - }, - "/tests/corpus/contextual-return-layouts.ts": { - "order": [ - "/tests/corpus/contextual-return-layouts.ts" - ], - "diags": [] - }, - "/tests/corpus/crypto-hash-optional-input.ts": { - "order": [ - "/tests/corpus/crypto-hash-optional-input.ts" - ], - "diags": [] - }, - "/tests/corpus/date-checked-native.js": { - "order": [ - "/tests/corpus/date-checked-native.js" - ], - "diags": [] - }, - "/tests/corpus/declared-index-spread.ts": { - "order": [ - "/tests/corpus/declared-index-spread.ts" - ], - "diags": [] - }, - "/tests/corpus/deep-reference-teardown.ts": { - "order": [ - "/tests/corpus/deep-reference-teardown.ts" - ], - "diags": [] - }, - "/tests/corpus/default-undefined-parameters.ts": { - "order": [ - "/tests/corpus/default-undefined-parameters.ts" - ], - "diags": [] - }, - "/tests/corpus/deferred-registry-many.ts": { - "order": [ - "/tests/corpus/deferred-registry-many.ts" - ], - "diags": [] - }, - "/tests/corpus/destructure-call-assignment.js": { - "order": [ - "/tests/corpus/destructure-call-assignment.js" - ], - "diags": [] - }, - "/tests/corpus/destructure-inferred-row-defaults.js": { - "order": [ - "/tests/corpus/destructure-inferred-row-defaults.js" - ], - "diags": [] - }, - "/tests/corpus/destructure-union-arrays.ts": { - "order": [ - "/tests/corpus/destructure-union-arrays.ts" - ], - "diags": [] - }, - "/tests/corpus/dynamic-function-descriptors.js": { - "order": [ - "/tests/corpus/dynamic-function-descriptors.js" - ], - "diags": [] - }, - "/tests/corpus/error-cause-writes.js": { - "order": [ - "/tests/corpus/error-cause-writes.js" - ], - "diags": [] - }, - "/tests/corpus/error-inherited-message.mjs": { - "order": [ - "/tests/corpus/error-inherited-message.mjs" - ], - "diags": [] - }, - "/tests/corpus/error-inherited-name.mjs": { - "order": [ - "/tests/corpus/error-inherited-name.mjs" - ], - "diags": [] - }, - "/tests/corpus/error-property-writes.mjs": { - "order": [ - "/tests/corpus/error-property-writes.mjs" - ], - "diags": [] - }, - "/tests/corpus/error-prototype-tostring.js": { - "order": [ - "/tests/corpus/error-prototype-tostring.js" - ], - "diags": [] - }, - "/tests/corpus/error-stack-frames.ts": { - "order": [ - "/tests/corpus/error-stack-frames.ts" - ], - "diags": [] - }, - "/tests/corpus/error-stack-limit.ts": { - "order": [ - "/tests/corpus/error-stack-limit.ts" - ], - "diags": [] - }, - "/tests/corpus/error-tostring-overrides.ts": { - "order": [ - "/tests/corpus/error-tostring-overrides.ts" - ], - "diags": [] - }, - "/tests/corpus/expression-runtime-values.ts": { - "order": [ - "/tests/corpus/expression-runtime-values.ts" - ], - "diags": [] - }, - "/tests/corpus/field-assignment-values.ts": { - "order": [ - "/tests/corpus/field-assignment-values.ts" - ], - "diags": [] - }, - "/tests/corpus/file-handle-values.ts": { - "order": [ - "/tests/corpus/file-handle-values.ts" - ], - "diags": [] - }, - "/tests/corpus/file-url-percent-decoding.ts": { - "order": [ - "/tests/corpus/file-url-percent-decoding.ts" - ], - "diags": [] - }, - "/tests/corpus/for-multiple-bindings.ts": { - "order": [ - "/tests/corpus/for-multiple-bindings.ts" - ], - "diags": [] - }, - "/tests/corpus/for-multiple-lexical-bindings.ts": { - "order": [ - "/tests/corpus/for-multiple-lexical-bindings.ts" - ], - "diags": [] - }, - "/tests/corpus/for-of-checked-iterator.js": { - "order": [ - "/tests/corpus/for-of-checked-iterator.js" - ], - "diags": [] - }, - "/tests/corpus/fresh-array-union-layout.js": { - "order": [ - "/tests/corpus/fresh-array-union-layout.js" - ], - "diags": [] - }, - "/tests/corpus/frozen-checked-dictionaries.mjs": { - "order": [ - "/tests/corpus/frozen-checked-dictionaries.mjs" - ], - "diags": [] - }, - "/tests/corpus/fs-native-realpath.ts": { - "order": [ - "/tests/corpus/fs-native-realpath.ts" - ], - "diags": [] - }, - "/tests/corpus/fs-remove-readonly.ts": { - "order": [ - "/tests/corpus/fs-remove-readonly.ts" - ], - "diags": [] - }, - "/tests/corpus/fs-write-string-bytes-union.ts": { - "order": [ - "/tests/corpus/fs-write-string-bytes-union.ts" - ], - "diags": [] - }, - "/tests/corpus/function-apply-value.mjs": { - "order": [ - "/tests/corpus/function-apply-value.mjs" - ], - "diags": [] - }, - "/tests/corpus/function-constructor-global.mjs": { - "order": [ - "/tests/corpus/function-constructor-global.mjs" - ], - "diags": [] - }, - "/tests/corpus/function-constructor-kinds/main.js": { - "order": [ - "/tests/corpus/function-constructor-kinds/consumer.js", - "/tests/corpus/function-constructor-kinds/main.js" - ], - "diags": [] - }, - "/tests/corpus/function-custom-prototype.js": { - "order": [ - "/tests/corpus/function-custom-prototype.js" - ], - "diags": [] - }, - "/tests/corpus/function-custom-to-string.mjs": { - "order": [ - "/tests/corpus/function-custom-to-string.mjs" - ], - "diags": [] - }, - "/tests/corpus/function-object-assign.js": { - "order": [ - "/tests/corpus/function-object-assign.js" - ], - "diags": [] - }, - "/tests/corpus/function-own-prototype/main.js": { - "order": [ - "/tests/corpus/function-own-prototype/consumer.js", - "/tests/corpus/function-own-prototype/main.js" - ], - "diags": [] - }, - "/tests/corpus/generator-checked-protocol.ts": { - "order": [ - "/tests/corpus/generator-checked-protocol.ts" - ], - "diags": [] - }, - "/tests/corpus/generator-checked-return.js": { - "order": [ - "/tests/corpus/generator-checked-return.js" - ], - "diags": [] - }, - "/tests/corpus/generator-custom-delegation/main.ts": { - "order": [ - "/tests/corpus/generator-custom-delegation/iterators.js", - "/tests/corpus/generator-custom-delegation/main.ts" - ], - "diags": [] - }, - "/tests/corpus/generator-default-return-pattern.ts": { - "order": [ - "/tests/corpus/generator-default-return-pattern.ts" - ], - "diags": [] - }, - "/tests/corpus/generator-delegation-values.ts": { - "order": [ - "/tests/corpus/generator-delegation-values.ts" - ], - "diags": [] - }, - "/tests/corpus/generator-inferred-date.js": { - "order": [ - "/tests/corpus/generator-inferred-date.js" - ], - "diags": [] - }, - "/tests/corpus/generator-mixed-checked-channels.ts": { - "order": [ - "/tests/corpus/generator-mixed-checked-channels.ts" - ], - "diags": [] - }, - "/tests/corpus/generator-untyped-consumer/main.ts": { - "order": [ - "/tests/corpus/generator-untyped-consumer/consumer.js", - "/tests/corpus/generator-untyped-consumer/main.ts" - ], - "diags": [] - }, - "/tests/corpus/generic-binding-ownership.ts": { - "order": [ - "/tests/corpus/generic-binding-ownership.ts" - ], - "diags": [] - }, - "/tests/corpus/generic-class-js-functions/main.ts": { - "order": [ - "/tests/corpus/generic-class-js-functions/functions.js", - "/tests/corpus/generic-class-js-functions/main.ts" - ], - "diags": [] - }, - "/tests/corpus/generic-class-recovery.ts": { - "order": [ - "/tests/corpus/generic-class-recovery.ts" - ], - "diags": [] - }, - "/tests/corpus/generic-pattern-bindings.ts": { - "order": [ - "/tests/corpus/generic-pattern-bindings.ts" - ], - "diags": [] - }, - "/tests/corpus/generic-record-index.ts": { - "order": [ - "/tests/corpus/generic-record-index.ts" - ], - "diags": [] - }, - "/tests/corpus/generic-visitor-void.ts": { - "order": [ - "/tests/corpus/generic-visitor-void.ts" - ], - "diags": [] - }, - "/tests/corpus/global-error-subclasses.ts": { - "order": [ - "/tests/corpus/global-error-subclasses.ts" - ], - "diags": [] - }, - "/tests/corpus/global-runtime-probes.js": { - "order": [ - "/tests/corpus/global-runtime-probes.js" - ], - "diags": [] - }, - "/tests/corpus/global-stored-probes.js": { - "order": [ - "/tests/corpus/global-stored-probes.js" - ], - "diags": [] - }, - "/tests/corpus/global-string-cache/main.js": { - "order": [ - "/tests/corpus/global-string-cache/remote.js", - "/tests/corpus/global-string-cache/main.js" - ], - "diags": [] - }, - "/tests/corpus/global-symbol-cache/main.js": { - "order": [ - "/tests/corpus/global-symbol-cache/remote.js", - "/tests/corpus/global-symbol-cache/main.js" - ], - "diags": [] - }, - "/tests/corpus/guarded-native-iterables.ts": { - "order": [ - "/tests/corpus/guarded-native-iterables.ts" - ], - "diags": [] - }, - "/tests/corpus/indexed-assignment-values.js": { - "order": [ - "/tests/corpus/indexed-assignment-values.js" - ], - "diags": [] - }, - "/tests/corpus/indexed-assignment-values.ts": { - "order": [ - "/tests/corpus/indexed-assignment-values.ts" - ], - "diags": [] - }, - "/tests/corpus/inferred-array-assignment-values.mjs": { - "order": [ - "/tests/corpus/inferred-array-assignment-values.mjs" - ], - "diags": [] - }, - "/tests/corpus/inferred-class-default.mjs": { - "order": [ - "/tests/corpus/inferred-class-default.mjs" - ], - "diags": [] - }, - "/tests/corpus/inferred-compound-values.mjs": { - "order": [ - "/tests/corpus/inferred-compound-values.mjs" - ], - "diags": [] - }, - "/tests/corpus/inferred-conditional-class.mjs": { - "order": [ - "/tests/corpus/inferred-conditional-class.mjs" - ], - "diags": [] - }, - "/tests/corpus/inferred-error-fields.js": { - "order": [ - "/tests/corpus/inferred-error-fields.js" - ], - "diags": [] - }, - "/tests/corpus/inferred-map-patterns.mjs": { - "order": [ - "/tests/corpus/inferred-map-patterns.mjs" - ], - "diags": [] - }, - "/tests/corpus/inferred-method-override.js": { - "order": [ - "/tests/corpus/inferred-method-override.js" - ], - "diags": [] - }, - "/tests/corpus/inferred-partial-destructuring.mjs": { - "order": [ - "/tests/corpus/inferred-partial-destructuring.mjs" - ], - "diags": [] - }, - "/tests/corpus/inferred-primitive-properties.mjs": { - "order": [ - "/tests/corpus/inferred-primitive-properties.mjs" - ], - "diags": [] - }, - "/tests/corpus/inferred-record-return.mjs": { - "order": [ - "/tests/corpus/inferred-record-return.mjs" - ], - "diags": [] - }, - "/tests/corpus/inferred-recursive-record.mjs": { - "order": [ - "/tests/corpus/inferred-recursive-record.mjs" - ], - "diags": [] - }, - "/tests/corpus/inferred-undefined-field.mjs": { - "order": [ - "/tests/corpus/inferred-undefined-field.mjs" - ], - "diags": [] - }, - "/tests/corpus/instanceof-class-record-union.ts": { - "order": [ - "/tests/corpus/instanceof-class-record-union.ts" - ], - "diags": [] - }, - "/tests/corpus/intl-grapheme-conformance/main.ts": { - "order": [ - "/tests/corpus/intl-grapheme-conformance/cases.ts", - "/tests/corpus/intl-grapheme-conformance/main.ts" - ], - "diags": [] - }, - "/tests/corpus/intl-grapheme.ts": { - "order": [ - "/tests/corpus/intl-grapheme.ts" - ], - "diags": [] - }, - "/tests/corpus/js-abort-portable.js": { - "order": [ - "/tests/corpus/js-abort-portable.js" - ], - "diags": [] - }, - "/tests/corpus/js-array-constructor.js": { - "order": [ - "/tests/corpus/js-array-constructor.js" - ], - "diags": [] - }, - "/tests/corpus/js-array-default-buffer.js": { - "order": [ - "/tests/corpus/js-array-default-buffer.js" - ], - "diags": [] - }, - "/tests/corpus/js-array-iterators.js": { - "order": [ - "/tests/corpus/js-array-iterators.js" - ], - "diags": [] - }, - "/tests/corpus/js-arrow-bind.cjs": { - "order": [ - "/tests/corpus/js-arrow-bind.cjs" - ], - "diags": [] - }, - "/tests/corpus/js-buffer-callback-brand.cjs": { - "order": [ - "/tests/corpus/js-buffer-callback-brand.cjs" - ], - "diags": [] - }, - "/tests/corpus/js-callable-proxy.js": { - "order": [ - "/tests/corpus/js-callable-proxy.js" - ], - "diags": [] - }, - "/tests/corpus/js-chained-native-results.mjs": { - "order": [ - "/tests/corpus/js-chained-native-results.mjs" - ], - "diags": [] - }, - "/tests/corpus/js-checked-array-iterator.js": { - "order": [ - "/tests/corpus/js-checked-array-iterator.js" - ], - "diags": [] - }, - "/tests/corpus/js-checked-array-reference.js": { - "order": [ - "/tests/corpus/js-checked-array-reference.js" - ], - "diags": [] - }, - "/tests/corpus/js-checked-number-negation.mjs": { - "order": [ - "/tests/corpus/js-checked-number-negation.mjs" - ], - "diags": [] - }, - "/tests/corpus/js-checked-sort-result.js": { - "order": [ - "/tests/corpus/js-checked-sort-result.js" - ], - "diags": [] - }, - "/tests/corpus/js-child-error-listener.cjs": { - "order": [ - "/tests/corpus/js-child-error-listener.cjs" - ], - "diags": [] - }, - "/tests/corpus/js-cjs-callable-snapshots/main.cjs": { - "order": [ - "/tests/corpus/js-cjs-callable-snapshots/factories.cjs", - "/tests/corpus/js-cjs-callable-snapshots/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/js-class-added-parameters.js": { - "order": [ - "/tests/corpus/js-class-added-parameters.js" - ], - "diags": [] - }, - "/tests/corpus/js-class-checked-overrides.js": { - "order": [ - "/tests/corpus/js-class-checked-overrides.js" - ], - "diags": [] - }, - "/tests/corpus/js-class-computed-fields.js": { - "order": [ - "/tests/corpus/js-class-computed-fields.js" - ], - "diags": [] - }, - "/tests/corpus/js-class-enumeration.js": { - "order": [ - "/tests/corpus/js-class-enumeration.js" - ], - "diags": [] - }, - "/tests/corpus/js-class-field-accessor-override.js": { - "order": [ - "/tests/corpus/js-class-field-accessor-override.js" - ], - "diags": [] - }, - "/tests/corpus/js-class-fluent-overrides.js": { - "order": [ - "/tests/corpus/js-class-fluent-overrides.js" - ], - "diags": [] - }, - "/tests/corpus/js-class-late-method-values.js": { - "order": [ - "/tests/corpus/js-class-late-method-values.js" - ], - "diags": [] - }, - "/tests/corpus/js-class-member-dispatch.js": { - "order": [ - "/tests/corpus/js-class-member-dispatch.js" - ], - "diags": [] - }, - "/tests/corpus/js-class-return-shapes.js": { - "order": [ - "/tests/corpus/js-class-return-shapes.js" - ], - "diags": [] - }, - "/tests/corpus/js-class-shadowed-methods.js": { - "order": [ - "/tests/corpus/js-class-shadowed-methods.js" - ], - "diags": [] - }, - "/tests/corpus/js-class-stored-method-receiver.js": { - "order": [ - "/tests/corpus/js-class-stored-method-receiver.js" - ], - "diags": [] - }, - "/tests/corpus/js-class-subclass-properties.js": { - "order": [ - "/tests/corpus/js-class-subclass-properties.js" - ], - "diags": [] - }, - "/tests/corpus/js-class-symbol-spread.cjs": { - "order": [ - "/tests/corpus/js-class-symbol-spread.cjs" - ], - "diags": [] - }, - "/tests/corpus/js-computed-prototype-additions.js": { - "order": [ - "/tests/corpus/js-computed-prototype-additions.js" - ], - "diags": [] - }, - "/tests/corpus/js-constructor-returned-callable.js": { - "order": [ - "/tests/corpus/js-constructor-returned-callable.js" - ], - "diags": [] - }, - "/tests/corpus/js-constructor-spread.js": { - "order": [ - "/tests/corpus/js-constructor-spread.js" - ], - "diags": [] - }, - "/tests/corpus/js-dataview-dispatch.js": { - "order": [ - "/tests/corpus/js-dataview-dispatch.js" - ], - "diags": [] - }, - "/tests/corpus/js-declared-fields.cjs": { - "order": [ - "/tests/corpus/js-declared-fields.cjs" - ], - "diags": [] - }, - "/tests/corpus/js-default-listener-arguments.cjs": { - "order": [ - "/tests/corpus/js-default-listener-arguments.cjs" - ], - "diags": [] - }, - "/tests/corpus/js-default-options/main.ts": { - "order": [ - "/tests/corpus/js-default-options/options.js", - "/tests/corpus/js-default-options/index.js", - "/tests/corpus/js-default-options/main.ts" - ], - "diags": [] - }, - "/tests/corpus/js-deferred-field-initializers.js": { - "order": [ - "/tests/corpus/js-deferred-field-initializers.js" - ], - "diags": [] - }, - "/tests/corpus/js-deferred-registry-effects.js": { - "order": [ - "/tests/corpus/js-deferred-registry-effects.js" - ], - "diags": [] - }, - "/tests/corpus/js-derived-constructor-hoisting.js": { - "order": [ - "/tests/corpus/js-derived-constructor-hoisting.js" - ], - "diags": [] - }, - "/tests/corpus/js-dormant-array-write.js": { - "order": [ - "/tests/corpus/js-dormant-array-write.js" - ], - "diags": [] - }, - "/tests/corpus/js-dormant-overrides.js": { - "order": [ - "/tests/corpus/js-dormant-overrides.js" - ], - "diags": [] - }, - "/tests/corpus/js-expando-records.js": { - "order": [ - "/tests/corpus/js-expando-records.js" - ], - "diags": [] - }, - "/tests/corpus/js-implicit-call-results.js": { - "order": [ - "/tests/corpus/js-implicit-call-results.js" - ], - "diags": [] - }, - "/tests/corpus/js-inferred-callback-exports/main.js": { - "order": [ - "/tests/corpus/js-inferred-callback-exports/internal.js", - "/tests/corpus/js-inferred-callback-exports/facade.js", - "/tests/corpus/js-inferred-callback-exports/main.js" - ], - "diags": [] - }, - "/tests/corpus/js-inferred-class-array-return.js": { - "order": [ - "/tests/corpus/js-inferred-class-array-return.js" - ], - "diags": [] - }, - "/tests/corpus/js-inferred-object-values.js": { - "order": [ - "/tests/corpus/js-inferred-object-values.js" - ], - "diags": [] - }, - "/tests/corpus/js-inherited-field-storage.js": { - "order": [ - "/tests/corpus/js-inherited-field-storage.js" - ], - "diags": [] - }, - "/tests/corpus/js-inherited-parameter-abi.js": { - "order": [ - "/tests/corpus/js-inherited-parameter-abi.js" - ], - "diags": [] - }, - "/tests/corpus/js-iterable-spread.js": { - "order": [ - "/tests/corpus/js-iterable-spread.js" - ], - "diags": [] - }, - "/tests/corpus/js-loose-dynamic-primitives.js": { - "order": [ - "/tests/corpus/js-loose-dynamic-primitives.js" - ], - "diags": [] - }, - "/tests/corpus/js-map-object-seeds.js": { - "order": [ - "/tests/corpus/js-map-object-seeds.js" - ], - "diags": [] - }, - "/tests/corpus/js-member-increment.js": { - "order": [ - "/tests/corpus/js-member-increment.js" - ], - "diags": [] - }, - "/tests/corpus/js-module-function-values.js": { - "order": [ - "/tests/corpus/js-module-function-values.js" - ], - "diags": [] - }, - "/tests/corpus/js-mutable-null-members.js": { - "order": [ - "/tests/corpus/js-mutable-null-members.js" - ], - "diags": [] - }, - "/tests/corpus/js-nested-native-descriptors.js": { - "order": [ - "/tests/corpus/js-nested-native-descriptors.js" - ], - "diags": [] - }, - "/tests/corpus/js-normalize-dispatch.js": { - "order": [ - "/tests/corpus/js-normalize-dispatch.js" - ], - "diags": [] - }, - "/tests/corpus/js-nullish-inherited-fields.mjs": { - "order": [ - "/tests/corpus/js-nullish-inherited-fields.mjs" - ], - "diags": [] - }, - "/tests/corpus/js-object-receiver-storage.js": { - "order": [ - "/tests/corpus/js-object-receiver-storage.js" - ], - "diags": [] - }, - "/tests/corpus/js-object-returning-constructors.mjs": { - "order": [ - "/tests/corpus/js-object-returning-constructors.mjs" - ], - "diags": [] - }, - "/tests/corpus/js-object-shared-arrays.js": { - "order": [ - "/tests/corpus/js-object-shared-arrays.js" - ], - "diags": [] - }, - "/tests/corpus/js-omitted-typed-arguments.js": { - "order": [ - "/tests/corpus/js-omitted-typed-arguments.js" - ], - "diags": [] - }, - "/tests/corpus/js-optional-class-fields.js": { - "order": [ - "/tests/corpus/js-optional-class-fields.js" - ], - "diags": [] - }, - "/tests/corpus/js-optional-member-call.js": { - "order": [ - "/tests/corpus/js-optional-member-call.js" - ], - "diags": [] - }, - "/tests/corpus/js-primitive-union-addition.js": { - "order": [ - "/tests/corpus/js-primitive-union-addition.js" - ], - "diags": [] - }, - "/tests/corpus/js-promise-all-values.js": { - "order": [ - "/tests/corpus/js-promise-all-values.js" - ], - "diags": [] - }, - "/tests/corpus/js-promise-catch-handler.js": { - "order": [ - "/tests/corpus/js-promise-catch-handler.js" - ], - "diags": [] - }, - "/tests/corpus/js-promise-finally-order.js": { - "order": [ - "/tests/corpus/js-promise-finally-order.js" - ], - "diags": [] - }, - "/tests/corpus/js-promise-pending-reactions.js": { - "order": [ - "/tests/corpus/js-promise-pending-reactions.js" - ], - "diags": [] - }, - "/tests/corpus/js-prototype-host-boundary.js": { - "order": [ - "/tests/corpus/js-prototype-host-boundary.js" - ], - "diags": [] - }, - "/tests/corpus/js-reflect-receivers.js": { - "order": [ - "/tests/corpus/js-reflect-receivers.js" - ], - "diags": [] - }, - "/tests/corpus/js-regex-record-captures.js": { - "order": [ - "/tests/corpus/js-regex-record-captures.js" - ], - "diags": [] - }, - "/tests/corpus/js-scalar-iterables.js": { - "order": [ - "/tests/corpus/js-scalar-iterables.js" - ], - "diags": [] - }, - "/tests/corpus/js-shared-method-dispatch.js": { - "order": [ - "/tests/corpus/js-shared-method-dispatch.js" - ], - "diags": [] - }, - "/tests/corpus/js-specialized-field-method.js": { - "order": [ - "/tests/corpus/js-specialized-field-method.js" - ], - "diags": [] - }, - "/tests/corpus/js-static-accessors.js": { - "order": [ - "/tests/corpus/js-static-accessors.js" - ], - "diags": [] - }, - "/tests/corpus/js-static-method-values.js": { - "order": [ - "/tests/corpus/js-static-method-values.js" - ], - "diags": [] - }, - "/tests/corpus/js-static-registries.cjs": { - "order": [ - "/tests/corpus/js-static-registries.cjs" - ], - "diags": [] - }, - "/tests/corpus/js-super-accessor-initialization.js": { - "order": [ - "/tests/corpus/js-super-accessor-initialization.js" - ], - "diags": [] - }, - "/tests/corpus/js-uninitialized-native-fields.js": { - "order": [ - "/tests/corpus/js-uninitialized-native-fields.js" - ], - "diags": [] - }, - "/tests/corpus/json-guarded-map-values.ts": { - "order": [ - "/tests/corpus/json-guarded-map-values.ts" - ], - "diags": [] - }, - "/tests/corpus/json-output-bulk.ts": { - "order": [ - "/tests/corpus/json-output-bulk.ts" - ], - "diags": [] - }, - "/tests/corpus/json-runtime-options.mjs": { - "order": [ - "/tests/corpus/json-runtime-options.mjs" - ], - "diags": [] - }, - "/tests/corpus/json-stringify-value.js": { - "order": [ - "/tests/corpus/json-stringify-value.js" - ], - "diags": [] - }, - "/tests/corpus/live-reference-shared-converters.ts": { - "order": [ - "/tests/corpus/live-reference-shared-converters.ts" - ], - "diags": [] - }, - "/tests/corpus/llvm-read-receiver-lifetime.ts": { - "order": [ - "/tests/corpus/llvm-read-receiver-lifetime.ts" - ], - "diags": [] - }, - "/tests/corpus/local-class-call-spreads.js": { - "order": [ - "/tests/corpus/local-class-call-spreads.js" - ], - "diags": [] - }, - "/tests/corpus/local-class-declaration.ts": { - "order": [ - "/tests/corpus/local-class-declaration.ts" - ], - "diags": [] - }, - "/tests/corpus/local-class-evaluation.ts": { - "order": [ - "/tests/corpus/local-class-evaluation.ts" - ], - "diags": [] - }, - "/tests/corpus/local-class-inheritance.ts": { - "order": [ - "/tests/corpus/local-class-inheritance.ts" - ], - "diags": [] - }, - "/tests/corpus/local-class-lifetimes.ts": { - "order": [ - "/tests/corpus/local-class-lifetimes.ts" - ], - "diags": [] - }, - "/tests/corpus/local-class-namespace/main.js": { - "order": [ - "/tests/corpus/local-class-namespace/base.js", - "/tests/corpus/local-class-namespace/main.js" - ], - "diags": [] - }, - "/tests/corpus/local-class-prototype-data.js": { - "order": [ - "/tests/corpus/local-class-prototype-data.js" - ], - "diags": [] - }, - "/tests/corpus/local-class-specialization.js": { - "order": [ - "/tests/corpus/local-class-specialization.js" - ], - "diags": [] - }, - "/tests/corpus/local-class-unknown.ts": { - "order": [ - "/tests/corpus/local-class-unknown.ts" - ], - "diags": [] - }, - "/tests/corpus/local-class-values.ts": { - "order": [ - "/tests/corpus/local-class-values.ts" - ], - "diags": [] - }, - "/tests/corpus/logical-assignment-dynamic.js": { - "order": [ - "/tests/corpus/logical-assignment-dynamic.js" - ], - "diags": [] - }, - "/tests/corpus/logical-assignment-values.ts": { - "order": [ - "/tests/corpus/logical-assignment-values.ts" - ], - "diags": [] - }, - "/tests/corpus/logical-runtime-optional-record.ts": { - "order": [ - "/tests/corpus/logical-runtime-optional-record.ts" - ], - "diags": [] - }, - "/tests/corpus/loop-reference-lifetimes.ts": { - "order": [ - "/tests/corpus/loop-reference-lifetimes.ts" - ], - "diags": [] - }, - "/tests/corpus/map-checked-boundary/main.ts": { - "order": [ - "/tests/corpus/map-checked-boundary/consumer.js", - "/tests/corpus/map-checked-boundary/main.ts" - ], - "diags": [] - }, - "/tests/corpus/map-checked-seed.js": { - "order": [ - "/tests/corpus/map-checked-seed.js" - ], - "diags": [] - }, - "/tests/corpus/map-number-keys-dense.ts": { - "order": [ - "/tests/corpus/map-number-keys-dense.ts" - ], - "diags": [] - }, - "/tests/corpus/map-read-lifetimes-exits.ts": { - "order": [ - "/tests/corpus/map-read-lifetimes-exits.ts" - ], - "diags": [] - }, - "/tests/corpus/map-read-lifetimes.ts": { - "order": [ - "/tests/corpus/map-read-lifetimes.ts" - ], - "diags": [] - }, - "/tests/corpus/map-seeds-and-spreads.ts": { - "order": [ - "/tests/corpus/map-seeds-and-spreads.ts" - ], - "diags": [] - }, - "/tests/corpus/map-typed-array-values.ts": { - "order": [ - "/tests/corpus/map-typed-array-values.ts" - ], - "diags": [] - }, - "/tests/corpus/math-function-values.js": { - "order": [ - "/tests/corpus/math-function-values.js" - ], - "diags": [] - }, - "/tests/corpus/module-fallback-functions/main.js": { - "order": [ - "/tests/corpus/module-fallback-functions/platform.js", - "/tests/corpus/module-fallback-functions/main.js" - ], - "diags": [] - }, - "/tests/corpus/narrowed-nullish-values.ts": { - "order": [ - "/tests/corpus/narrowed-nullish-values.ts" - ], - "diags": [] - }, - "/tests/corpus/native-array-borrowed-find-last.js": { - "order": [ - "/tests/corpus/native-array-borrowed-find-last.js" - ], - "diags": [] - }, - "/tests/corpus/native-array-borrowed-slice.js": { - "order": [ - "/tests/corpus/native-array-borrowed-slice.js" - ], - "diags": [] - }, - "/tests/corpus/native-array-copying-methods.js": { - "order": [ - "/tests/corpus/native-array-copying-methods.js" - ], - "diags": [] - }, - "/tests/corpus/native-array-fill-copywithin.js": { - "order": [ - "/tests/corpus/native-array-fill-copywithin.js" - ], - "diags": [] - }, - "/tests/corpus/native-array-frozen-noops.js": { - "order": [ - "/tests/corpus/native-array-frozen-noops.js" - ], - "diags": [] - }, - "/tests/corpus/native-array-index-boundaries.js": { - "order": [ - "/tests/corpus/native-array-index-boundaries.js" - ], - "diags": [] - }, - "/tests/corpus/native-array-integrity.js": { - "order": [ - "/tests/corpus/native-array-integrity.js" - ], - "diags": [] - }, - "/tests/corpus/native-array-length.js": { - "order": [ - "/tests/corpus/native-array-length.js" - ], - "diags": [] - }, - "/tests/corpus/native-array-named-properties.js": { - "order": [ - "/tests/corpus/native-array-named-properties.js" - ], - "diags": [] - }, - "/tests/corpus/native-array-prototype/main.js": { - "order": [ - "/tests/corpus/native-array-prototype/main.js" - ], - "diags": [] - }, - "/tests/corpus/native-array-read-lifetimes.ts": { - "order": [ - "/tests/corpus/native-array-read-lifetimes.ts" - ], - "diags": [] - }, - "/tests/corpus/native-array-reduce-find-last.js": { - "order": [ - "/tests/corpus/native-array-reduce-find-last.js" - ], - "diags": [] - }, - "/tests/corpus/native-array-search-from-index.js": { - "order": [ - "/tests/corpus/native-array-search-from-index.js" - ], - "diags": [] - }, - "/tests/corpus/native-array-splice-coercion.js": { - "order": [ - "/tests/corpus/native-array-splice-coercion.js" - ], - "diags": [] - }, - "/tests/corpus/native-array-splice-flat.js": { - "order": [ - "/tests/corpus/native-array-splice-flat.js" - ], - "diags": [] - }, - "/tests/corpus/native-buffer-coercion.js": { - "order": [ - "/tests/corpus/native-buffer-coercion.js" - ], - "diags": [] - }, - "/tests/corpus/native-class-array-boundaries.ts": { - "order": [ - "/tests/corpus/native-class-array-boundaries.ts" - ], - "diags": [] - }, - "/tests/corpus/native-class-cache.js": { - "order": [ - "/tests/corpus/native-class-cache.js" - ], - "diags": [] - }, - "/tests/corpus/native-class-properties.cjs": { - "order": [ - "/tests/corpus/native-class-properties.cjs" - ], - "diags": [] - }, - "/tests/corpus/native-class-property-cycles.cjs": { - "order": [ - "/tests/corpus/native-class-property-cycles.cjs" - ], - "diags": [] - }, - "/tests/corpus/native-class-property-order.cjs": { - "order": [ - "/tests/corpus/native-class-property-order.cjs" - ], - "diags": [] - }, - "/tests/corpus/native-class-type-predicates.ts": { - "order": [ - "/tests/corpus/native-class-type-predicates.ts" - ], - "diags": [] - }, - "/tests/corpus/native-factory-records.js": { - "order": [ - "/tests/corpus/native-factory-records.js" - ], - "diags": [] - }, - "/tests/corpus/native-method-values.js": { - "order": [ - "/tests/corpus/native-method-values.js" - ], - "diags": [] - }, - "/tests/corpus/native-method-values.ts": { - "order": [ - "/tests/corpus/native-method-values.ts" - ], - "diags": [] - }, - "/tests/corpus/native-object-descriptors.js": { - "order": [ - "/tests/corpus/native-object-descriptors.js" - ], - "diags": [] - }, - "/tests/corpus/native-object-for-in-minimal.js": { - "order": [ - "/tests/corpus/native-object-for-in-minimal.js" - ], - "diags": [] - }, - "/tests/corpus/native-object-property-attributes.js": { - "order": [ - "/tests/corpus/native-object-property-attributes.js" - ], - "diags": [] - }, - "/tests/corpus/native-object-prototype.js": { - "order": [ - "/tests/corpus/native-object-prototype.js" - ], - "diags": [] - }, - "/tests/corpus/native-property-names.ts": { - "order": [ - "/tests/corpus/native-property-names.ts" - ], - "diags": [] - }, - "/tests/corpus/native-proxy-env.js": { - "order": [ - "/tests/corpus/native-proxy-env.js" - ], - "diags": [] - }, - "/tests/corpus/nested-map-cycles.ts": { - "order": [ - "/tests/corpus/nested-map-cycles.ts" - ], - "diags": [] - }, - "/tests/corpus/nested-map-values.ts": { - "order": [ - "/tests/corpus/nested-map-values.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-crypto-kdf-errors.ts": { - "order": [ - "/tests/corpus/node24-crypto-kdf-errors.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-crypto-kdf-options.ts": { - "order": [ - "/tests/corpus/node24-crypto-kdf-options.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-crypto-kdf.ts": { - "order": [ - "/tests/corpus/node24-crypto-kdf.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-crypto-sha2.ts": { - "order": [ - "/tests/corpus/node24-crypto-sha2.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-deep-equality-properties.js": { - "order": [ - "/tests/corpus/node24-deep-equality-properties.js" - ], - "diags": [] - }, - "/tests/corpus/node24-deep-equality.cjs": { - "order": [ - "/tests/corpus/node24-deep-equality.cjs" - ], - "diags": [] - }, - "/tests/corpus/node24-deep-equality.ts": { - "order": [ - "/tests/corpus/node24-deep-equality.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-links-callbacks.cjs": { - "order": [ - "/tests/corpus/node24-fs-links-callbacks.cjs" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-links-errors.cjs": { - "order": [ - "/tests/corpus/node24-fs-links-errors.cjs" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-links-options.cjs": { - "order": [ - "/tests/corpus/node24-fs-links-options.cjs" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-links-promise-errors.cjs": { - "order": [ - "/tests/corpus/node24-fs-links-promise-errors.cjs" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-links-promises.ts": { - "order": [ - "/tests/corpus/node24-fs-links-promises.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-links.ts": { - "order": [ - "/tests/corpus/node24-fs-links.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-statfs-callbacks.cjs": { - "order": [ - "/tests/corpus/node24-fs-statfs-callbacks.cjs" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-statfs-errors.cjs": { - "order": [ - "/tests/corpus/node24-fs-statfs-errors.cjs" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-statfs-options.cjs": { - "order": [ - "/tests/corpus/node24-fs-statfs-options.cjs" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-statfs.ts": { - "order": [ - "/tests/corpus/node24-fs-statfs.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-timestamps-callbacks.cjs": { - "order": [ - "/tests/corpus/node24-fs-timestamps-callbacks.cjs" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-timestamps-errors.cjs": { - "order": [ - "/tests/corpus/node24-fs-timestamps-errors.cjs" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-timestamps-promises.ts": { - "order": [ - "/tests/corpus/node24-fs-timestamps-promises.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-timestamps-symlinks.ts": { - "order": [ - "/tests/corpus/node24-fs-timestamps-symlinks.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-fs-timestamps.ts": { - "order": [ - "/tests/corpus/node24-fs-timestamps.ts" - ], - "diags": [] - }, - "/tests/corpus/nullable-object-extension.mjs": { - "order": [ - "/tests/corpus/nullable-object-extension.mjs" - ], - "diags": [] - }, - "/tests/corpus/nullish-assignment-values.ts": { - "order": [ - "/tests/corpus/nullish-assignment-values.ts" - ], - "diags": [] - }, - "/tests/corpus/nullish-long-chain.ts": { - "order": [ - "/tests/corpus/nullish-long-chain.ts" - ], - "diags": [] - }, - "/tests/corpus/number-predicates-unknown.ts": { - "order": [ - "/tests/corpus/number-predicates-unknown.ts" - ], - "diags": [] - }, - "/tests/corpus/object-enumeration-array-reads.ts": { - "order": [ - "/tests/corpus/object-enumeration-array-reads.ts" - ], - "diags": [] - }, - "/tests/corpus/object-from-checked-entries.js": { - "order": [ - "/tests/corpus/object-from-checked-entries.js" - ], - "diags": [] - }, - "/tests/corpus/object-inherited-to-string.js": { - "order": [ - "/tests/corpus/object-inherited-to-string.js" - ], - "diags": [] - }, - "/tests/corpus/object-prototype-identity.mjs": { - "order": [ - "/tests/corpus/object-prototype-identity.mjs" - ], - "diags": [] - }, - "/tests/corpus/object-reexport/main.js": { - "order": [ - "/tests/corpus/object-reexport/core.js", - "/tests/corpus/object-reexport/barrel.js", - "/tests/corpus/object-reexport/consumer.js", - "/tests/corpus/object-reexport/main.js" - ], - "diags": [] - }, - "/tests/corpus/object-spread-computed.ts": { - "order": [ - "/tests/corpus/object-spread-computed.ts" - ], - "diags": [] - }, - "/tests/corpus/opentui-byte-queue.js": { - "order": [ - "/tests/corpus/opentui-byte-queue.js" - ], - "diags": [] - }, - "/tests/corpus/optional-callback-arity.ts": { - "order": [ - "/tests/corpus/optional-callback-arity.ts" - ], - "diags": [] - }, - "/tests/corpus/optional-class-flows.ts": { - "order": [ - "/tests/corpus/optional-class-flows.ts" - ], - "diags": [] - }, - "/tests/corpus/optional-native-callables.js": { - "order": [ - "/tests/corpus/optional-native-callables.js" - ], - "diags": [] - }, - "/tests/corpus/optional-node-list-iteration.ts": { - "order": [ - "/tests/corpus/optional-node-list-iteration.ts" - ], - "diags": [] - }, - "/tests/corpus/optional-string-index/main.ts": { - "order": [ - "/tests/corpus/optional-string-index/main.ts" - ], - "diags": [] - }, - "/tests/corpus/path-to-file-url-options.ts": { - "order": [ - "/tests/corpus/path-to-file-url-options.ts" - ], - "diags": [] - }, - "/tests/corpus/performance-presence.ts": { - "order": [ - "/tests/corpus/performance-presence.ts" - ], - "diags": [] - }, - "/tests/corpus/primitive-and-function-descriptors.js": { - "order": [ - "/tests/corpus/primitive-and-function-descriptors.js" - ], - "diags": [] - }, - "/tests/corpus/primitive-union-string.ts": { - "order": [ - "/tests/corpus/primitive-union-string.ts" - ], - "diags": [] - }, - "/tests/corpus/process-builtin-values.js": { - "order": [ - "/tests/corpus/process-builtin-values.js" - ], - "diags": [] - }, - "/tests/corpus/process-env-computed-keys.js": { - "order": [ - "/tests/corpus/process-env-computed-keys.js" - ], - "diags": [] - }, - "/tests/corpus/process-hrtime.js": { - "order": [ - "/tests/corpus/process-hrtime.js" - ], - "diags": [] - }, - "/tests/corpus/process-named-signals.cjs": { - "order": [ - "/tests/corpus/process-named-signals.cjs" - ], - "diags": [] - }, - "/tests/corpus/process-uncaught-handler-throws.cjs": { - "order": [ - "/tests/corpus/process-uncaught-handler-throws.cjs" - ], - "diags": [] - }, - "/tests/corpus/process-uncaught-loop.cjs": { - "order": [ - "/tests/corpus/process-uncaught-loop.cjs" - ], - "diags": [] - }, - "/tests/corpus/process-uncaught-module.mjs": { - "order": [ - "/tests/corpus/process-uncaught-module.mjs" - ], - "diags": [] - }, - "/tests/corpus/process-uncaught-monitor.cjs": { - "order": [ - "/tests/corpus/process-uncaught-monitor.cjs" - ], - "diags": [] - }, - "/tests/corpus/process-uncaught-rejection.cjs": { - "order": [ - "/tests/corpus/process-uncaught-rejection.cjs" - ], - "diags": [] - }, - "/tests/corpus/process-uncaught-sync.cjs": { - "order": [ - "/tests/corpus/process-uncaught-sync.cjs" - ], - "diags": [] - }, - "/tests/corpus/process-versions-storage.ts": { - "order": [ - "/tests/corpus/process-versions-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/promise-checked-rejections.ts": { - "order": [ - "/tests/corpus/promise-checked-rejections.ts" - ], - "diags": [] - }, - "/tests/corpus/promise-resolve-void.ts": { - "order": [ - "/tests/corpus/promise-resolve-void.ts" - ], - "diags": [] - }, - "/tests/corpus/prototype-method-overrides.mjs": { - "order": [ - "/tests/corpus/prototype-method-overrides.mjs" - ], - "diags": [] - }, - "/tests/corpus/prototype-named-data-records.ts": { - "order": [ - "/tests/corpus/prototype-named-data-records.ts" - ], - "diags": [] - }, - "/tests/corpus/record-optional-json-presence.ts": { - "order": [ - "/tests/corpus/record-optional-json-presence.ts" - ], - "diags": [] - }, - "/tests/corpus/record-unknown-values.ts": { - "order": [ - "/tests/corpus/record-unknown-values.ts" - ], - "diags": [] - }, - "/tests/corpus/reflect-own-keys.mjs": { - "order": [ - "/tests/corpus/reflect-own-keys.mjs" - ], - "diags": [] - }, - "/tests/corpus/reflect-record-union-keys.mjs": { - "order": [ - "/tests/corpus/reflect-record-union-keys.mjs" - ], - "diags": [] - }, - "/tests/corpus/reflect-typed-record-keys.ts": { - "order": [ - "/tests/corpus/reflect-typed-record-keys.ts" - ], - "diags": [] - }, - "/tests/corpus/regex-checked-casts.ts": { - "order": [ - "/tests/corpus/regex-checked-casts.ts" - ], - "diags": [] - }, - "/tests/corpus/regex-checked-storage.js": { - "order": [ - "/tests/corpus/regex-checked-storage.js" - ], - "diags": [] - }, - "/tests/corpus/regex-optional-captures.ts": { - "order": [ - "/tests/corpus/regex-optional-captures.ts" - ], - "diags": [] - }, - "/tests/corpus/regex-optional-templates.ts": { - "order": [ - "/tests/corpus/regex-optional-templates.ts" - ], - "diags": [] - }, - "/tests/corpus/regex-split-captures.ts": { - "order": [ - "/tests/corpus/regex-split-captures.ts" - ], - "diags": [] - }, - "/tests/corpus/regexp-optional-constructor.ts": { - "order": [ - "/tests/corpus/regexp-optional-constructor.ts" - ], - "diags": [] - }, - "/tests/corpus/regexp-string-coercion.js": { - "order": [ - "/tests/corpus/regexp-string-coercion.js" - ], - "diags": [] - }, - "/tests/corpus/renderer-export-dictionaries.js": { - "order": [ - "/tests/corpus/renderer-export-dictionaries.js" - ], - "diags": [] - }, - "/tests/corpus/renderer-null-state.js": { - "order": [ - "/tests/corpus/renderer-null-state.js" - ], - "diags": [] - }, - "/tests/corpus/renderer-specializations.js": { - "order": [ - "/tests/corpus/renderer-specializations.js" - ], - "diags": [] - }, - "/tests/corpus/rest-optional-array-arguments.ts": { - "order": [ - "/tests/corpus/rest-optional-array-arguments.ts" - ], - "diags": [] - }, - "/tests/corpus/rest-optional-elements.ts": { - "order": [ - "/tests/corpus/rest-optional-elements.ts" - ], - "diags": [] - }, - "/tests/corpus/return-void-through-finally.ts": { - "order": [ - "/tests/corpus/return-void-through-finally.ts" - ], - "diags": [] - }, - "/tests/corpus/set-checked-methods.js": { - "order": [ - "/tests/corpus/set-checked-methods.js" - ], - "diags": [] - }, - "/tests/corpus/set-checked-storage.ts": { - "order": [ - "/tests/corpus/set-checked-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/set-iterator-seed-references.ts": { - "order": [ - "/tests/corpus/set-iterator-seed-references.ts" - ], - "diags": [] - }, - "/tests/corpus/set-iterator-seeds.ts": { - "order": [ - "/tests/corpus/set-iterator-seeds.ts" - ], - "diags": [] - }, - "/tests/corpus/set-optional-seeds.ts": { - "order": [ - "/tests/corpus/set-optional-seeds.ts" - ], - "diags": [] - }, - "/tests/corpus/static-field-updates/main.ts": { - "order": [ - "/tests/corpus/static-field-updates/counter.ts", - "/tests/corpus/static-field-updates/main.ts" - ], - "diags": [] - }, - "/tests/corpus/static-method-receivers.ts": { - "order": [ - "/tests/corpus/static-method-receivers.ts" - ], - "diags": [] - }, - "/tests/corpus/stdio-values.mjs": { - "order": [ - "/tests/corpus/stdio-values.mjs" - ], - "diags": [] - }, - "/tests/corpus/stdio-write-errors.mjs": { - "order": [ - "/tests/corpus/stdio-write-errors.mjs" - ], - "diags": [] - }, - "/tests/corpus/stdio-write-overrides.mjs": { - "order": [ - "/tests/corpus/stdio-write-overrides.mjs" - ], - "diags": [] - }, - "/tests/corpus/stored-native-builtins.js": { - "order": [ - "/tests/corpus/stored-native-builtins.js" - ], - "diags": [] - }, - "/tests/corpus/stored-object-helpers.js": { - "order": [ - "/tests/corpus/stored-object-helpers.js" - ], - "diags": [] - }, - "/tests/corpus/string-code-points.ts": { - "order": [ - "/tests/corpus/string-code-points.ts" - ], - "diags": [] - }, - "/tests/corpus/string-concat-number-parts.ts": { - "order": [ - "/tests/corpus/string-concat-number-parts.ts" - ], - "diags": [] - }, - "/tests/corpus/string-normalize.ts": { - "order": [ - "/tests/corpus/string-normalize.ts" - ], - "diags": [] - }, - "/tests/corpus/string-pattern-replacement.ts": { - "order": [ - "/tests/corpus/string-pattern-replacement.ts" - ], - "diags": [] - }, - "/tests/corpus/string-split-checked-separator.mjs": { - "order": [ - "/tests/corpus/string-split-checked-separator.mjs" - ], - "diags": [] - }, - "/tests/corpus/string-split-traversal.ts": { - "order": [ - "/tests/corpus/string-split-traversal.ts" - ], - "diags": [] - }, - "/tests/corpus/structural-class-properties.ts": { - "order": [ - "/tests/corpus/structural-class-properties.ts" - ], - "diags": [] - }, - "/tests/corpus/symbol-checked-boundary/main.ts": { - "order": [ - "/tests/corpus/symbol-checked-boundary/consumer.js", - "/tests/corpus/symbol-checked-boundary/main.ts" - ], - "diags": [] - }, - "/tests/corpus/symbol-class-fields.ts": { - "order": [ - "/tests/corpus/symbol-class-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/symbol-class-fields/main.cjs": { - "order": [ - "/tests/corpus/symbol-class-fields/counter.cjs", - "/tests/corpus/symbol-class-fields/main.cjs" - ], - "diags": [] - }, - "/tests/corpus/symbol-class-methods/main.ts": { - "order": [ - "/tests/corpus/symbol-class-methods/keys.ts", - "/tests/corpus/symbol-class-methods/main.ts" - ], - "diags": [] - }, - "/tests/corpus/symbol-fields-deferred-factory.ts": { - "order": [ - "/tests/corpus/symbol-fields-deferred-factory.ts" - ], - "diags": [] - }, - "/tests/corpus/symbol-fields-inferred.js": { - "order": [ - "/tests/corpus/symbol-fields-inferred.js" - ], - "diags": [] - }, - "/tests/corpus/symbol-object-properties/main.js": { - "order": [ - "/tests/corpus/symbol-object-properties/main.js" - ], - "diags": [] - }, - "/tests/corpus/synchronous-callback-lifetimes.ts": { - "order": [ - "/tests/corpus/synchronous-callback-lifetimes.ts" - ], - "diags": [] - }, - "/tests/corpus/text-codec-values/main.ts": { - "order": [ - "/tests/corpus/text-codec-values/shared.ts", - "/tests/corpus/text-codec-values/user.ts", - "/tests/corpus/text-codec-values/main.ts" - ], - "diags": [] - }, - "/tests/corpus/text-codec-var.ts": { - "order": [ - "/tests/corpus/text-codec-var.ts" - ], - "diags": [] - }, - "/tests/corpus/tuple-and-string-search.ts": { - "order": [ - "/tests/corpus/tuple-and-string-search.ts" - ], - "diags": [] - }, - "/tests/corpus/tuple-array-union.ts": { - "order": [ - "/tests/corpus/tuple-array-union.ts" - ], - "diags": [] - }, - "/tests/corpus/tuple-callback-visitation.ts": { - "order": [ - "/tests/corpus/tuple-callback-visitation.ts" - ], - "diags": [] - }, - "/tests/corpus/tuple-forof-visitation.ts": { - "order": [ - "/tests/corpus/tuple-forof-visitation.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-array-byte-io.js": { - "order": [ - "/tests/corpus/typed-array-byte-io.js" - ], - "diags": [] - }, - "/tests/corpus/typed-array-checked-index.js": { - "order": [ - "/tests/corpus/typed-array-checked-index.js" - ], - "diags": [] - }, - "/tests/corpus/typed-array-constructor-alias.ts": { - "order": [ - "/tests/corpus/typed-array-constructor-alias.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-array-constructor-identity.js": { - "order": [ - "/tests/corpus/typed-array-constructor-identity.js" - ], - "diags": [] - }, - "/tests/corpus/typed-array-constructor-union.ts": { - "order": [ - "/tests/corpus/typed-array-constructor-union.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-array-constructor-values.mjs": { - "order": [ - "/tests/corpus/typed-array-constructor-values.mjs" - ], - "diags": [] - }, - "/tests/corpus/typed-array-dynamic-methods.js": { - "order": [ - "/tests/corpus/typed-array-dynamic-methods.js" - ], - "diags": [] - }, - "/tests/corpus/typed-array-integer-widths.ts": { - "order": [ - "/tests/corpus/typed-array-integer-widths.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-array-unknown.ts": { - "order": [ - "/tests/corpus/typed-array-unknown.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-collection-iterator-references.ts": { - "order": [ - "/tests/corpus/typed-collection-iterator-references.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-collection-iterators.ts": { - "order": [ - "/tests/corpus/typed-collection-iterators.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-collection-views/main.ts": { - "order": [ - "/tests/corpus/typed-collection-views/use.mjs", - "/tests/corpus/typed-collection-views/main.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-prototype-methods.ts": { - "order": [ - "/tests/corpus/typed-prototype-methods.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-rest-callables.ts": { - "order": [ - "/tests/corpus/typed-rest-callables.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-rest-filtered-return.ts": { - "order": [ - "/tests/corpus/typed-rest-filtered-return.ts" - ], - "diags": [] - }, - "/tests/corpus/typedarray-native-inputs.js": { - "order": [ - "/tests/corpus/typedarray-native-inputs.js" - ], - "diags": [] - }, - "/tests/corpus/typeof-checked-comparison.js": { - "order": [ - "/tests/corpus/typeof-checked-comparison.js" - ], - "diags": [] - }, - "/tests/corpus/unicode-process-argv.ts": { - "order": [ - "/tests/corpus/unicode-process-argv.ts" - ], - "diags": [] - }, - "/tests/corpus/union-discriminant-width.ts": { - "order": [ - "/tests/corpus/union-discriminant-width.ts" - ], - "diags": [] - }, - "/tests/corpus/union-literal-scalar-discriminants.ts": { - "order": [ - "/tests/corpus/union-literal-scalar-discriminants.ts" - ], - "diags": [] - }, - "/tests/corpus/union-literal-slot-conversion.ts": { - "order": [ - "/tests/corpus/union-literal-slot-conversion.ts" - ], - "diags": [] - }, - "/tests/corpus/union-nested-layout-discriminant.ts": { - "order": [ - "/tests/corpus/union-nested-layout-discriminant.ts" - ], - "diags": [] - }, - "/tests/corpus/union-optional-semantic-identity.ts": { - "order": [ - "/tests/corpus/union-optional-semantic-identity.ts" - ], - "diags": [] - }, - "/tests/corpus/union-record-clone.ts": { - "order": [ - "/tests/corpus/union-record-clone.ts" - ], - "diags": [] - }, - "/tests/corpus/union-record-structural-copy.ts": { - "order": [ - "/tests/corpus/union-record-structural-copy.ts" - ], - "diags": [] - }, - "/tests/corpus/unknown-array-holes.ts": { - "order": [ - "/tests/corpus/unknown-array-holes.ts" - ], - "diags": [] - }, - "/tests/corpus/unknown-collections.ts": { - "order": [ - "/tests/corpus/unknown-collections.ts" - ], - "diags": [] - }, - "/tests/corpus/unknown-object-enumeration.ts": { - "order": [ - "/tests/corpus/unknown-object-enumeration.ts" - ], - "diags": [] - }, - "/tests/corpus/unknown-record-views.ts": { - "order": [ - "/tests/corpus/unknown-record-views.ts" - ], - "diags": [] - }, - "/tests/corpus/url-runtime-base.ts": { - "order": [ - "/tests/corpus/url-runtime-base.ts" - ], - "diags": [] - }, - "/tests/corpus/util-parseargs-wrapped/main.ts": { - "order": [ - "/tests/corpus/util-parseargs-wrapped/main.ts" - ], - "diags": [] - }, - "/tests/corpus/weak-map-array-buffer.ts": { - "order": [ - "/tests/corpus/weak-map-array-buffer.ts" - ], - "diags": [] - }, - "/tests/corpus/weak-map-fresh-array.js": { - "order": [ - "/tests/corpus/weak-map-fresh-array.js" - ], - "diags": [] - }, - "/tests/corpus/weak-map-native.js": { - "order": [ - "/tests/corpus/weak-map-native.js" - ], - "diags": [] - }, - "/tests/corpus/weak-native-class-identity.ts": { - "order": [ - "/tests/corpus/weak-native-class-identity.ts" - ], - "diags": [] - }, - "/tests/corpus/weak-set-native.js": { - "order": [ - "/tests/corpus/weak-set-native.js" - ], - "diags": [] - }, - "/tests/diagnostics/accessors.ts": { - "order": [ - "/tests/diagnostics/accessors.ts" - ], - "diags": [] - }, - "/tests/diagnostics/any-unit-exit.ts": { - "order": [ - "/tests/diagnostics/any-unit-exit.ts" - ], - "diags": [] - }, - "/tests/diagnostics/any.ts": { - "order": [ - "/tests/diagnostics/any.ts" - ], - "diags": [] - }, - "/tests/diagnostics/arrow-bind.ts": { - "order": [ - "/tests/diagnostics/arrow-bind.ts" - ], - "diags": [] - }, - "/tests/diagnostics/assert-fences.ts": { - "order": [ - "/tests/diagnostics/assert-fences.ts" - ], - "diags": [] - }, - "/tests/diagnostics/async-iterator-handles.ts": { - "order": [ - "/tests/diagnostics/async-iterator-handles.ts" - ], - "diags": [] - }, - "/tests/diagnostics/bigint-fences.ts": { - "order": [ - "/tests/diagnostics/bigint-fences.ts" - ], - "diags": [ - { - "code": "SC0001", - "message": "Expected 1 arguments, but got 2.", - "loc": { - "file": "/tests/diagnostics/bigint-fences.ts", - "start": 439, - "end": 455 - } - } - ] - }, - "/tests/diagnostics/blocked-binding-cascade.ts": { - "order": [ - "/tests/diagnostics/blocked-binding-cascade.ts" - ], - "diags": [] - }, - "/tests/diagnostics/catch-bindings.ts": { - "order": [ - "/tests/diagnostics/catch-bindings.ts" - ], - "diags": [] - }, - "/tests/diagnostics/checker-panic-infinity.ts": { - "order": [ - "/tests/diagnostics/checker-panic-infinity.ts" - ], - "diags": [] - }, - "/tests/diagnostics/checker-panic-tuple.ts": { - "order": [ - "/tests/diagnostics/checker-panic-tuple.ts" - ], - "diags": [] - }, - "/tests/diagnostics/child-process.ts": { - "order": [ - "/tests/diagnostics/child-process.ts" - ], - "diags": [] - }, - "/tests/diagnostics/cjs-esm-lexer-require-reached/main.js": { - "order": [ - "/tests/diagnostics/cjs-esm-lexer-require-reached/table.cjs", - "/tests/diagnostics/cjs-esm-lexer-require-reached/mid.mjs", - "/tests/diagnostics/cjs-esm-lexer-require-reached/main.js" - ], - "diags": [ - { - "code": "SC1013", - "message": "a named import of a CommonJS export Node's lexer cannot detect, reached through require() of an ES module (Node throws its SyntaxError mid-evaluation at that require; import the CommonJS module's default and read members off it instead) is not supported yet", - "loc": { - "file": "/tests/diagnostics/cjs-esm-lexer-require-reached/mid.mjs", - "start": 9, - "end": 10 - }, - "milestone": "later" - } - ] - }, - "/tests/diagnostics/cjs-module-mutation/main.ts": { - "order": [ - "/tests/diagnostics/cjs-module-mutation/main.ts" - ], - "diags": [] - }, - "/tests/diagnostics/cjs-require-cycle/main.js": { - "order": [ - "/tests/diagnostics/cjs-require-cycle/b.js", - "/tests/diagnostics/cjs-require-cycle/a.js", - "/tests/diagnostics/cjs-require-cycle/main.js" - ], - "diags": [ - { - "code": "SC1016", - "message": "circular imports (/tests/diagnostics/cjs-require-cycle/a.js → /tests/diagnostics/cjs-require-cycle/b.js → /tests/diagnostics/cjs-require-cycle/a.js; the cycle closes through a require() edge) are not supported yet", - "loc": { - "file": "/tests/diagnostics/cjs-require-cycle/a.js", - "start": 0, - "end": 0 - }, - "milestone": "later", - "hint": "ES-module cycles of let/const/function bindings compile as-is; rewrite the named construct (a named import instead of a namespace, a const instead of a default-export expression or var, a class declared before the code that can reach it) or break the named edge" - } - ] - }, - "/tests/diagnostics/cjs-require-esm-type-link/main.js": { - "order": [ - "/tests/diagnostics/cjs-require-esm-type-link/types.mts", - "/tests/diagnostics/cjs-require-esm-type-link/child.mts", - "/tests/diagnostics/cjs-require-esm-type-link/main.js" - ], - "diags": [ - { - "code": "SC1013", - "message": "a named import of an unavailable export in an ES module reached through require() (Node throws its SyntaxError mid-evaluation at that require; make the import match the module's runtime exports) is not supported yet", - "loc": { - "file": "/tests/diagnostics/cjs-require-esm-type-link/child.mts", - "start": 9, - "end": 14 - }, - "milestone": "later" - } - ] - }, - "/tests/diagnostics/cjs-require-tdz/main.js": { - "order": [ - "/tests/diagnostics/cjs-require-tdz/main.js" - ], - "diags": [ - { - "code": "SC1013", - "message": "require() below code that can reach its binding 'greet' (Node initializes the binding AT the require and throws ReferenceError on any earlier access, which is not modeled — move the require above the code that can run first) is not supported yet", - "loc": { - "file": "/tests/diagnostics/cjs-require-tdz/main.js", - "start": 336, - "end": 367 - }, - "milestone": "later" - } - ] - }, - "/tests/diagnostics/class-decorators.ts": { - "order": [ - "/tests/diagnostics/class-decorators.ts" - ], - "diags": [] - }, - "/tests/diagnostics/class-interface-refinements.ts": { - "order": [ - "/tests/diagnostics/class-interface-refinements.ts" - ], - "diags": [] - }, - "/tests/diagnostics/class-prototype-reflection.ts": { - "order": [ - "/tests/diagnostics/class-prototype-reflection.ts" - ], - "diags": [] - }, - "/tests/diagnostics/class-values.ts": { - "order": [ - "/tests/diagnostics/class-values.ts" - ], - "diags": [] - }, - "/tests/diagnostics/collection-iterator-helpers.ts": { - "order": [ - "/tests/diagnostics/collection-iterator-helpers.ts" - ], - "diags": [] - }, - "/tests/diagnostics/collection-views.ts": { - "order": [ - "/tests/diagnostics/collection-views.ts" - ], - "diags": [] - }, - "/tests/diagnostics/component-fences.ts": { - "order": [ - "/tests/diagnostics/component-fences.ts" - ], - "diags": [] - }, - "/tests/diagnostics/comptime.ts": { - "order": [ - "/tests/diagnostics/comptime.ts" - ], - "diags": [] - }, - "/tests/diagnostics/create-require.ts": { - "order": [ - "/tests/diagnostics/create-require.ts" - ], - "diags": [] - }, - "/tests/diagnostics/dataview.ts": { - "order": [ - "/tests/diagnostics/dataview.ts" - ], - "diags": [] - }, - "/tests/diagnostics/date-formatters.ts": { - "order": [ - "/tests/diagnostics/date-formatters.ts" - ], - "diags": [] - }, - "/tests/diagnostics/date-union-fences.ts": { - "order": [ - "/tests/diagnostics/date-union-fences.ts" - ], - "diags": [] - }, - "/tests/diagnostics/deep-binary-nesting.ts": { - "order": [ - "/tests/diagnostics/deep-binary-nesting.ts" - ], - "diags": [] - }, - "/tests/diagnostics/deep-nesting-preflight.ts": { - "order": [ - "/tests/diagnostics/deep-nesting-preflight.ts" - ], - "diags": [] - }, - "/tests/diagnostics/default-export.ts": { - "order": [ - "/tests/diagnostics/default-export.ts" - ], - "diags": [ - { - "code": "SC0001", - "message": "Export assignment cannot be used when targeting ECMAScript modules. Consider using 'export default' or another module format instead.", - "loc": { - "file": "/tests/diagnostics/default-export.ts", - "start": 439, - "end": 456 - } - }, - { - "code": "SC1012", - "message": "export = assignments are not supported yet", - "loc": { - "file": "/tests/diagnostics/default-export.ts", - "start": 439, - "end": 456 - }, - "milestone": "later", - "hint": "use named exports: export function f() {} / import { f } from \"./m\"" - } - ] - }, - "/tests/diagnostics/delete-fences.ts": { - "order": [ - "/tests/diagnostics/delete-fences.ts" - ], - "diags": [] - }, - "/tests/diagnostics/destructuring-fences.ts": { - "order": [ - "/tests/diagnostics/destructuring-fences.ts" - ], - "diags": [] - }, - "/tests/diagnostics/dynamic-import-static.ts": { - "order": [ - "/tests/diagnostics/dynamic-import-static.ts" - ], - "diags": [] - }, - "/tests/diagnostics/dynamic-import/main.ts": { - "order": [ - "/tests/diagnostics/dynamic-import/helper.ts", - "/tests/diagnostics/dynamic-import/main.ts" - ], - "diags": [] - }, - "/tests/diagnostics/dynamic-representable-types.ts": { - "order": [ - "/tests/diagnostics/dynamic-representable-types.ts" - ], - "diags": [] - }, - "/tests/diagnostics/dynamic-surface.ts": { - "order": [ - "/tests/diagnostics/dynamic-surface.ts" - ], - "diags": [] - }, - "/tests/diagnostics/ee-computed-internal.ts": { - "order": [ - "/tests/diagnostics/ee-computed-internal.ts" - ], - "diags": [] - }, - "/tests/diagnostics/ee-computed-listeners.ts": { - "order": [ - "/tests/diagnostics/ee-computed-listeners.ts" - ], - "diags": [] - }, - "/tests/diagnostics/ee-computed-stream-internal.ts": { - "order": [ - "/tests/diagnostics/ee-computed-stream-internal.ts" - ], - "diags": [] - }, - "/tests/diagnostics/ee-computed-unrestricted.ts": { - "order": [ - "/tests/diagnostics/ee-computed-unrestricted.ts" - ], - "diags": [] - }, - "/tests/diagnostics/ee-emit-override.ts": { - "order": [ - "/tests/diagnostics/ee-emit-override.ts" - ], - "diags": [] - }, - "/tests/diagnostics/enums.ts": { - "order": [ - "/tests/diagnostics/enums.ts" - ], - "diags": [] - }, - "/tests/diagnostics/es2025-fences.ts": { - "order": [ - "/tests/diagnostics/es2025-fences.ts" - ], - "diags": [] - }, - "/tests/diagnostics/esm-syntax-commonjs/main.js": { - "order": [ - "/tests/diagnostics/esm-syntax-commonjs/main.js" - ], - "diags": [ - { - "code": "SC1013", - "message": "Node classifies this file as CommonJS, where this ES-module syntax marker is a SyntaxError", - "loc": { - "file": "/tests/diagnostics/esm-syntax-commonjs/main.js", - "start": 0, - "end": 10 - }, - "milestone": "later", - "hint": "use a .mjs/.mts extension or set the nearest package.json's \"type\" to \"module\"" - } - ] - }, - "/tests/diagnostics/exceptions.ts": { - "order": [ - "/tests/diagnostics/exceptions.ts" - ], - "diags": [] - }, - "/tests/diagnostics/fetch-static.ts": { - "order": [ - "/tests/diagnostics/fetch-static.ts" - ], - "diags": [] - }, - "/tests/diagnostics/filter-narrow.ts": { - "order": [ - "/tests/diagnostics/filter-narrow.ts" - ], - "diags": [] - }, - "/tests/diagnostics/filter-void-predicate-dyn.ts": { - "order": [ - "/tests/diagnostics/filter-void-predicate-dyn.ts" - ], - "diags": [] - }, - "/tests/diagnostics/filter-void-predicate-dynamic.ts": { - "order": [ - "/tests/diagnostics/filter-void-predicate-dynamic.ts" - ], - "diags": [] - }, - "/tests/diagnostics/filter-void-predicate-island.ts": { - "order": [ - "/tests/diagnostics/filter-void-predicate-island.ts" - ], - "diags": [] - }, - "/tests/diagnostics/filter-void-predicate.ts": { - "order": [ - "/tests/diagnostics/filter-void-predicate.ts" - ], - "diags": [] - }, - "/tests/diagnostics/function-forms.ts": { - "order": [ - "/tests/diagnostics/function-forms.ts" - ], - "diags": [] - }, - "/tests/diagnostics/function-limits.ts": { - "order": [ - "/tests/diagnostics/function-limits.ts" - ], - "diags": [] - }, - "/tests/diagnostics/generator-method-overrides.ts": { - "order": [ - "/tests/diagnostics/generator-method-overrides.ts" - ], - "diags": [] - }, - "/tests/diagnostics/generic-methods.ts": { - "order": [ - "/tests/diagnostics/generic-methods.ts" - ], - "diags": [] - }, - "/tests/diagnostics/generic-signature-values.ts": { - "order": [ - "/tests/diagnostics/generic-signature-values.ts" - ], - "diags": [] - }, - "/tests/diagnostics/generic-value-bindings.ts": { - "order": [ - "/tests/diagnostics/generic-value-bindings.ts" - ], - "diags": [] - }, - "/tests/diagnostics/generics.ts": { - "order": [ - "/tests/diagnostics/generics.ts" - ], - "diags": [] - }, - "/tests/diagnostics/http2-module.ts": { - "order": [ - "/tests/diagnostics/http2-module.ts" - ], - "diags": [] - }, - "/tests/diagnostics/http2-response-trailers.ts": { - "order": [ - "/tests/diagnostics/http2-response-trailers.ts" - ], - "diags": [] - }, - "/tests/diagnostics/identity-collection-keys.ts": { - "order": [ - "/tests/diagnostics/identity-collection-keys.ts" - ], - "diags": [] - }, - "/tests/diagnostics/import-defer-type/main.ts": { - "order": [ - "/tests/diagnostics/import-defer-type/main.ts" - ], - "diags": [ - { - "code": "SC0001", - "message": "'from' expected.", - "loc": { - "file": "/tests/diagnostics/import-defer-type/main.ts", - "start": 223, - "end": 224 - } - }, - { - "code": "SC0001", - "message": "';' expected.", - "loc": { - "file": "/tests/diagnostics/import-defer-type/main.ts", - "start": 228, - "end": 231 - } - }, - { - "code": "SC0001", - "message": "Unexpected keyword or identifier.", - "loc": { - "file": "/tests/diagnostics/import-defer-type/main.ts", - "start": 232, - "end": 236 - } - }, - { - "code": "SC0001", - "message": "String literal expected.", - "loc": { - "file": "/tests/diagnostics/import-defer-type/main.ts", - "start": 223, - "end": 227 - } - }, - { - "code": "SC0001", - "message": "Cannot find name 'ns1'.", - "loc": { - "file": "/tests/diagnostics/import-defer-type/main.ts", - "start": 228, - "end": 231 - } - }, - { - "code": "SC0001", - "message": "Cannot find name 'from'.", - "loc": { - "file": "/tests/diagnostics/import-defer-type/main.ts", - "start": 232, - "end": 236 - } - } - ] - }, - "/tests/diagnostics/import-defer/main.ts": { - "order": [ - "/tests/diagnostics/import-defer/main.ts" - ], - "diags": [] - }, - "/tests/diagnostics/import-equals-require.ts": { - "order": [ - "/tests/diagnostics/import-equals-require.ts" - ], - "diags": [ - { - "code": "SC0001", - "message": "Import assignment cannot be used when targeting ECMAScript modules. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"', 'import d from \"mod\"', or another module format instead.", - "loc": { - "file": "/tests/diagnostics/import-equals-require.ts", - "start": 178, - "end": 204 - } - }, - { - "code": "SC1013", - "message": "import = require(...) assignments are not supported yet", - "loc": { - "file": "/tests/diagnostics/import-equals-require.ts", - "start": 178, - "end": 204 - }, - "milestone": "later" - } - ] - }, - "/tests/diagnostics/import-forms/main.ts": { - "order": [ - "/tests/diagnostics/import-forms/helpers.ts", - "/tests/diagnostics/import-forms/legacy.cjs", - "/tests/diagnostics/import-forms/main.ts" - ], - "diags": [ - { - "code": "SC1012", - "message": "default exports/imports are not supported yet", - "loc": { - "file": "/tests/diagnostics/import-forms/main.ts", - "start": 517, - "end": 519 - }, - "milestone": "later", - "hint": "use named exports: export function f() {} / import { f } from \"./m\"" - }, - { - "code": "SC1013", - "message": "namespace imports of JSON modules are not supported yet", - "loc": { - "file": "/tests/diagnostics/import-forms/main.ts", - "start": 543, - "end": 551 - }, - "milestone": "later" - }, - { - "code": "SC1013", - "message": "namespace imports of CommonJS modules are not supported yet", - "loc": { - "file": "/tests/diagnostics/import-forms/main.ts", - "start": 578, - "end": 589 - }, - "milestone": "later" - }, - { - "code": "SC1014", - "message": "re-exports from packages or builtin modules are not supported yet", - "loc": { - "file": "/tests/diagnostics/import-forms/main.ts", - "start": 759, - "end": 794 - }, - "milestone": "later", - "hint": "export declarations directly: export function f() {}" - } - ] - }, - "/tests/diagnostics/import-meta-bare.ts": { - "order": [ - "/tests/diagnostics/import-meta-bare.ts" - ], - "diags": [] - }, - "/tests/diagnostics/import-meta-computed.ts": { - "order": [ - "/tests/diagnostics/import-meta-computed.ts" - ], - "diags": [] - }, - "/tests/diagnostics/import-meta-destructure.ts": { - "order": [ - "/tests/diagnostics/import-meta-destructure.ts" - ], - "diags": [] - }, - "/tests/diagnostics/import-meta-write.ts": { - "order": [ - "/tests/diagnostics/import-meta-write.ts" - ], - "diags": [] - }, - "/tests/diagnostics/imports.ts": { - "order": [ - "/tests/diagnostics/imports.ts" - ], - "diags": [ - { - "code": "SC0001", - "message": "Cannot find module 'some-package' or its corresponding type declarations.", - "loc": { - "file": "/tests/diagnostics/imports.ts", - "start": 26, - "end": 40 - } - }, - { - "code": "SC1010", - "message": "the 'some-package' package (nothing installed resolves it) is not supported yet", - "loc": { - "file": "/tests/diagnostics/imports.ts", - "start": 0, - "end": 41 - }, - "milestone": "M4", - "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" - } - ] - }, - "/tests/diagnostics/index-signature-values.ts": { - "order": [ - "/tests/diagnostics/index-signature-values.ts" - ], - "diags": [] - }, - "/tests/diagnostics/inheritance.ts": { - "order": [ - "/tests/diagnostics/inheritance.ts" - ], - "diags": [] - }, - "/tests/diagnostics/intersection-values.ts": { - "order": [ - "/tests/diagnostics/intersection-values.ts" - ], - "diags": [] - }, - "/tests/diagnostics/intl-segmenter.ts": { - "order": [ - "/tests/diagnostics/intl-segmenter.ts" - ], - "diags": [] - }, - "/tests/diagnostics/intl.ts": { - "order": [ - "/tests/diagnostics/intl.ts" - ], - "diags": [] - }, - "/tests/diagnostics/invalid-package-config/main.ts": { - "order": [ - "/tests/diagnostics/invalid-package-config/main.ts" - ], - "diags": [ - { - "code": "SC1013", - "message": "Node cannot load this module because '/tests/diagnostics/invalid-package-config/package.json' is an invalid package configuration (ERR_INVALID_PACKAGE_CONFIG)", - "loc": { - "file": "/tests/diagnostics/invalid-package-config/main.ts", - "start": 0, - "end": 0 - }, - "milestone": "later", - "hint": "fix the nearest package.json so it contains valid JSON" - } - ] - }, - "/tests/diagnostics/island-boundary-slots.ts": { - "order": [ - "/tests/diagnostics/island-boundary-slots.ts" - ], - "diags": [] - }, - "/tests/diagnostics/island.ts": { - "order": [ - "/tests/diagnostics/island.ts" - ], - "diags": [] - }, - "/tests/diagnostics/jsdoc-import-require.js": { - "order": [ - "/tests/diagnostics/jsdoc-import-require.js" - ], - "diags": [ - { - "code": "SC0001", - "message": "'from' expected.", - "loc": { - "file": "/tests/diagnostics/jsdoc-import-require.js", - "start": 14, - "end": 15 - } - }, - { - "code": "SC0001", - "message": "String literal expected.", - "loc": { - "file": "/tests/diagnostics/jsdoc-import-require.js", - "start": 14, - "end": 33 - } - } - ] - }, - "/tests/diagnostics/json-dyn.ts": { - "order": [ - "/tests/diagnostics/json-dyn.ts" - ], - "diags": [] - }, - "/tests/diagnostics/json-module-comment/main.ts": { - "order": [ - "/tests/diagnostics/json-module-comment/main.ts" - ], - "diags": [] - }, - "/tests/diagnostics/json-modules/main.ts": { - "order": [ - "/tests/diagnostics/json-modules/main.ts" - ], - "diags": [ - { - "code": "SC1012", - "message": "named imports from JSON modules are not supported yet", - "loc": { - "file": "/tests/diagnostics/json-modules/main.ts", - "start": 135, - "end": 146 - }, - "milestone": "later", - "hint": "use named exports: export function f() {} / import { f } from \"./m\"" - } - ] - }, - "/tests/diagnostics/json-shape/main.ts": { - "order": [ - "/tests/diagnostics/json-shape/main.ts" - ], - "diags": [] - }, - "/tests/diagnostics/local-class-boundaries.ts": { - "order": [ - "/tests/diagnostics/local-class-boundaries.ts" - ], - "diags": [] - }, - "/tests/diagnostics/local-require-binding-esm.js": { - "order": [ - "/tests/diagnostics/local-require-binding-esm.js" - ], - "diags": [ - { - "code": "SC1013", - "message": "calls through a source binding named 'require' (this spelling is reserved for CommonJS/createRequire module edges — rename the binding) is not supported yet", - "loc": { - "file": "/tests/diagnostics/local-require-binding-esm.js", - "start": 80, - "end": 100 - }, - "milestone": "later" - } - ] - }, - "/tests/diagnostics/maps-surface.ts": { - "order": [ - "/tests/diagnostics/maps-surface.ts" - ], - "diags": [] - }, - "/tests/diagnostics/maps.ts": { - "order": [ - "/tests/diagnostics/maps.ts" - ], - "diags": [] - }, - "/tests/diagnostics/merged-namespace-collect-probe.ts": { - "order": [ - "/tests/diagnostics/merged-namespace-collect-probe.ts" - ], - "diags": [] - }, - "/tests/diagnostics/mixed-compare.ts": { - "order": [ - "/tests/diagnostics/mixed-compare.ts" - ], - "diags": [ - { - "code": "SC0001", - "message": "This comparison appears to be unintentional because the types 'true' and 'false' have no overlap.", - "loc": { - "file": "/tests/diagnostics/mixed-compare.ts", - "start": 70, - "end": 84 - } - }, - { - "code": "SC0001", - "message": "Operator '<' cannot be applied to types 'string' and 'number'.", - "loc": { - "file": "/tests/diagnostics/mixed-compare.ts", - "start": 122, - "end": 127 - } - } - ] - }, - "/tests/diagnostics/mixins.ts": { - "order": [ - "/tests/diagnostics/mixins.ts" - ], - "diags": [] - }, - "/tests/diagnostics/module-out-of-scope.ts": { - "order": [ - "/tests/diagnostics/module-out-of-scope.ts" - ], - "diags": [ - { - "code": "SC0001", - "message": "Cannot find name 'node:v8'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.", - "loc": { - "file": "/tests/diagnostics/module-out-of-scope.ts", - "start": 381, - "end": 390 - } - }, - { - "code": "SC0001", - "message": "Cannot find name 'domain'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.", - "loc": { - "file": "/tests/diagnostics/module-out-of-scope.ts", - "start": 415, - "end": 423 - } - }, - { - "code": "SC0001", - "message": "Cannot find name 'node:sqlite'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.", - "loc": { - "file": "/tests/diagnostics/module-out-of-scope.ts", - "start": 454, - "end": 467 - } - }, - { - "code": "SC0001", - "message": "Cannot find module '_http_common' or its corresponding type declarations.", - "loc": { - "file": "/tests/diagnostics/module-out-of-scope.ts", - "start": 496, - "end": 510 - } - }, - { - "code": "SC0001", - "message": "Cannot find name 'node:inspector'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.", - "loc": { - "file": "/tests/diagnostics/module-out-of-scope.ts", - "start": 533, - "end": 549 - } - }, - { - "code": "SC0001", - "message": "Cannot find name 'node:stream/web'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.", - "loc": { - "file": "/tests/diagnostics/module-out-of-scope.ts", - "start": 582, - "end": 599 - } - }, - { - "code": "SC1010", - "message": "the 'node:v8' module (it observes V8 engine internals — heap statistics and snapshots, GC and CPU profiles, serialize/deserialize — and a compiled binary embeds no V8 engine to observe) is not supported yet", - "loc": { - "file": "/tests/diagnostics/module-out-of-scope.ts", - "start": 347, - "end": 391 - }, - "milestone": "M4", - "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" - }, - { - "code": "SC1010", - "message": "the 'domain' module (deprecated in Node and slated for removal; its implicit error interception hooks every async callback at engine level, which is not modeled) is not supported yet", - "loc": { - "file": "/tests/diagnostics/module-out-of-scope.ts", - "start": 392, - "end": 424 - }, - "milestone": "M4", - "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" - }, - { - "code": "SC1010", - "message": "the 'node:sqlite' module (it wraps the SQLite library bundled into the node executable, and scriptc binaries bundle no SQLite engine) is not supported yet", - "loc": { - "file": "/tests/diagnostics/module-out-of-scope.ts", - "start": 425, - "end": 468 - }, - "milestone": "M4", - "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" - }, - { - "code": "SC1010", - "message": "the '_http_common' module (a Node-internal module: it exposes Node's own implementation objects, which the scriptc runtime does not replicate) is not supported yet", - "loc": { - "file": "/tests/diagnostics/module-out-of-scope.ts", - "start": 469, - "end": 511 - }, - "milestone": "M4", - "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" - }, - { - "code": "SC1010", - "message": "the 'node:inspector' module (it drives the V8 inspector protocol — debugger, profiler, heap access — and a compiled binary embeds no V8 engine to inspect) is not supported yet", - "loc": { - "file": "/tests/diagnostics/module-out-of-scope.ts", - "start": 512, - "end": 550 - }, - "milestone": "M4", - "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" - }, - { - "code": "SC1010", - "message": "the 'node:stream/web' module is not supported yet", - "loc": { - "file": "/tests/diagnostics/module-out-of-scope.ts", - "start": 551, - "end": 600 - }, - "milestone": "M4", - "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" - } - ] - }, - "/tests/diagnostics/module-resolution-introspection.ts": { - "order": [ - "/tests/diagnostics/module-resolution-introspection.ts" - ], - "diags": [] - }, - "/tests/diagnostics/multiple-errors.ts": { - "order": [ - "/tests/diagnostics/multiple-errors.ts" - ], - "diags": [] - }, - "/tests/diagnostics/namespaces.ts": { - "order": [ - "/tests/diagnostics/namespaces.ts" - ], - "diags": [] - }, - "/tests/diagnostics/new-target-field-initializer.ts": { - "order": [ - "/tests/diagnostics/new-target-field-initializer.ts" - ], - "diags": [] - }, - "/tests/diagnostics/node-fallback-fence.ts": { - "order": [ - "/tests/diagnostics/node-fallback-fence.ts" - ], - "diags": [] - }, - "/tests/diagnostics/npm-imports/main.ts": { - "order": [ - "/tests/diagnostics/npm-imports/main.ts" - ], - "diags": [] - }, - "/tests/diagnostics/ns-import-object/main.ts": { - "order": [ - "/tests/diagnostics/ns-import-object/lib.ts", - "/tests/diagnostics/ns-import-object/main.ts" - ], - "diags": [] - }, - "/tests/diagnostics/object-create-fences.ts": { - "order": [ - "/tests/diagnostics/object-create-fences.ts" - ], - "diags": [] - }, - "/tests/diagnostics/optional-fields.ts": { - "order": [ - "/tests/diagnostics/optional-fields.ts" - ], - "diags": [] - }, - "/tests/diagnostics/options-record.ts": { - "order": [ - "/tests/diagnostics/options-record.ts" - ], - "diags": [] - }, - "/tests/diagnostics/outside-world.ts": { - "order": [ - "/tests/diagnostics/outside-world.ts" - ], - "diags": [ - { - "code": "SC0001", - "message": "Cannot find name 'document'. Do you need to change your target library? Try changing the 'lib' compiler option to include 'dom'.", - "loc": { - "file": "/tests/diagnostics/outside-world.ts", - "start": 622, - "end": 630 - } - }, - { - "code": "SC0001", - "message": "Cannot find name 'WebSocket'.", - "loc": { - "file": "/tests/diagnostics/outside-world.ts", - "start": 647, - "end": 656 - } - } - ] - }, - "/tests/diagnostics/overload-fences.ts": { - "order": [ - "/tests/diagnostics/overload-fences.ts" - ], - "diags": [] - }, - "/tests/diagnostics/overloaded-function-values.ts": { - "order": [ - "/tests/diagnostics/overloaded-function-values.ts" - ], - "diags": [] - }, - "/tests/diagnostics/pkg-import-fences/main.ts": { - "order": [ - "/tests/diagnostics/pkg-import-fences/main.ts" - ], - "diags": [ - { - "code": "SC1010", - "message": "the '#types' import (it resolves only to type declarations — there is no runtime implementation to compile) is not supported yet", - "loc": { - "file": "/tests/diagnostics/pkg-import-fences/main.ts", - "start": 449, - "end": 476 - }, - "milestone": "M4", - "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" - }, - { - "code": "SC1010", - "message": "the 'ambientonly' module (it exists only as an ambient 'declare module' type surface — there is no runtime module to import) is not supported yet", - "loc": { - "file": "/tests/diagnostics/pkg-import-fences/main.ts", - "start": 383, - "end": 415 - }, - "milestone": "M4", - "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" - }, - { - "code": "SC1010", - "message": "the 'patternXmod' module (it exists only as an ambient 'declare module' type surface — there is no runtime module to import) is not supported yet", - "loc": { - "file": "/tests/diagnostics/pkg-import-fences/main.ts", - "start": 416, - "end": 448 - }, - "milestone": "M4", - "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" - } - ] - }, - "/tests/diagnostics/private-members.ts": { - "order": [ - "/tests/diagnostics/private-members.ts" - ], - "diags": [] - }, - "/tests/diagnostics/promise-all-fences.ts": { - "order": [ - "/tests/diagnostics/promise-all-fences.ts" - ], - "diags": [] - }, - "/tests/diagnostics/record-width.ts": { - "order": [ - "/tests/diagnostics/record-width.ts" - ], - "diags": [] - }, - "/tests/diagnostics/regex.ts": { - "order": [ - "/tests/diagnostics/regex.ts" - ], - "diags": [] - }, - "/tests/diagnostics/retained-generic-rest-order.ts": { - "order": [ - "/tests/diagnostics/retained-generic-rest-order.ts" - ], - "diags": [] - }, - "/tests/diagnostics/runtime-optional-capture-chain.ts": { - "order": [ - "/tests/diagnostics/runtime-optional-capture-chain.ts" - ], - "diags": [] - }, - "/tests/diagnostics/runtime-optional-refined-union.ts": { - "order": [ - "/tests/diagnostics/runtime-optional-refined-union.ts" - ], - "diags": [] - }, - "/tests/diagnostics/self-returning-function.ts": { - "order": [ - "/tests/diagnostics/self-returning-function.ts" - ], - "diags": [] - }, - "/tests/diagnostics/sets.ts": { - "order": [ - "/tests/diagnostics/sets.ts" - ], - "diags": [] - }, - "/tests/diagnostics/spi-off/main.ts": { - "order": [ - "/tests/diagnostics/spi-off/main.ts" - ], - "diags": [] - }, - "/tests/diagnostics/spread-fences.ts": { - "order": [ - "/tests/diagnostics/spread-fences.ts" - ], - "diags": [] - }, - "/tests/diagnostics/spread-runtime-optional.ts": { - "order": [ - "/tests/diagnostics/spread-runtime-optional.ts" - ], - "diags": [] - }, - "/tests/diagnostics/statements.ts": { - "order": [ - "/tests/diagnostics/statements.ts" - ], - "diags": [] - }, - "/tests/diagnostics/static-blocks.ts": { - "order": [ - "/tests/diagnostics/static-blocks.ts" - ], - "diags": [] - }, - "/tests/diagnostics/stdlib-fence.ts": { - "order": [ - "/tests/diagnostics/stdlib-fence.ts" - ], - "diags": [] - }, - "/tests/diagnostics/stdlib.ts": { - "order": [ - "/tests/diagnostics/stdlib.ts" - ], - "diags": [] - }, - "/tests/diagnostics/text-codec-value.ts": { - "order": [ - "/tests/diagnostics/text-codec-value.ts" - ], - "diags": [] - }, - "/tests/diagnostics/text-decoder-label.ts": { - "order": [ - "/tests/diagnostics/text-decoder-label.ts" - ], - "diags": [] - }, - "/tests/diagnostics/top-level-await-commonjs/main.ts": { - "order": [ - "/tests/diagnostics/top-level-await-commonjs/main.ts" - ], - "diags": [ - { - "code": "SC1013", - "message": "Node classifies this file as CommonJS, where this ES-module syntax marker is a SyntaxError", - "loc": { - "file": "/tests/diagnostics/top-level-await-commonjs/main.ts", - "start": 15, - "end": 40 - }, - "milestone": "later", - "hint": "use a .mjs/.mts extension or set the nearest package.json's \"type\" to \"module\"" - } - ] - }, - "/tests/diagnostics/top-level-await-implicit-module-nested-require.js": { - "order": [ - "/tests/diagnostics/top-level-await-implicit-module-nested-require.js" - ], - "diags": [ - { - "code": "SC1013", - "message": "require() in an ES module (Node throws ReferenceError — use import) is not supported yet", - "loc": { - "file": "/tests/diagnostics/top-level-await-implicit-module-nested-require.js", - "start": 114, - "end": 134 - }, - "milestone": "later" - } - ] - }, - "/tests/diagnostics/top-level-await-module-leak/main.ts": { - "order": [ - "/tests/diagnostics/top-level-await-module-leak/a.ts", - "/tests/diagnostics/top-level-await-module-leak/b.ts", - "/tests/diagnostics/top-level-await-module-leak/main.ts" - ], - "diags": [ - { - "code": "SC0001", - "message": "Cannot find name 'shared'.", - "loc": { - "file": "/tests/diagnostics/top-level-await-module-leak/b.ts", - "start": 37, - "end": 43 - } - } - ] - }, - "/tests/diagnostics/tuples.ts": { - "order": [ - "/tests/diagnostics/tuples.ts" - ], - "diags": [] - }, - "/tests/diagnostics/unassigned-fields.ts": { - "order": [ - "/tests/diagnostics/unassigned-fields.ts" - ], - "diags": [] - }, - "/tests/diagnostics/union-clone-override-width.ts": { - "order": [ - "/tests/diagnostics/union-clone-override-width.ts" - ], - "diags": [] - }, - "/tests/diagnostics/unions.ts": { - "order": [ - "/tests/diagnostics/unions.ts" - ], - "diags": [] - }, - "/tests/diagnostics/utility-types.ts": { - "order": [ - "/tests/diagnostics/utility-types.ts" - ], - "diags": [] - }, - "/tests/diagnostics/var-fences.ts": { - "order": [ - "/tests/diagnostics/var-fences.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/2465-getter-table/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/2465-getter-table/main.ts" - ], - "diags": [ - { - "code": "SC0001", - "message": "Module '\"gtable\"' has no exported member 'chunkGhost'.", - "loc": { - "file": "/tests/fixtures/npm/cases/2465-getter-table/main.ts", - "start": 506, - "end": 516 - } - } - ] - }, - "/tests/fixtures/npm/cases/2466-getter-star/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/2466-getter-star/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/2467-star-barrel/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/2467-star-barrel/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/2468-defineprop-exports/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/2468-defineprop-exports/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/2469-bundle-offender/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/2469-bundle-offender/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/2556-toesm-external/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/2556-toesm-external/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/2557-toesm-drift/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/2557-toesm-drift/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/abandoned-handles/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/abandoned-handles/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/any-chaining/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/any-chaining/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/assert-shims/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/assert-shims/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/buffer-shims/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/buffer-shims/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/builtin-shims/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/builtin-shims/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/bytes-exit/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/bytes-exit/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/callbacks/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/callbacks/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/chain/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/chain/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/cjs-esm-named/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/cjs-esm-named/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/cjs-lexer-aligned/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/cjs-lexer-aligned/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/cjs-lexer-invisible/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/cjs-lexer-invisible/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/cjs-named/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/cjs-named/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/class-construct/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/class-construct/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/create-require/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/create-require/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/crypto-shims/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/crypto-shims/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/dotfolder/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/dotfolder/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/dual-entry/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/dual-entry/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/dual-package-kinds/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/dual-package-kinds/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/dynamic-import-local/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/dynamic-import-local/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/dynamic-import/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/dynamic-import/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/esbuild-require/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/esbuild-require/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/esm-entries/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/esm-entries/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/esm-missing-default/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/esm-missing-default/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/esm-missing-export/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/esm-missing-export/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/fetch-destructure/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/fetch-destructure/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/fs-shims/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/fs-shims/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/hoisted-workspace/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/hoisted-workspace/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/import-refusal/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/import-refusal/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/island-array-exits/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/island-array-exits/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/island-instanceof-regexp/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/island-instanceof-regexp/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/island-json-stringify/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/island-json-stringify/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/island-registry/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/island-registry/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/island-timers/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/island-timers/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/island-web-plumbing/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/island-web-plumbing/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/jsval-into-dyn/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/jsval-into-dyn/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/jsval-iterate/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/jsval-iterate/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/lazy-traps/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/lazy-traps/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/misc-shims/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/misc-shims/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/namespace/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/namespace/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-crypto-kdf/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-crypto-kdf/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-deep-equality/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-deep-equality/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-fs-descriptors/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-fs-descriptors/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/npm-reexport/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/npm-reexport/facade.ts", - "/tests/fixtures/npm/cases/npm-reexport/default-facade.ts", - "/tests/fixtures/npm/cases/npm-reexport/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/package-imports/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/package-imports/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/promise-bridge-forever/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/promise-bridge-forever/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/promise-bridge-unhandled/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/promise-bridge-unhandled/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/promise-bridge/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/promise-bridge/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/scoped-nested/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/scoped-nested/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/self-name/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/self-name/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/side-effect-order/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/side-effect-order/mid.ts", - "/tests/fixtures/npm/cases/side-effect-order/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/stream-shims/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/stream-shims/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/top-level-await-pending-exit-code/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/top-level-await-pending-exit-code/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/top-level-await-pending-exit-listener/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/top-level-await-pending-exit-listener/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/typed-callbacks/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/typed-callbacks/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/util-shims/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/util-shims/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/web-streams/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/web-streams/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/workspace-copied/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/workspace-copied/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/workspace-linked/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/workspace-linked/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/workspace-unclean/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/workspace-unclean/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/zlib-shims/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/zlib-shims/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/strictness/indexed-loose/main.ts": { - "order": [ - "/tests/fixtures/strictness/indexed-loose/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/strictness/indexed-strict/main.ts": { - "order": [ - "/tests/fixtures/strictness/indexed-strict/main.ts" - ], - "diags": [ - { - "code": "SC0001", - "message": "'picked' is possibly 'undefined'.", - "loc": { - "file": "/tests/fixtures/strictness/indexed-strict/main.ts", - "start": 360, - "end": 366 - } - } - ] - }, - "/tests/fixtures/strictness/json-any-broken/main.ts": { - "order": [ - "/tests/fixtures/strictness/json-any-broken/main.ts" - ], - "diags": [ - { - "code": "SC0001", - "message": "Type 'string' is not assignable to type 'number'.", - "loc": { - "file": "/tests/fixtures/strictness/json-any-broken/main.ts", - "start": 324, - "end": 325 - } - } - ] - }, - "/tests/fixtures/strictness/json-any/main.ts": { - "order": [ - "/tests/fixtures/strictness/json-any/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/strictness/null-floor/main.ts": { - "order": [ - "/tests/fixtures/strictness/null-floor/main.ts" - ], - "diags": [ - { - "code": "SC0002", - "message": "this project's tsconfig disables strictNullChecks, which scriptc requires (null and undefined are modeled as distinct static types; without the knob every type silently includes them)", - "loc": { - "file": "/tests/fixtures/strictness/null-floor/tsconfig.json", - "start": 0, - "end": 0 - }, - "hint": "set \"strictNullChecks\": true (or \"strict\": true) in the project tsconfig" - } - ] - }, - "/tests/fixtures/strictness/project-paths/main.ts": { - "order": [ - "/tests/fixtures/strictness/project-paths/src/exact.ts", - "/tests/fixtures/strictness/project-paths/src/message.ts", - "/tests/fixtures/strictness/project-paths/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/argv-env.ts": { - "order": [ - "/tests/fixtures/node-types/argv-env.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/child-execfile.ts": { - "order": [ - "/tests/fixtures/node-types/child-execfile.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/child-stdin-fences.ts": { - "order": [ - "/tests/fixtures/node-types/child-stdin-fences.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/child-stdin.ts": { - "order": [ - "/tests/fixtures/node-types/child-stdin.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/crypto-kdf.ts": { - "order": [ - "/tests/fixtures/node-types/crypto-kdf.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/deep-equality.ts": { - "order": [ - "/tests/fixtures/node-types/deep-equality.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/fenced.ts": { - "order": [ - "/tests/fixtures/node-types/fenced.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/fetch-static.ts": { - "order": [ - "/tests/fixtures/node-types/fetch-static.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/fs-links.ts": { - "order": [ - "/tests/fixtures/node-types/fs-links.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/fs-statfs.ts": { - "order": [ - "/tests/fixtures/node-types/fs-statfs.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/fs-timestamps.ts": { - "order": [ - "/tests/fixtures/node-types/fs-timestamps.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/import-fences.ts": { - "order": [ - "/tests/fixtures/node-types/import-fences.ts" - ], - "diags": [ - { - "code": "SC1010", - "message": "the 'v8' module (it observes V8 engine internals — heap statistics and snapshots, GC and CPU profiles, serialize/deserialize — and a compiled binary embeds no V8 engine to observe) is not supported yet", - "loc": { - "file": "/tests/fixtures/node-types/import-fences.ts", - "start": 422, - "end": 461 - }, - "milestone": "M4", - "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" - } - ] - }, - "/tests/fixtures/node-types/path-os.ts": { - "order": [ - "/tests/fixtures/node-types/path-os.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/stream-capture.ts": { - "order": [ - "/tests/fixtures/node-types/stream-capture.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/url-getters.ts": { - "order": [ - "/tests/fixtures/node-types/url-getters.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-url-factories.ts": { - "order": [ - "/tests/corpus/node24-url-factories.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-url-factory-errors.ts": { - "order": [ - "/tests/corpus/node24-url-factory-errors.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-url-factories/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-url-factories/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/url-factories.ts": { - "order": [ - "/tests/fixtures/node-types/url-factories.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-env-parse.ts": { - "order": [ - "/tests/corpus/node24-env-parse.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-env-parse-errors.ts": { - "order": [ - "/tests/corpus/node24-env-parse-errors.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-env-files.ts": { - "order": [ - "/tests/corpus/node24-env-files.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-env-files-errors.ts": { - "order": [ - "/tests/corpus/node24-env-files-errors.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-env-imports.cjs": { - "order": [ - "/tests/corpus/node24-env-imports.cjs" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-env/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-env/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/env-files.ts": { - "order": [ - "/tests/fixtures/node-types/env-files.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-buffer-encoding-errors.ts": { - "order": [ - "/tests/corpus/node24-buffer-encoding-errors.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-buffer-encoding.ts": { - "order": [ - "/tests/corpus/node24-buffer-encoding.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-text-codec-properties.ts": { - "order": [ - "/tests/corpus/node24-text-codec-properties.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-text-encode-into.ts": { - "order": [ - "/tests/corpus/node24-text-encode-into.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/text-encoding.ts": { - "order": [ - "/tests/fixtures/node-types/text-encoding.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-text-encoding/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-text-encoding/main.ts" - ], - "diags": [] - }, - "/tests/corpus/js-open-binding-writes.js": { - "order": [ - "/tests/corpus/js-open-binding-writes.js" - ], - "diags": [] - }, - "/tests/corpus/node24-string-decoder.ts": { - "order": [ - "/tests/corpus/node24-string-decoder.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-string-decoder/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-string-decoder/main.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-parseargs.js": { - "order": [ - "/tests/corpus/node24-parseargs.js" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-parseargs/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-parseargs/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-util-adapters/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-util-adapters/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-event-emitter/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-event-emitter/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-async-events/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-async-events/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-promise-timers/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-promise-timers/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-timers-unref/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-timers-unref/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-mime/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-mime/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-mime-errors/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-mime-errors/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-commonjs-metadata/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-commonjs-metadata/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-diagnostics-async/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-diagnostics-async/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-diagnostics-subscriber-throw/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-diagnostics-subscriber-throw/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-diagnostics-tracing/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-diagnostics-tracing/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-diagnostics-transform-throw/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-diagnostics-transform-throw/main.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-file-url-buffer.ts": { - "order": [ - "/tests/corpus/node24-file-url-buffer.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-file-url-errors.js": { - "order": [ - "/tests/corpus/node24-file-url-errors.js" - ], - "diags": [] - }, - "/tests/corpus/node24-file-url-options.ts": { - "order": [ - "/tests/corpus/node24-file-url-options.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-file-url-conversion/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-file-url-conversion/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/file-url-conversion.ts": { - "order": [ - "/tests/fixtures/node-types/file-url-conversion.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-system-errors.ts": { - "order": [ - "/tests/corpus/node24-system-errors.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-system-errors.cjs": { - "order": [ - "/tests/corpus/node24-system-errors.cjs" - ], - "diags": [] - }, - "/tests/corpus/node24-system-error-validation.js": { - "order": [ - "/tests/corpus/node24-system-error-validation.js" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-system-errors/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-system-errors/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/system-errors.ts": { - "order": [ - "/tests/fixtures/node-types/system-errors.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-text-utilities.ts": { - "order": [ - "/tests/corpus/node24-text-utilities.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-text-utilities.cjs": { - "order": [ - "/tests/corpus/node24-text-utilities.cjs" - ], - "diags": [] - }, - "/tests/corpus/node24-text-utilities-validation.js": { - "order": [ - "/tests/corpus/node24-text-utilities-validation.js" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-text-utilities/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-text-utilities/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/text-utilities.ts": { - "order": [ - "/tests/fixtures/node-types/text-utilities.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-text-utilities-coercion.js": { - "order": [ - "/tests/corpus/node24-text-utilities-coercion.js" - ], - "diags": [] - }, - "/tests/corpus/node24-no-error-assertions.ts": { - "order": [ - "/tests/corpus/node24-no-error-assertions.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-no-error-assertions.cjs": { - "order": [ - "/tests/corpus/node24-no-error-assertions.cjs" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-no-error-assertions/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-no-error-assertions/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/no-error-assertions.ts": { - "order": [ - "/tests/fixtures/node-types/no-error-assertions.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-no-error-assertions-coercion.js": { - "order": [ - "/tests/corpus/node24-no-error-assertions-coercion.js" - ], - "diags": [] - }, - "/tests/diagnostics/no-error-assertion-fences.ts": { - "order": [ - "/tests/diagnostics/no-error-assertion-fences.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-style-text-validation.js": { - "order": [ - "/tests/corpus/node24-style-text-validation.js" - ], - "diags": [] - }, - "/tests/corpus/node24-style-text.cjs": { - "order": [ - "/tests/corpus/node24-style-text.cjs" - ], - "diags": [] - }, - "/tests/corpus/node24-style-text.ts": { - "order": [ - "/tests/corpus/node24-style-text.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/style-text.ts": { - "order": [ - "/tests/fixtures/node-types/style-text.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-style-text/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-style-text/main.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-style-text-environment.js": { - "order": [ - "/tests/corpus/node24-style-text-environment.js" - ], - "diags": [] - }, - "/tests/corpus/node24-util-types.ts": { - "order": [ - "/tests/corpus/node24-util-types.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-util-types.js": { - "order": [ - "/tests/corpus/node24-util-types.js" - ], - "diags": [] - }, - "/tests/corpus/node24-util-types.cjs": { - "order": [ - "/tests/corpus/node24-util-types.cjs" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-util-types/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-util-types/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/util-types.ts": { - "order": [ - "/tests/fixtures/node-types/util-types.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-esm-metadata/main.mjs": { - "order": [ - "/tests/corpus/node24-esm-metadata/child with ü.mjs", - "/tests/corpus/node24-esm-metadata/main.mjs" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-esm-metadata/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-esm-metadata/main.ts" - ], - "diags": [] - }, - "/tests/diagnostics/import-meta-rest.ts": { - "order": [ - "/tests/diagnostics/import-meta-rest.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-url-mutation-coercion.js": { - "order": [ - "/tests/corpus/node24-url-mutation-coercion.js" - ], - "diags": [] - }, - "/tests/corpus/node24-url-mutation.ts": { - "order": [ - "/tests/corpus/node24-url-mutation.ts" - ], - "diags": [] - }, - "/tests/diagnostics/url-mutation-object-plus.ts": { - "order": [ - "/tests/diagnostics/url-mutation-object-plus.ts" - ], - "diags": [] - }, - "/tests/diagnostics/url-mutation-operator.ts": { - "order": [ - "/tests/diagnostics/url-mutation-operator.ts" - ], - "diags": [] - }, - "/tests/diagnostics/url-mutation-runtime-key.ts": { - "order": [ - "/tests/diagnostics/url-mutation-runtime-key.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/url-mutation.ts": { - "order": [ - "/tests/fixtures/node-types/url-mutation.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-url-mutation/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-url-mutation/main.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-url-authority.ts": { - "order": [ - "/tests/corpus/node24-url-authority.ts" - ], - "diags": [] - }, - "/tests/corpus/node24-url-authority-coercion.js": { - "order": [ - "/tests/corpus/node24-url-authority-coercion.js" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-url-authority/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-url-authority/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-web-stream-queues/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-web-stream-queues/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-web-stream-lifecycle/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-web-stream-lifecycle/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-web-stream-errors/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-web-stream-errors/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-web-stream-pipes/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-web-stream-pipes/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-web-stream-pipe-errors/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-web-stream-pipe-errors/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-web-stream-pipe-abort/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-web-stream-pipe-abort/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-web-stream-transforms/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-web-stream-transforms/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-web-stream-encoding/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-web-stream-encoding/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-web-stream-readers/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-web-stream-readers/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-web-stream-readable-lifecycle/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-web-stream-readable-lifecycle/main.ts" - ], - "diags": [] - }, - "/tests/fixtures/npm/cases/node24-web-stream-tee/main.ts": { - "order": [ - "/tests/fixtures/npm/cases/node24-web-stream-tee/main.ts" - ], - "diags": [] - }, - "/tests/corpus/array-read-helper-effects.ts": { - "order": [ - "/tests/corpus/array-read-helper-effects.ts" - ], - "diags": [] - }, - "/tests/corpus/call-lifetimes-argument-order.ts": { - "order": [ - "/tests/corpus/call-lifetimes-argument-order.ts" - ], - "diags": [] - }, - "/tests/corpus/call-lifetimes-control-flow.ts": { - "order": [ - "/tests/corpus/call-lifetimes-control-flow.ts" - ], - "diags": [] - }, - "/tests/corpus/call-lifetimes-owned-boundaries.ts": { - "order": [ - "/tests/corpus/call-lifetimes-owned-boundaries.ts" - ], - "diags": [] - }, - "/tests/corpus/call-lifetimes-projections.ts": { - "order": [ - "/tests/corpus/call-lifetimes-projections.ts" - ], - "diags": [] - }, - "/tests/corpus/call-lifetimes-union-values.ts": { - "order": [ - "/tests/corpus/call-lifetimes-union-values.ts" - ], - "diags": [] - }, - "/tests/corpus/call-lifetimes-virtual-optionals.ts": { - "order": [ - "/tests/corpus/call-lifetimes-virtual-optionals.ts" - ], - "diags": [] - }, - "/tests/corpus/array-argument-lifetimes-exits.ts": { - "order": [ - "/tests/corpus/array-argument-lifetimes-exits.ts" - ], - "diags": [] - }, - "/tests/corpus/array-argument-lifetimes-mutation.ts": { - "order": [ - "/tests/corpus/array-argument-lifetimes-mutation.ts" - ], - "diags": [] - }, - "/tests/corpus/array-argument-lifetimes-strings.ts": { - "order": [ - "/tests/corpus/array-argument-lifetimes-strings.ts" - ], - "diags": [] - }, - "/tests/corpus/array-argument-lifetimes-values.ts": { - "order": [ - "/tests/corpus/array-argument-lifetimes-values.ts" - ], - "diags": [] - }, - "/tests/corpus/input-lifetimes-modules/main.ts": { - "order": [ - "/tests/corpus/input-lifetimes-modules/model.ts", - "/tests/corpus/input-lifetimes-modules/helpers.ts", - "/tests/corpus/input-lifetimes-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/string-lifetimes-boundaries.ts": { - "order": [ - "/tests/corpus/string-lifetimes-boundaries.ts" - ], - "diags": [] - }, - "/tests/corpus/string-lifetimes-evaluation.ts": { - "order": [ - "/tests/corpus/string-lifetimes-evaluation.ts" - ], - "diags": [] - }, - "/tests/corpus/string-lifetimes-iteration.ts": { - "order": [ - "/tests/corpus/string-lifetimes-iteration.ts" - ], - "diags": [] - }, - "/tests/corpus/string-lifetimes-operations.ts": { - "order": [ - "/tests/corpus/string-lifetimes-operations.ts" - ], - "diags": [] - }, - "/tests/corpus/collection-ingestion.ts": { - "order": [ - "/tests/corpus/collection-ingestion.ts" - ], - "diags": [] - }, - "/tests/corpus/collection-ingestion-mappers.ts": { - "order": [ - "/tests/corpus/collection-ingestion-mappers.ts" - ], - "diags": [] - }, - "/tests/corpus/collection-ingestion-references.ts": { - "order": [ - "/tests/corpus/collection-ingestion-references.ts" - ], - "diags": [] - }, - "/tests/corpus/collection-ingestion-protocol/main.ts": { - "order": [ - "/tests/corpus/collection-ingestion-protocol/source.js", - "/tests/corpus/collection-ingestion-protocol/main.ts" - ], - "diags": [] - }, - "/tests/corpus/integer-view-control.ts": { - "order": [ - "/tests/corpus/integer-view-control.ts" - ], - "diags": [] - }, - "/tests/corpus/integer-view-numbers.ts": { - "order": [ - "/tests/corpus/integer-view-numbers.ts" - ], - "diags": [] - }, - "/tests/corpus/integer-view-storage.ts": { - "order": [ - "/tests/corpus/integer-view-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/counted-loop-numbers.ts": { - "order": [ - "/tests/corpus/counted-loop-numbers.ts" - ], - "diags": [] - }, - "/tests/corpus/counted-loop-storage.ts": { - "order": [ - "/tests/corpus/counted-loop-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/byte-loop-bounds.ts": { - "order": [ - "/tests/corpus/byte-loop-bounds.ts" - ], - "diags": [] - }, - "/tests/corpus/integer-flow-arithmetic.ts": { - "order": [ - "/tests/corpus/integer-flow-arithmetic.ts" - ], - "diags": [] - }, - "/tests/corpus/integer-loop-forms.ts": { - "order": [ - "/tests/corpus/integer-loop-forms.ts" - ], - "diags": [] - }, - "/tests/corpus/heap-input-aliases.ts": { - "order": [ - "/tests/corpus/heap-input-aliases.ts" - ], - "diags": [] - }, - "/tests/corpus/heap-input-collections.ts": { - "order": [ - "/tests/corpus/heap-input-collections.ts" - ], - "diags": [] - }, - "/tests/corpus/input-lifetime-intervals.ts": { - "order": [ - "/tests/corpus/input-lifetime-intervals.ts" - ], - "diags": [] - }, - "/tests/corpus/regex-input-lifetimes.ts": { - "order": [ - "/tests/corpus/regex-input-lifetimes.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-value-input-lifetimes.ts": { - "order": [ - "/tests/corpus/checked-value-input-lifetimes.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-dispatch-input-lifetimes.js": { - "order": [ - "/tests/corpus/checked-dispatch-input-lifetimes.js" - ], - "diags": [] - }, - "/tests/corpus/string-construction-order.ts": { - "order": [ - "/tests/corpus/string-construction-order.ts" - ], - "diags": [] - }, - "/tests/corpus/collection-value-keys.ts": { - "order": [ - "/tests/corpus/collection-value-keys.ts" - ], - "diags": [] - }, - "/tests/corpus/collection-storage-copies.ts": { - "order": [ - "/tests/corpus/collection-storage-copies.ts" - ], - "diags": [] - }, - "/tests/corpus/byte-number-pipeline.ts": { - "order": [ - "/tests/corpus/byte-number-pipeline.ts" - ], - "diags": [] - }, - "/tests/corpus/module-byte-loops.ts": { - "order": [ - "/tests/corpus/module-byte-loops.ts" - ], - "diags": [] - }, - "/tests/corpus/file-read-storage.ts": { - "order": [ - "/tests/corpus/file-read-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-iterator-consumption.js": { - "order": [ - "/tests/corpus/checked-iterator-consumption.js" - ], - "diags": [] - }, - "/tests/corpus/structured-text-storage.ts": { - "order": [ - "/tests/corpus/structured-text-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/projected-collection-lifetimes.ts": { - "order": [ - "/tests/corpus/projected-collection-lifetimes.ts" - ], - "diags": [] - }, - "/tests/corpus/small-collection-transitions.ts": { - "order": [ - "/tests/corpus/small-collection-transitions.ts" - ], - "diags": [] - }, - "/tests/corpus/checked-storage-transitions.js": { - "order": [ - "/tests/corpus/checked-storage-transitions.js" - ], - "diags": [] - }, - "/tests/corpus/structured-text-boundaries.js": { - "order": [ - "/tests/corpus/structured-text-boundaries.js" - ], - "diags": [] - }, - "/tests/corpus/array-storage-transitions.ts": { - "order": [ - "/tests/corpus/array-storage-transitions.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-array-reversed-storage.ts": { - "order": [ - "/tests/corpus/typed-array-reversed-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/regex-text-paths.ts": { - "order": [ - "/tests/corpus/regex-text-paths.ts" - ], - "diags": [] - }, - "/tests/corpus/unicode-case-paths.ts": { - "order": [ - "/tests/corpus/unicode-case-paths.ts" - ], - "diags": [] - }, - "/tests/corpus/utf8-span-decoding.ts": { - "order": [ - "/tests/corpus/utf8-span-decoding.ts" - ], - "diags": [] - }, - "/tests/corpus/literal-switch-dispatch.ts": { - "order": [ - "/tests/corpus/literal-switch-dispatch.ts" - ], - "diags": [] - }, - "/tests/corpus/local-union-storage.ts": { - "order": [ - "/tests/corpus/local-union-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/class-callback-storage.ts": { - "order": [ - "/tests/corpus/class-callback-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/array-sort-runs.ts": { - "order": [ - "/tests/corpus/array-sort-runs.ts" - ], - "diags": [] - }, - "/tests/corpus/uint8array-sort-domains.ts": { - "order": [ - "/tests/corpus/uint8array-sort-domains.ts" - ], - "diags": [] - }, - "/tests/corpus/buffer-codec-boundaries.ts": { - "order": [ - "/tests/corpus/buffer-codec-boundaries.ts" - ], - "diags": [] - }, - "/tests/corpus/text-encode-into-boundaries.ts": { - "order": [ - "/tests/corpus/text-encode-into-boundaries.ts" - ], - "diags": [] - }, - "/tests/corpus/object-key-indexes.js": { - "order": [ - "/tests/corpus/object-key-indexes.js" - ], - "diags": [] - }, - "/tests/corpus/record-key-order.ts": { - "order": [ - "/tests/corpus/record-key-order.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-array-bulk-conversion.mjs": { - "order": [ - "/tests/corpus/typed-array-bulk-conversion.mjs" - ], - "diags": [] - }, - "/tests/corpus/typed-array-numeric-import.ts": { - "order": [ - "/tests/corpus/typed-array-numeric-import.ts" - ], - "diags": [] - }, - "/tests/corpus/byte-record-windows.ts": { - "order": [ - "/tests/corpus/byte-record-windows.ts" - ], - "diags": [] - }, - "/tests/corpus/array-numeric-own-keys.ts": { - "order": [ - "/tests/corpus/array-numeric-own-keys.ts" - ], - "diags": [] - }, - "/tests/corpus/array-primitive-ordering.ts": { - "order": [ - "/tests/corpus/array-primitive-ordering.ts" - ], - "diags": [] - }, - "/tests/corpus/class-subclass-assertions.ts": { - "order": [ - "/tests/corpus/class-subclass-assertions.ts" - ], - "diags": [] - }, - "/tests/corpus/deferred-field-updates.ts": { - "order": [ - "/tests/corpus/deferred-field-updates.ts" - ], - "diags": [] - }, - "/tests/corpus/forward-generic-signatures.ts": { - "order": [ - "/tests/corpus/forward-generic-signatures.ts" - ], - "diags": [] - }, - "/tests/corpus/generic-base-specializations.ts": { - "order": [ - "/tests/corpus/generic-base-specializations.ts" - ], - "diags": [] - }, - "/tests/corpus/generic-namespace-factories/main.ts": { - "order": [ - "/tests/corpus/generic-namespace-factories/pair.ts", - "/tests/corpus/generic-namespace-factories/main.ts" - ], - "diags": [] - }, - "/tests/corpus/generic-nullable-collections.ts": { - "order": [ - "/tests/corpus/generic-nullable-collections.ts" - ], - "diags": [] - }, - "/tests/corpus/non-null-class-iteration.ts": { - "order": [ - "/tests/corpus/non-null-class-iteration.ts" - ], - "diags": [] - }, - "/tests/corpus/runtime-optional-string-flows.ts": { - "order": [ - "/tests/corpus/runtime-optional-string-flows.ts" - ], - "diags": [] - }, - "/tests/corpus/class-interface-protocols.ts": { - "order": [ - "/tests/corpus/class-interface-protocols.ts" - ], - "diags": [] - }, - "/tests/corpus/fs-read-encodings.ts": { - "order": [ - "/tests/corpus/fs-read-encodings.ts" - ], - "diags": [] - }, - "/tests/corpus/regex-callback-replacements.ts": { - "order": [ - "/tests/corpus/regex-callback-replacements.ts" - ], - "diags": [] - }, - "/tests/corpus/regex-callback-values.js": { - "order": [ - "/tests/corpus/regex-callback-values.js" - ], - "diags": [] - }, - "/tests/corpus/constant-callback-dispatch.ts": { - "order": [ - "/tests/corpus/constant-callback-dispatch.ts" - ], - "diags": [] - }, - "/tests/corpus/constant-number-remainders.ts": { - "order": [ - "/tests/corpus/constant-number-remainders.ts" - ], - "diags": [] - }, - "/tests/corpus/numeric-call-specialization.ts": { - "order": [ - "/tests/corpus/numeric-call-specialization.ts" - ], - "diags": [] - }, - "/tests/corpus/scalar-string-slices.ts": { - "order": [ - "/tests/corpus/scalar-string-slices.ts" - ], - "diags": [] - }, - "/tests/corpus/atomics-integer-operations.ts": { - "order": [ - "/tests/corpus/atomics-integer-operations.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-buffer-consumers.ts": { - "order": [ - "/tests/corpus/native-worker-buffer-consumers.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-clone-errors.ts": { - "order": [ - "/tests/corpus/native-worker-clone-errors.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-commonjs.cjs": { - "order": [ - "/tests/corpus/native-worker-commonjs.cjs" - ], - "diags": [] - }, - "/tests/corpus/native-worker-delayed-messages.ts": { - "order": [ - "/tests/corpus/native-worker-delayed-messages.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-environment.ts": { - "order": [ - "/tests/corpus/native-worker-environment.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-error.ts": { - "order": [ - "/tests/corpus/native-worker-error.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-exit-listeners.ts": { - "order": [ - "/tests/corpus/native-worker-exit-listeners.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-io.ts": { - "order": [ - "/tests/corpus/native-worker-io.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-loop-cancellation.ts": { - "order": [ - "/tests/corpus/native-worker-loop-cancellation.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-message-graphs.ts": { - "order": [ - "/tests/corpus/native-worker-message-graphs.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-messages.ts": { - "order": [ - "/tests/corpus/native-worker-messages.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-port-lifetime.ts": { - "order": [ - "/tests/corpus/native-worker-port-lifetime.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-process-exit.ts": { - "order": [ - "/tests/corpus/native-worker-process-exit.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-references.ts": { - "order": [ - "/tests/corpus/native-worker-references.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-roots/main.ts": { - "order": [ - "/tests/corpus/native-worker-roots/main.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-shared-views.ts": { - "order": [ - "/tests/corpus/native-worker-shared-views.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-terminate-loop.ts": { - "order": [ - "/tests/corpus/native-worker-terminate-loop.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-terminate-suspended.ts": { - "order": [ - "/tests/corpus/native-worker-terminate-suspended.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-terminate-wait.ts": { - "order": [ - "/tests/corpus/native-worker-terminate-wait.ts" - ], - "diags": [] - }, - "/tests/corpus/caught-class-identity.ts": { - "order": [ - "/tests/corpus/caught-class-identity.ts" - ], - "diags": [] - }, - "/tests/corpus/caught-system-error-fields.ts": { - "order": [ - "/tests/corpus/caught-system-error-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/collection-data-unions.ts": { - "order": [ - "/tests/corpus/collection-data-unions.ts" - ], - "diags": [] - }, - "/tests/corpus/native-callback-dispatch.ts": { - "order": [ - "/tests/corpus/native-callback-dispatch.ts" - ], - "diags": [] - }, - "/tests/corpus/terminal-stream-properties.ts": { - "order": [ - "/tests/corpus/terminal-stream-properties.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-index-arguments.ts": { - "order": [ - "/tests/corpus/typed-index-arguments.ts" - ], - "diags": [] - }, - "/tests/fixtures/node-types/terminal-error-fields.ts": { - "order": [ - "/tests/fixtures/node-types/terminal-error-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/class-narrowed-views.ts": { - "order": [ - "/tests/corpus/class-narrowed-views.ts" - ], - "diags": [] - }, - "/tests/corpus/class-covariant-returns.ts": { - "order": [ - "/tests/corpus/class-covariant-returns.ts" - ], - "diags": [] - }, - "/tests/corpus/derived-numeric-updates.ts": { - "order": [ - "/tests/corpus/derived-numeric-updates.ts" - ], - "diags": [] - }, - "/tests/corpus/captured-class-refinement.ts": { - "order": [ - "/tests/corpus/captured-class-refinement.ts" - ], - "diags": [] - }, - "/tests/corpus/class-collection-insertion.ts": { - "order": [ - "/tests/corpus/class-collection-insertion.ts" - ], - "diags": [] - }, - "/tests/corpus/union-reference-comparison.ts": { - "order": [ - "/tests/corpus/union-reference-comparison.ts" - ], - "diags": [] - }, - "/tests/corpus/optional-flag-comparisons.ts": { - "order": [ - "/tests/corpus/optional-flag-comparisons.ts" - ], - "diags": [] - }, - "/tests/corpus/record-field-presence.ts": { - "order": [ - "/tests/corpus/record-field-presence.ts" - ], - "diags": [] - }, - "/tests/corpus/record-presence-copies.ts": { - "order": [ - "/tests/corpus/record-presence-copies.ts" - ], - "diags": [] - }, - "/tests/corpus/record-presence-delete-json.ts": { - "order": [ - "/tests/corpus/record-presence-delete-json.ts" - ], - "diags": [] - }, - "/tests/corpus/record-unchecked-read-presence.ts": { - "order": [ - "/tests/corpus/record-unchecked-read-presence.ts" - ], - "diags": [] - }, - "/tests/corpus/4040-adapted-function-identity.ts": { - "order": [ - "/tests/corpus/4040-adapted-function-identity.ts" - ], - "diags": [] - }, - "/tests/corpus/4041-adapted-function-properties.ts": { - "order": [ - "/tests/corpus/4041-adapted-function-properties.ts" - ], - "diags": [] - }, - "/tests/corpus/4042-object-is-union-subclass.ts": { - "order": [ - "/tests/corpus/4042-object-is-union-subclass.ts" - ], - "diags": [] - }, - "/tests/corpus/4043-nonnull-missing-element.ts": { - "order": [ - "/tests/corpus/4043-nonnull-missing-element.ts" - ], - "diags": [] - }, - "/tests/corpus/4044-adapted-callback-modules/main.ts": { - "order": [ - "/tests/corpus/4044-adapted-callback-modules/registry.ts", - "/tests/corpus/4044-adapted-callback-modules/main.ts" - ], - "diags": [] - }, - "/tests/corpus/iterator-typed-returns.ts": { - "order": [ - "/tests/corpus/iterator-typed-returns.ts" - ], - "diags": [] - }, - "/tests/corpus/never-returning-calls.ts": { - "order": [ - "/tests/corpus/never-returning-calls.ts" - ], - "diags": [] - }, - "/tests/corpus/optional-element-defaults.ts": { - "order": [ - "/tests/corpus/optional-element-defaults.ts" - ], - "diags": [] - }, - "/tests/diagnostics/iterator-slot-fences.ts": { - "order": [ - "/tests/diagnostics/iterator-slot-fences.ts" - ], - "diags": [] - }, - "/tests/corpus/4060-cycle-shared-instance/main.ts": { - "order": [ - "/tests/corpus/4060-cycle-shared-instance/report.ts", - "/tests/corpus/4060-cycle-shared-instance/inventory.ts", - "/tests/corpus/4060-cycle-shared-instance/main.ts" - ], - "diags": [] - }, - "/tests/corpus/4061-cycle-evaluation-order/main.ts": { - "order": [ - "/tests/corpus/4061-cycle-evaluation-order/south.ts", - "/tests/corpus/4061-cycle-evaluation-order/east.ts", - "/tests/corpus/4061-cycle-evaluation-order/north.ts", - "/tests/corpus/4061-cycle-evaluation-order/main.ts" - ], - "diags": [] - }, - "/tests/corpus/4062-cycle-tdz-read/main.ts": { - "order": [ - "/tests/corpus/4062-cycle-tdz-read/probe.ts", - "/tests/corpus/4062-cycle-tdz-read/limits.ts", - "/tests/corpus/4062-cycle-tdz-read/main.ts" - ], - "diags": [] - }, - "/tests/corpus/4063-cycle-hoisted-calls/main.ts": { - "order": [ - "/tests/corpus/4063-cycle-hoisted-calls/odd.ts", - "/tests/corpus/4063-cycle-hoisted-calls/even.ts", - "/tests/corpus/4063-cycle-hoisted-calls/main.ts" - ], - "diags": [] - }, - "/tests/corpus/4064-cycle-classes-after-init/main.ts": { - "order": [ - "/tests/corpus/4064-cycle-classes-after-init/item.ts", - "/tests/corpus/4064-cycle-classes-after-init/shelf.ts", - "/tests/corpus/4064-cycle-classes-after-init/main.ts" - ], - "diags": [] - }, - "/tests/corpus/4065-cycle-init-throws/main.ts": { - "order": [ - "/tests/corpus/4065-cycle-init-throws/rules.ts", - "/tests/corpus/4065-cycle-init-throws/ledger.ts", - "/tests/corpus/4065-cycle-init-throws/main.ts" - ], - "diags": [] - }, - "/tests/corpus/4066-cycle-top-level-tdz/main.ts": { - "order": [ - "/tests/corpus/4066-cycle-top-level-tdz/margin.ts", - "/tests/corpus/4066-cycle-top-level-tdz/frame.ts", - "/tests/corpus/4066-cycle-top-level-tdz/main.ts" - ], - "diags": [] - }, - "/tests/corpus/4067-dynamic-import-cycle-tdz/main.ts": { - "order": [ - "/tests/corpus/4067-dynamic-import-cycle-tdz/main.ts" - ], - "diags": [] - }, - "/tests/diagnostics/cycle-class-early/main.ts": { - "order": [ - "/tests/diagnostics/cycle-class-early/dogs.ts", - "/tests/diagnostics/cycle-class-early/pets.ts", - "/tests/diagnostics/cycle-class-early/main.ts" - ], - "diags": [] - }, - "/tests/diagnostics/cycle-default-export/main.ts": { - "order": [ - "/tests/diagnostics/cycle-default-export/b.ts", - "/tests/diagnostics/cycle-default-export/a.ts", - "/tests/diagnostics/cycle-default-export/main.ts" - ], - "diags": [ - { - "code": "SC1016", - "message": "circular imports (/tests/diagnostics/cycle-default-export/a.ts → /tests/diagnostics/cycle-default-export/b.ts → /tests/diagnostics/cycle-default-export/a.ts; the default export expression at /tests/diagnostics/cycle-default-export/a.ts:2 has no initialization state inside the cycle) are not supported yet", - "loc": { - "file": "/tests/diagnostics/cycle-default-export/a.ts", - "start": 0, - "end": 0 - }, - "milestone": "later", - "hint": "ES-module cycles of let/const/function bindings compile as-is; rewrite the named construct (a named import instead of a namespace, a const instead of a default-export expression or var, a class declared before the code that can reach it) or break the named edge" - } - ] - }, - "/tests/diagnostics/cycle-namespace-import/main.ts": { - "order": [ - "/tests/diagnostics/cycle-namespace-import/b.ts", - "/tests/diagnostics/cycle-namespace-import/a.ts", - "/tests/diagnostics/cycle-namespace-import/main.ts" - ], - "diags": [ - { - "code": "SC1016", - "message": "circular imports (/tests/diagnostics/cycle-namespace-import/a.ts → /tests/diagnostics/cycle-namespace-import/b.ts → /tests/diagnostics/cycle-namespace-import/a.ts; the namespace import 'helpers' at /tests/diagnostics/cycle-namespace-import/a.ts:1 names a module of the cycle) are not supported yet", - "loc": { - "file": "/tests/diagnostics/cycle-namespace-import/a.ts", - "start": 0, - "end": 0 - }, - "milestone": "later", - "hint": "ES-module cycles of let/const/function bindings compile as-is; rewrite the named construct (a named import instead of a namespace, a const instead of a default-export expression or var, a class declared before the code that can reach it) or break the named edge" - } - ] - }, - "/tests/diagnostics/cycle-var-early/main.ts": { - "order": [ - "/tests/diagnostics/cycle-var-early/b.ts", - "/tests/diagnostics/cycle-var-early/a.ts", - "/tests/diagnostics/cycle-var-early/main.ts" - ], - "diags": [] - }, - "/tests/corpus/cycle-generations-long-lived.ts": { - "order": [ - "/tests/corpus/cycle-generations-long-lived.ts" - ], - "diags": [] - }, - "/tests/corpus/4045-optional-element-projections.ts": { - "order": [ - "/tests/corpus/4045-optional-element-projections.ts" - ], - "diags": [] - }, - "/tests/corpus/4046-captured-parameter-values.ts": { - "order": [ - "/tests/corpus/4046-captured-parameter-values.ts" - ], - "diags": [] - }, - "/tests/corpus/4047-captured-parameter-rebinding.ts": { - "order": [ - "/tests/corpus/4047-captured-parameter-rebinding.ts" - ], - "diags": [] - }, - "/tests/corpus/3138-array-large-storage.ts": { - "order": [ - "/tests/corpus/3138-array-large-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/3139-regex-native-deep-alternatives.ts": { - "order": [ - "/tests/corpus/3139-regex-native-deep-alternatives.ts" - ], - "diags": [] - }, - "/tests/corpus/3140-array-dense-access.ts": { - "order": [ - "/tests/corpus/3140-array-dense-access.ts" - ], - "diags": [] - }, - "/tests/corpus/3141-map-string-key-hash.ts": { - "order": [ - "/tests/corpus/3141-map-string-key-hash.ts" - ], - "diags": [] - }, - "/tests/corpus/3150-integer-remainder.ts": { - "order": [ - "/tests/corpus/3150-integer-remainder.ts" - ], - "diags": [] - }, - "/tests/corpus/3151-array-push-writes.ts": { - "order": [ - "/tests/corpus/3151-array-push-writes.ts" - ], - "diags": [] - }, - "/tests/corpus/3170-number-conversion-fast-paths.ts": { - "order": [ - "/tests/corpus/3170-number-conversion-fast-paths.ts" - ], - "diags": [] - }, - "/tests/corpus/3171-method-census-data-writes.ts": { - "order": [ - "/tests/corpus/3171-method-census-data-writes.ts" - ], - "diags": [] - }, - "/tests/corpus/4032-inline-rc-fast-paths.ts": { - "order": [ - "/tests/corpus/4032-inline-rc-fast-paths.ts" - ], - "diags": [] - }, - "/tests/corpus/4060-stack-union-reads.ts": { - "order": [ - "/tests/corpus/4060-stack-union-reads.ts" - ], - "diags": [] - }, - "/tests/corpus/4061-nullable-ref-fields.ts": { - "order": [ - "/tests/corpus/4061-nullable-ref-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/4140-array-callback-split-visit.ts": { - "order": [ - "/tests/corpus/4140-array-callback-split-visit.ts" - ], - "diags": [] - }, - "/tests/corpus/4141-array-callback-ambient-receiver/main.ts": { - "order": [ - "/tests/corpus/4141-array-callback-ambient-receiver/peek.mjs", - "/tests/corpus/4141-array-callback-ambient-receiver/mapper.ts", - "/tests/corpus/4141-array-callback-ambient-receiver/holder.mjs", - "/tests/corpus/4141-array-callback-ambient-receiver/main.ts" - ], - "diags": [] - }, - "/tests/corpus/4142-array-callback-factories.ts": { - "order": [ - "/tests/corpus/4142-array-callback-factories.ts" - ], - "diags": [] - }, - "/tests/corpus/4143-union-refinement-intersection-arms.ts": { - "order": [ - "/tests/corpus/4143-union-refinement-intersection-arms.ts" - ], - "diags": [] - }, - "/tests/corpus/4290-acyclic-immutable-trees.ts": { - "order": [ - "/tests/corpus/4290-acyclic-immutable-trees.ts" - ], - "diags": [] - }, - "/tests/corpus/4291-acyclic-constructor-escapes.ts": { - "order": [ - "/tests/corpus/4291-acyclic-constructor-escapes.ts" - ], - "diags": [] - }, - "/tests/corpus/4292-acyclic-readonly-bypass.ts": { - "order": [ - "/tests/corpus/4292-acyclic-readonly-bypass.ts" - ], - "diags": [] - }, - "/tests/corpus/4293-acyclic-dynamic-writes.ts": { - "order": [ - "/tests/corpus/4293-acyclic-dynamic-writes.ts" - ], - "diags": [] - }, - "/tests/corpus/4294-console-line-sizes.ts": { - "order": [ - "/tests/corpus/4294-console-line-sizes.ts" - ], - "diags": [] - }, - "/tests/corpus/4295-console-template-parts.ts": { - "order": [ - "/tests/corpus/4295-console-template-parts.ts" - ], - "diags": [] - }, - "/tests/corpus/4296-console-glued-long-parts.ts": { - "order": [ - "/tests/corpus/4296-console-glued-long-parts.ts" - ], - "diags": [] - }, - "/tests/corpus/4410-inline-object-allocation.ts": { - "order": [ - "/tests/corpus/4410-inline-object-allocation.ts" - ], - "diags": [] - }, - "/tests/corpus/4431-exception-pending-contexts.ts": { - "order": [ - "/tests/corpus/4431-exception-pending-contexts.ts" - ], - "diags": [] - }, - "/tests/corpus/4432-checked-downcast-failures.ts": { - "order": [ - "/tests/corpus/4432-checked-downcast-failures.ts" - ], - "diags": [] - }, - "/tests/corpus/array-sort-runtime-comparator.ts": { - "order": [ - "/tests/corpus/array-sort-runtime-comparator.ts" - ], - "diags": [] - }, - "/tests/corpus/closure-union-locals.ts": { - "order": [ - "/tests/corpus/closure-union-locals.ts" - ], - "diags": [] - }, - "/tests/corpus/fiber-switch-stress.ts": { - "order": [ - "/tests/corpus/fiber-switch-stress.ts" - ], - "diags": [] - }, - "/tests/corpus/fiberless-async-ordering.ts": { - "order": [ - "/tests/corpus/fiberless-async-ordering.ts" - ], - "diags": [] - }, - "/tests/corpus/fiberless-async-unhandled.ts": { - "order": [ - "/tests/corpus/fiberless-async-unhandled.ts" - ], - "diags": [] - }, - "/tests/corpus/in-array-runtime-index.ts": { - "order": [ - "/tests/corpus/in-array-runtime-index.ts" - ], - "diags": [] - }, - "/tests/corpus/json-typed-parse-direct.ts": { - "order": [ - "/tests/corpus/json-typed-parse-direct.ts" - ], - "diags": [] - }, - "/tests/corpus/regex-exec-long-subject.ts": { - "order": [ - "/tests/corpus/regex-exec-long-subject.ts" - ], - "diags": [] - }, - "/tests/corpus/regex-native-matcher.ts": { - "order": [ - "/tests/corpus/regex-native-matcher.ts" - ], - "diags": [] - }, - "/tests/corpus/regexp-constructor-repeat.ts": { - "order": [ - "/tests/corpus/regexp-constructor-repeat.ts" - ], - "diags": [] - }, - "/tests/corpus/timers-clear-many.ts": { - "order": [ - "/tests/corpus/timers-clear-many.ts" - ], - "diags": [] - }, - "/tests/corpus/4080-optional-read-presence-tests.ts": { - "order": [ - "/tests/corpus/4080-optional-read-presence-tests.ts" - ], - "diags": [] - }, - "/tests/corpus/4081-hoisted-function-tdz.ts": { - "order": [ - "/tests/corpus/4081-hoisted-function-tdz.ts" - ], - "diags": [] - }, - "/tests/corpus/4082-hoisted-function-tdz-uncaught.ts": { - "order": [ - "/tests/corpus/4082-hoisted-function-tdz-uncaught.ts" - ], - "diags": [] - }, - "/tests/corpus/4083-dynamic-import-failure/main.ts": { - "order": [ - "/tests/corpus/4083-dynamic-import-failure/errors.ts", - "/tests/corpus/4083-dynamic-import-failure/main.ts" - ], - "diags": [] - }, - "/tests/corpus/4084-record-optional-field-copies.ts": { - "order": [ - "/tests/corpus/4084-record-optional-field-copies.ts" - ], - "diags": [] - }, - "/tests/corpus/4085-generator-loop-close.ts": { - "order": [ - "/tests/corpus/4085-generator-loop-close.ts" - ], - "diags": [] - }, - "/tests/corpus/4086-optional-capture-defaults.ts": { - "order": [ - "/tests/corpus/4086-optional-capture-defaults.ts" - ], - "diags": [] - }, - "/tests/diagnostics/unrelated-class-assertion.ts": { - "order": [ - "/tests/diagnostics/unrelated-class-assertion.ts" - ], - "diags": [] - }, - "/tests/corpus/4080-string-index-bounds.ts": { - "order": [ - "/tests/corpus/4080-string-index-bounds.ts" - ], - "diags": [] - }, - "/tests/corpus/4081-string-index-unproven.ts": { - "order": [ - "/tests/corpus/4081-string-index-unproven.ts" - ], - "diags": [] - }, - "/tests/corpus/4088-class-static-tdz.ts": { - "order": [ - "/tests/corpus/4088-class-static-tdz.ts" - ], - "diags": [] - }, - "/tests/corpus/4089-class-wrapper-tdz.js": { - "order": [ - "/tests/corpus/4089-class-wrapper-tdz.js" - ], - "diags": [] - }, - "/tests/corpus/4090-computed-key-tdz.js": { - "order": [ - "/tests/corpus/4090-computed-key-tdz.js" - ], - "diags": [] - }, - "/tests/corpus/4091-class-evaluation-deferred.ts": { - "order": [ - "/tests/corpus/4091-class-evaluation-deferred.ts" - ], - "diags": [] - }, - "/tests/corpus/cycle-growth-yield.ts": { - "order": [ - "/tests/corpus/cycle-growth-yield.ts" - ], - "diags": [] - }, - "/tests/corpus/indexed-element-field-reads.ts": { - "order": [ - "/tests/corpus/indexed-element-field-reads.ts" - ], - "diags": [] - }, - "/tests/corpus/const-enum-module-cycle/main.ts": { - "order": [ - "/tests/corpus/const-enum-module-cycle/flags.ts", - "/tests/corpus/const-enum-module-cycle/rules.ts", - "/tests/corpus/const-enum-module-cycle/limits.ts", - "/tests/corpus/const-enum-module-cycle/main.ts" - ], - "diags": [] - }, - "/tests/corpus/for-of-subclass-elements.ts": { - "order": [ - "/tests/corpus/for-of-subclass-elements.ts" - ], - "diags": [] - }, - "/tests/corpus/nonnull-forwarded-class-values.ts": { - "order": [ - "/tests/corpus/nonnull-forwarded-class-values.ts" - ], - "diags": [] - }, - "/tests/corpus/nullish-asserted-class-arms.ts": { - "order": [ - "/tests/corpus/nullish-asserted-class-arms.ts" - ], - "diags": [] - }, - "/tests/diagnostics/nullish-class-defaults.ts": { - "order": [ - "/tests/diagnostics/nullish-class-defaults.ts" - ], - "diags": [] - }, - "/tests/corpus/nonnull-element-arguments.ts": { - "order": [ - "/tests/corpus/nonnull-element-arguments.ts" - ], - "diags": [] - }, - "/tests/corpus/4520-optional-guard-narrowing.ts": { - "order": [ - "/tests/corpus/4520-optional-guard-narrowing.ts" - ], - "diags": [] - }, - "/tests/corpus/4521-array-callback-element-presence.ts": { - "order": [ - "/tests/corpus/4521-array-callback-element-presence.ts" - ], - "diags": [] - }, - "/tests/corpus/4522-captured-parameter-lifetimes.ts": { - "order": [ - "/tests/corpus/4522-captured-parameter-lifetimes.ts" - ], - "diags": [] - }, - "/tests/corpus/4523-array-pop-removal.ts": { - "order": [ - "/tests/corpus/4523-array-pop-removal.ts" - ], - "diags": [] - }, - "/tests/corpus/4524-array-callback-supertype-params.ts": { - "order": [ - "/tests/corpus/4524-array-callback-supertype-params.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-bounded-errors.ts": { - "order": [ - "/tests/corpus/native-worker-bounded-errors.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-cancel-hot.ts": { - "order": [ - "/tests/corpus/native-worker-cancel-hot.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-class-fields.ts": { - "order": [ - "/tests/corpus/native-worker-class-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-poll-exceptions.ts": { - "order": [ - "/tests/corpus/native-worker-poll-exceptions.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-terminate-recursion.ts": { - "order": [ - "/tests/corpus/native-worker-terminate-recursion.ts" - ], - "diags": [] - }, - "/tests/corpus/error-values-inspect.ts": { - "order": [ - "/tests/corpus/error-values-inspect.ts" - ], - "diags": [] - }, - "/tests/corpus/locale-compare-root-order.ts": { - "order": [ - "/tests/corpus/locale-compare-root-order.ts" - ], - "diags": [] - }, - "/tests/corpus/next-tick-commonjs-entry.cjs": { - "order": [ - "/tests/corpus/next-tick-commonjs-entry.cjs" - ], - "diags": [] - }, - "/tests/corpus/number-parse-statics.ts": { - "order": [ - "/tests/corpus/number-parse-statics.ts" - ], - "diags": [] - }, - "/tests/corpus/process-version-pin.ts": { - "order": [ - "/tests/corpus/process-version-pin.ts" - ], - "diags": [] - }, - "/tests/corpus/repeat-and-typed-read-errors.ts": { - "order": [ - "/tests/corpus/repeat-and-typed-read-errors.ts" - ], - "diags": [] - }, - "/tests/corpus/worker-class-instance-clone.ts": { - "order": [ - "/tests/corpus/worker-class-instance-clone.ts" - ], - "diags": [] - }, - "/tests/corpus/4411-nullable-ref-values.ts": { - "order": [ - "/tests/corpus/4411-nullable-ref-values.ts" - ], - "diags": [] - }, - "/tests/corpus/4412-nullable-record-values.ts": { - "order": [ - "/tests/corpus/4412-nullable-record-values.ts" - ], - "diags": [] - }, - "/tests/corpus/4413-nullable-null-and-undefined.ts": { - "order": [ - "/tests/corpus/4413-nullable-null-and-undefined.ts" - ], - "diags": [] - }, - "/tests/corpus/4414-nullable-string-values.ts": { - "order": [ - "/tests/corpus/4414-nullable-string-values.ts" - ], - "diags": [] - }, - "/tests/corpus/4415-nullable-container-values.ts": { - "order": [ - "/tests/corpus/4415-nullable-container-values.ts" - ], - "diags": [] - }, - "/tests/corpus/4415-identity-borrowed-operands.ts": { - "order": [ - "/tests/corpus/4415-identity-borrowed-operands.ts" - ], - "diags": [] - }, - "/tests/corpus/4451-int32-field-storage.ts": { - "order": [ - "/tests/corpus/4451-int32-field-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/4452-int32-field-dynamic-writes.ts": { - "order": [ - "/tests/corpus/4452-int32-field-dynamic-writes.ts" - ], - "diags": [] - }, - "/tests/corpus/4453-int32-closed-locals.ts": { - "order": [ - "/tests/corpus/4453-int32-closed-locals.ts" - ], - "diags": [] - }, - "/tests/corpus/4476-string-ascii-header-fact.ts": { - "order": [ - "/tests/corpus/4476-string-ascii-header-fact.ts" - ], - "diags": [] - }, - "/tests/corpus/4477-buffer-write-ascii-runs.ts": { - "order": [ - "/tests/corpus/4477-buffer-write-ascii-runs.ts" - ], - "diags": [] - }, - "/tests/corpus/4478-string-large-index-reads.ts": { - "order": [ - "/tests/corpus/4478-string-large-index-reads.ts" - ], - "diags": [] - }, - "/tests/corpus/4481-array-optional-push.ts": { - "order": [ - "/tests/corpus/4481-array-optional-push.ts" - ], - "diags": [] - }, - "/tests/corpus/4482-instanceof-static-class-optional.ts": { - "order": [ - "/tests/corpus/4482-instanceof-static-class-optional.ts" - ], - "diags": [] - }, - "/tests/corpus/4483-array-splice-statement.ts": { - "order": [ - "/tests/corpus/4483-array-splice-statement.ts" - ], - "diags": [] - }, - "/tests/corpus/4484-array-length-reset.ts": { - "order": [ - "/tests/corpus/4484-array-length-reset.ts" - ], - "diags": [] - }, - "/tests/corpus/4485-array-splice-optional-item.ts": { - "order": [ - "/tests/corpus/4485-array-splice-optional-item.ts" - ], - "diags": [] - }, - "/tests/corpus/4486-array-field-element-borrows.ts": { - "order": [ - "/tests/corpus/4486-array-field-element-borrows.ts" - ], - "diags": [] - }, - "/tests/corpus/4487-array-literal-optional-values.ts": { - "order": [ - "/tests/corpus/4487-array-literal-optional-values.ts" - ], - "diags": [] - }, - "/tests/corpus/4560-field-store-borrowed-receivers.ts": { - "order": [ - "/tests/corpus/4560-field-store-borrowed-receivers.ts" - ], - "diags": [] - }, - "/tests/corpus/4561-virtual-borrowed-parameters.ts": { - "order": [ - "/tests/corpus/4561-virtual-borrowed-parameters.ts" - ], - "diags": [] - }, - "/tests/corpus/4562-string-self-concat-move.ts": { - "order": [ - "/tests/corpus/4562-string-self-concat-move.ts" - ], - "diags": [] - }, - "/tests/corpus/4563-array-read-projection-receivers.ts": { - "order": [ - "/tests/corpus/4563-array-read-projection-receivers.ts" - ], - "diags": [] - }, - "/tests/corpus/4564-literal-choice-strings.ts": { - "order": [ - "/tests/corpus/4564-literal-choice-strings.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-stack-overflow.ts": { - "order": [ - "/tests/corpus/native-worker-stack-overflow.ts" - ], - "diags": [] - }, - "/tests/corpus/stack-overflow-async.ts": { - "order": [ - "/tests/corpus/stack-overflow-async.ts" - ], - "diags": [] - }, - "/tests/corpus/stack-overflow-caught.ts": { - "order": [ - "/tests/corpus/stack-overflow-caught.ts" - ], - "diags": [] - }, - "/tests/corpus/stack-overflow-finally.ts": { - "order": [ - "/tests/corpus/stack-overflow-finally.ts" - ], - "diags": [] - }, - "/tests/corpus/stack-overflow-shapes.ts": { - "order": [ - "/tests/corpus/stack-overflow-shapes.ts" - ], - "diags": [] - }, - "/tests/corpus/stack-overflow-uncaught.ts": { - "order": [ - "/tests/corpus/stack-overflow-uncaught.ts" - ], - "diags": [] - }, - "/tests/corpus/4471-unassigned-field-reads.ts": { - "order": [ - "/tests/corpus/4471-unassigned-field-reads.ts" - ], - "diags": [] - }, - "/tests/corpus/stack-depth-async-bodies.ts": { - "order": [ - "/tests/corpus/stack-depth-async-bodies.ts" - ], - "diags": [] - }, - "/tests/corpus/4591-weak-keys-union-records.ts": { - "order": [ - "/tests/corpus/4591-weak-keys-union-records.ts" - ], - "diags": [] - }, - "/tests/corpus/4592-cycle-const-from-import/main.ts": { - "order": [ - "/tests/corpus/4592-cycle-const-from-import/report.ts", - "/tests/corpus/4592-cycle-const-from-import/stock.ts", - "/tests/corpus/4592-cycle-const-from-import/markup.ts", - "/tests/corpus/4592-cycle-const-from-import/pricing.ts", - "/tests/corpus/4592-cycle-const-from-import/main.ts" - ], - "diags": [] - }, - "/tests/corpus/4593-weak-keys-empty-objects.ts": { - "order": [ - "/tests/corpus/4593-weak-keys-empty-objects.ts" - ], - "diags": [] - }, - "/tests/diagnostics/deferred-class-binding/main.ts": { - "order": [ - "/tests/diagnostics/deferred-class-binding/crate.ts", - "/tests/diagnostics/deferred-class-binding/main.ts" - ], - "diags": [] - }, - "/tests/diagnostics/deferred-class-receiver/main.ts": { - "order": [ - "/tests/diagnostics/deferred-class-receiver/shelf.ts", - "/tests/diagnostics/deferred-class-receiver/main.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-publish-classes.ts": { - "order": [ - "/tests/corpus/native-worker-publish-classes.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-publish-refusals.ts": { - "order": [ - "/tests/corpus/native-worker-publish-refusals.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-published-graphs.ts": { - "order": [ - "/tests/corpus/native-worker-published-graphs.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-typed-arrays.ts": { - "order": [ - "/tests/corpus/native-worker-typed-arrays.ts" - ], - "diags": [] - }, - "/tests/corpus/4541-nullable-wrap-borrows.ts": { - "order": [ - "/tests/corpus/4541-nullable-wrap-borrows.ts" - ], - "diags": [] - }, - "/tests/corpus/4542-preserving-call-borrows.ts": { - "order": [ - "/tests/corpus/4542-preserving-call-borrows.ts" - ], - "diags": [] - }, - "/tests/corpus/4544-checked-cast-aliases.ts": { - "order": [ - "/tests/corpus/4544-checked-cast-aliases.ts" - ], - "diags": [] - }, - "/tests/corpus/4543-walk-borrowed-locals.ts": { - "order": [ - "/tests/corpus/4543-walk-borrowed-locals.ts" - ], - "diags": [] - }, - "/tests/corpus/4545-borrowed-returns.ts": { - "order": [ - "/tests/corpus/4545-borrowed-returns.ts" - ], - "diags": [] - }, - "/tests/corpus/4546-rebound-borrowed-params.ts": { - "order": [ - "/tests/corpus/4546-rebound-borrowed-params.ts" - ], - "diags": [] - }, - "/tests/corpus/4568-for-of-hole-elements.ts": { - "order": [ - "/tests/corpus/4568-for-of-hole-elements.ts" - ], - "diags": [] - }, - "/tests/corpus/4569-shorthand-missing-elements.ts": { - "order": [ - "/tests/corpus/4569-shorthand-missing-elements.ts" - ], - "diags": [] - }, - "/tests/corpus/4570-map-lookup-default-record.ts": { - "order": [ - "/tests/corpus/4570-map-lookup-default-record.ts" - ], - "diags": [] - }, - "/tests/corpus/4594-union-class-field-mixed-types.ts": { - "order": [ - "/tests/corpus/4594-union-class-field-mixed-types.ts" - ], - "diags": [] - }, - "/tests/corpus/4595-union-class-field-optional-receiver.ts": { - "order": [ - "/tests/corpus/4595-union-class-field-optional-receiver.ts" - ], - "diags": [] - }, - "/tests/corpus/4596-error-subclass-int-fields.ts": { - "order": [ - "/tests/corpus/4596-error-subclass-int-fields.ts" - ], - "diags": [] - }, - "/tests/corpus/4597-callback-field-method-name.ts": { - "order": [ - "/tests/corpus/4597-callback-field-method-name.ts" - ], - "diags": [] - }, - "/tests/corpus/4596-tdz-nullable-forward-capture.ts": { - "order": [ - "/tests/corpus/4596-tdz-nullable-forward-capture.ts" - ], - "diags": [] - }, - "/tests/corpus/4650-stale-property-narrowing.ts": { - "order": [ - "/tests/corpus/4650-stale-property-narrowing.ts" - ], - "diags": [] - }, - "/tests/corpus/4652-stale-closure-binding-narrowing.ts": { - "order": [ - "/tests/corpus/4652-stale-closure-binding-narrowing.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-arena-reuse.ts": { - "order": [ - "/tests/corpus/native-worker-arena-reuse.ts" - ], - "diags": [] - }, - "/tests/corpus/4598-map-set-clear-reuse.ts": { - "order": [ - "/tests/corpus/4598-map-set-clear-reuse.ts" - ], - "diags": [] - }, - "/tests/corpus/missing-read-lambda-results.ts": { - "order": [ - "/tests/corpus/missing-read-lambda-results.ts" - ], - "diags": [] - }, - "/tests/corpus/missing-read-narrowed-storage.ts": { - "order": [ - "/tests/corpus/missing-read-narrowed-storage.ts" - ], - "diags": [] - }, - "/tests/corpus/missing-read-number-conversions.ts": { - "order": [ - "/tests/corpus/missing-read-number-conversions.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-array-nan-coded-reads.ts": { - "order": [ - "/tests/corpus/typed-array-nan-coded-reads.ts" - ], - "diags": [] - }, - "/tests/corpus/typed-array-present-reads.ts": { - "order": [ - "/tests/corpus/typed-array-present-reads.ts" - ], - "diags": [] - }, - "/tests/corpus/4601-cycle-holders.ts": { - "order": [ - "/tests/corpus/4601-cycle-holders.ts" - ], - "diags": [] - }, - "/tests/corpus/4602-constructor-escape-order.ts": { - "order": [ - "/tests/corpus/4602-constructor-escape-order.ts" - ], - "diags": [] - }, - "/tests/corpus/4598-live-array-ref-element-access.ts": { - "order": [ - "/tests/corpus/4598-live-array-ref-element-access.ts" - ], - "diags": [] - }, - "/tests/corpus/4620-optional-chain-borrowed-receivers.ts": { - "order": [ - "/tests/corpus/4620-optional-chain-borrowed-receivers.ts" - ], - "diags": [] - }, - "/tests/corpus/4621-edge-preserving-callees/main.ts": { - "order": [ - "/tests/corpus/4621-edge-preserving-callees/compare.ts", - "/tests/corpus/4621-edge-preserving-callees/items.ts", - "/tests/corpus/4621-edge-preserving-callees/main.ts" - ], - "diags": [] - }, - "/tests/corpus/exact-index-round-trip.ts": { - "order": [ - "/tests/corpus/exact-index-round-trip.ts" - ], - "diags": [] - }, - "/tests/corpus/final-field-borrows.ts": { - "order": [ - "/tests/corpus/final-field-borrows.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-terminate-tested-loops.ts": { - "order": [ - "/tests/corpus/native-worker-terminate-tested-loops.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-exception-state.ts": { - "order": [ - "/tests/corpus/native-worker-exception-state.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-terminate-exception-state.ts": { - "order": [ - "/tests/corpus/native-worker-terminate-exception-state.ts" - ], - "diags": [] - }, - "/tests/corpus/4598-os-available-parallelism.ts": { - "order": [ - "/tests/corpus/4598-os-available-parallelism.ts" - ], - "diags": [] - }, - "/tests/corpus/constant-module-globals/main.ts": { - "order": [ - "/tests/corpus/constant-module-globals/consts.ts", - "/tests/corpus/constant-module-globals/main.ts" - ], - "diags": [] - }, - "/tests/corpus/4660-typed-rest-spread-forwarding.ts": { - "order": [ - "/tests/corpus/4660-typed-rest-spread-forwarding.ts" - ], - "diags": [] - }, - "/tests/corpus/4610-array-ext-dyn-refresh.ts": { - "order": [ - "/tests/corpus/4610-array-ext-dyn-refresh.ts" - ], - "diags": [] - }, - "/tests/corpus/4690-cycle-bypass-long-lived.ts": { - "order": [ - "/tests/corpus/4690-cycle-bypass-long-lived.ts" - ], - "diags": [] - }, - "/tests/corpus/4671-scoped-array-read-borrows.ts": { - "order": [ - "/tests/corpus/4671-scoped-array-read-borrows.ts" - ], - "diags": [] - }, - "/tests/corpus/switch-integer-dispatch.ts": { - "order": [ - "/tests/corpus/switch-integer-dispatch.ts" - ], - "diags": [] - }, - "/tests/corpus/4651-map-string-get-entry.ts": { - "order": [ - "/tests/corpus/4651-map-string-get-entry.ts" - ], - "diags": [] - } - } -} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/001-hello.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/001-hello.ts.json new file mode 100644 index 000000000..9460882ec --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/001-hello.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/001-hello.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/002-log-args.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/002-log-args.ts.json new file mode 100644 index 000000000..5ed9c2e6b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/002-log-args.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/002-log-args.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/100-number-format.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/100-number-format.ts.json new file mode 100644 index 000000000..89d3b92e0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/100-number-format.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/100-number-format.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1000-json-stringify-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1000-json-stringify-basics.ts.json new file mode 100644 index 000000000..177625ce5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1000-json-stringify-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1000-json-stringify-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1001-json-escapes-unicode.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1001-json-escapes-unicode.ts.json new file mode 100644 index 000000000..b3d3ebf94 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1001-json-escapes-unicode.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1001-json-escapes-unicode.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1002-json-parse-cast.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1002-json-parse-cast.ts.json new file mode 100644 index 000000000..5c056069f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1002-json-parse-cast.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1002-json-parse-cast.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1003-json-parse-unions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1003-json-parse-unions.ts.json new file mode 100644 index 000000000..9aec3b8b8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1003-json-parse-unions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1003-json-parse-unions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1004-json-parse-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1004-json-parse-errors.ts.json new file mode 100644 index 000000000..b41205363 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1004-json-parse-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1004-json-parse-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1005-json-nested.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1005-json-nested.ts.json new file mode 100644 index 000000000..feb5cc8b6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1005-json-nested.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1005-json-nested.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1006-json-fs-config.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1006-json-fs-config.ts.json new file mode 100644 index 000000000..9699352e2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1006-json-fs-config.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1006-json-fs-config.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1007-json-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1007-json-rc-stress.ts.json new file mode 100644 index 000000000..35a67bef4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1007-json-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1007-json-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1008-json-null-arms.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1008-json-null-arms.ts.json new file mode 100644 index 000000000..237499e52 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1008-json-null-arms.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1008-json-null-arms.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1009-json-optional-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1009-json-optional-fields.ts.json new file mode 100644 index 000000000..3f0a8dc81 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1009-json-optional-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1009-json-optional-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/101-arithmetic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/101-arithmetic.ts.json new file mode 100644 index 000000000..8fe77ab21 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/101-arithmetic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/101-arithmetic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1010-json-stringify-space.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1010-json-stringify-space.ts.json new file mode 100644 index 000000000..65e262f42 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1010-json-stringify-space.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1010-json-stringify-space.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1011-json-unknown-typeof.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1011-json-unknown-typeof.ts.json new file mode 100644 index 000000000..4ac0dbbd1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1011-json-unknown-typeof.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1011-json-unknown-typeof.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/102-comparisons.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/102-comparisons.ts.json new file mode 100644 index 000000000..65f0ff9d9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/102-comparisons.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/102-comparisons.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1020-async-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1020-async-basics.ts.json new file mode 100644 index 000000000..671383beb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1020-async-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1020-async-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1021-async-ordering.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1021-async-ordering.ts.json new file mode 100644 index 000000000..279bd14d3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1021-async-ordering.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1021-async-ordering.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1022-async-exceptions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1022-async-exceptions.ts.json new file mode 100644 index 000000000..9638f514b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1022-async-exceptions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1022-async-exceptions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1023-async-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1023-async-rc-stress.ts.json new file mode 100644 index 000000000..c2e613c56 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1023-async-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1023-async-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1024-async-pending-exit.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1024-async-pending-exit.ts.json new file mode 100644 index 000000000..506275c18 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1024-async-pending-exit.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1024-async-pending-exit.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1025-async-promise-capture.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1025-async-promise-capture.ts.json new file mode 100644 index 000000000..9172379e2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1025-async-promise-capture.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1025-async-promise-capture.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1026-throw-promise.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1026-throw-promise.ts.json new file mode 100644 index 000000000..7389bebb5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1026-throw-promise.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1026-throw-promise.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1027-async-return-promise.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1027-async-return-promise.ts.json new file mode 100644 index 000000000..483b91fe4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1027-async-return-promise.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1027-async-return-promise.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1028-async-return-record-literals.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1028-async-return-record-literals.ts.json new file mode 100644 index 000000000..e9fca1a61 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1028-async-return-record-literals.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1028-async-return-record-literals.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1029-async-eager-chains.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1029-async-eager-chains.ts.json new file mode 100644 index 000000000..88edc4a7b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1029-async-eager-chains.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1029-async-eager-chains.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/103-ternary.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/103-ternary.ts.json new file mode 100644 index 000000000..49f628c2a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/103-ternary.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/103-ternary.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/104-ternary-empty-arrays.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/104-ternary-empty-arrays.ts.json new file mode 100644 index 000000000..e845ed12f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/104-ternary-empty-arrays.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/104-ternary-empty-arrays.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1050-comptime-tables.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1050-comptime-tables.ts.json new file mode 100644 index 000000000..46db46084 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1050-comptime-tables.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1050-comptime-tables.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1051-comptime-strings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1051-comptime-strings.ts.json new file mode 100644 index 000000000..835cfa65b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1051-comptime-strings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1051-comptime-strings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1052-comptime-records.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1052-comptime-records.ts.json new file mode 100644 index 000000000..e2d16b584 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1052-comptime-records.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1052-comptime-records.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1053-comptime-json.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1053-comptime-json.ts.json new file mode 100644 index 000000000..7a42e3961 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1053-comptime-json.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1053-comptime-json.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1054-comptime-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1054-comptime-modules/main.ts.json new file mode 100644 index 000000000..26a599aff --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1054-comptime-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1054-comptime-modules/tables.ts", + "/tests/corpus/1054-comptime-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/110-number-radix.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/110-number-radix.ts.json new file mode 100644 index 000000000..97cfaf72d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/110-number-radix.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/110-number-radix.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1100-island-eval-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1100-island-eval-basics.ts.json new file mode 100644 index 000000000..04f563a62 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1100-island-eval-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1100-island-eval-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1101-island-marshal-unicode.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1101-island-marshal-unicode.ts.json new file mode 100644 index 000000000..169cdf74e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1101-island-marshal-unicode.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1101-island-marshal-unicode.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1102-island-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1102-island-rc-stress.ts.json new file mode 100644 index 000000000..05472fd8f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1102-island-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1102-island-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/111-record-entries.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/111-record-entries.ts.json new file mode 100644 index 000000000..1bd8b1bd1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/111-record-entries.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/111-record-entries.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1110-math-members.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1110-math-members.ts.json new file mode 100644 index 000000000..c4f974532 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1110-math-members.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1110-math-members.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1111-math-random.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1111-math-random.ts.json new file mode 100644 index 000000000..f2f0ee65d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1111-math-random.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1111-math-random.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1112-number-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1112-number-methods.ts.json new file mode 100644 index 000000000..c95861fe3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1112-number-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1112-number-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1113-string-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1113-string-methods.ts.json new file mode 100644 index 000000000..cc5895391 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1113-string-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1113-string-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1114-string-unicode-island.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1114-string-unicode-island.ts.json new file mode 100644 index 000000000..d00effab0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1114-string-unicode-island.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1114-string-unicode-island.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1115-parse-globals.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1115-parse-globals.ts.json new file mode 100644 index 000000000..2c1a5ee91 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1115-parse-globals.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1115-parse-globals.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1116-island-static-mix.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1116-island-static-mix.ts.json new file mode 100644 index 000000000..6b79a0b1b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1116-island-static-mix.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1116-island-static-mix.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1117-typeof-static-union.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1117-typeof-static-union.ts.json new file mode 100644 index 000000000..ed001e5a0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1117-typeof-static-union.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1117-typeof-static-union.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1118-object-spread-conditional.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1118-object-spread-conditional.ts.json new file mode 100644 index 000000000..245886ff3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1118-object-spread-conditional.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1118-object-spread-conditional.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1119-switch-union.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1119-switch-union.ts.json new file mode 100644 index 000000000..985c87893 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1119-switch-union.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1119-switch-union.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/112-class-descriptor-key.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/112-class-descriptor-key.js.json new file mode 100644 index 000000000..e8d121b38 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/112-class-descriptor-key.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/112-class-descriptor-key.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1120-web-globals-encoders.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1120-web-globals-encoders.ts.json new file mode 100644 index 000000000..d94210870 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1120-web-globals-encoders.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1120-web-globals-encoders.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1121-infinity-number-tostring.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1121-infinity-number-tostring.ts.json new file mode 100644 index 000000000..a3cfee9b6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1121-infinity-number-tostring.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1121-infinity-number-tostring.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1122-any-captures.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1122-any-captures.ts.json new file mode 100644 index 000000000..4bc522d60 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1122-any-captures.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1122-any-captures.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1123-any-conditional-spread.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1123-any-conditional-spread.ts.json new file mode 100644 index 000000000..7b476f4f2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1123-any-conditional-spread.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1123-any-conditional-spread.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1124-union-narrowed-retag.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1124-union-narrowed-retag.ts.json new file mode 100644 index 000000000..00901d348 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1124-union-narrowed-retag.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1124-union-narrowed-retag.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/113-promise-checked-exits.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/113-promise-checked-exits.ts.json new file mode 100644 index 000000000..6882b7ad6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/113-promise-checked-exits.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/113-promise-checked-exits.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/114-live-record-delete.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/114-live-record-delete.ts.json new file mode 100644 index 000000000..922804a33 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/114-live-record-delete.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/114-live-record-delete.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/115-array-compound.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/115-array-compound.js.json new file mode 100644 index 000000000..9ed14c7e6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/115-array-compound.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/115-array-compound.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/116-text-decoder-runtime.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/116-text-decoder-runtime.js.json new file mode 100644 index 000000000..b0eec0e71 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/116-text-decoder-runtime.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/116-text-decoder-runtime.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/117-weak-cache-cycle.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/117-weak-cache-cycle.js.json new file mode 100644 index 000000000..6fbd315f3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/117-weak-cache-cycle.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/117-weak-cache-cycle.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/118-fs-stored-callbacks.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/118-fs-stored-callbacks.cjs.json new file mode 100644 index 000000000..2ebd84e68 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/118-fs-stored-callbacks.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/118-fs-stored-callbacks.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/119-native-patterns.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/119-native-patterns.js.json new file mode 100644 index 000000000..cac62a727 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/119-native-patterns.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/119-native-patterns.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1200-regex-test-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1200-regex-test-basics.ts.json new file mode 100644 index 000000000..eaa6554b8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1200-regex-test-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1200-regex-test-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1201-regex-replace.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1201-regex-replace.ts.json new file mode 100644 index 000000000..b73b2f3a6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1201-regex-replace.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1201-regex-replace.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1202-regex-substitutions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1202-regex-substitutions.ts.json new file mode 100644 index 000000000..0f3538997 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1202-regex-substitutions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1202-regex-substitutions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1203-regex-split.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1203-regex-split.ts.json new file mode 100644 index 000000000..e490a0576 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1203-regex-split.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1203-regex-split.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1204-regex-empty-unicode.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1204-regex-empty-unicode.ts.json new file mode 100644 index 000000000..8309450f7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1204-regex-empty-unicode.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1204-regex-empty-unicode.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1205-regex-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1205-regex-rc-stress.ts.json new file mode 100644 index 000000000..57ec2ae14 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1205-regex-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1205-regex-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1206-regex-dynamic-mix.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1206-regex-dynamic-mix.ts.json new file mode 100644 index 000000000..644b424e4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1206-regex-dynamic-mix.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1206-regex-dynamic-mix.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1300-errors-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1300-errors-basics.ts.json new file mode 100644 index 000000000..087838667 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1300-errors-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1300-errors-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1301-errors-subclass.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1301-errors-subclass.ts.json new file mode 100644 index 000000000..bb4fff22d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1301-errors-subclass.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1301-errors-subclass.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1302-errors-typed-catch.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1302-errors-typed-catch.ts.json new file mode 100644 index 000000000..a55f8720f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1302-errors-typed-catch.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1302-errors-typed-catch.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1303-errors-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1303-errors-rc-stress.ts.json new file mode 100644 index 000000000..1f282baee --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1303-errors-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1303-errors-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1304-errors-uncaught.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1304-errors-uncaught.ts.json new file mode 100644 index 000000000..07a750bcb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1304-errors-uncaught.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1304-errors-uncaught.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1305-errors-async-rejections.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1305-errors-async-rejections.ts.json new file mode 100644 index 000000000..1830fa526 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1305-errors-async-rejections.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1305-errors-async-rejections.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1306-errors-runtime-instances.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1306-errors-runtime-instances.ts.json new file mode 100644 index 000000000..802b8d806 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1306-errors-runtime-instances.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1306-errors-runtime-instances.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1350-path-normalize-join.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1350-path-normalize-join.ts.json new file mode 100644 index 000000000..197abbefb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1350-path-normalize-join.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1350-path-normalize-join.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1351-path-parts.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1351-path-parts.ts.json new file mode 100644 index 000000000..b4bbccf4b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1351-path-parts.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1351-path-parts.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1352-path-resolve-relative.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1352-path-resolve-relative.ts.json new file mode 100644 index 000000000..3275aec91 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1352-path-resolve-relative.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1352-path-resolve-relative.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1353-os-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1353-os-basics.ts.json new file mode 100644 index 000000000..3f5dad2df --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1353-os-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1353-os-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1354-builtin-bare-specifiers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1354-builtin-bare-specifiers.ts.json new file mode 100644 index 000000000..4ef347d0a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1354-builtin-bare-specifiers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1354-builtin-bare-specifiers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1355-url-parse.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1355-url-parse.ts.json new file mode 100644 index 000000000..14fac6bee --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1355-url-parse.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1355-url-parse.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1356-url-file-bridge.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1356-url-file-bridge.ts.json new file mode 100644 index 000000000..3aa4b18f7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1356-url-file-bridge.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1356-url-file-bridge.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1357-fsp-roundtrip.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1357-fsp-roundtrip.ts.json new file mode 100644 index 000000000..ac667a55a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1357-fsp-roundtrip.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1357-fsp-roundtrip.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1358-crypto-random.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1358-crypto-random.ts.json new file mode 100644 index 000000000..fc6a8d1b1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1358-crypto-random.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1358-crypto-random.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1359-json-module/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1359-json-module/main.ts.json new file mode 100644 index 000000000..caa1c1d17 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1359-json-module/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1359-json-module/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1360-spawn-sync.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1360-spawn-sync.ts.json new file mode 100644 index 000000000..5763f2d44 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1360-spawn-sync.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1360-spawn-sync.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1361-spawn-events.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1361-spawn-events.ts.json new file mode 100644 index 000000000..db69cf992 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1361-spawn-events.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1361-spawn-events.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1362-spawn-timers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1362-spawn-timers.ts.json new file mode 100644 index 000000000..1b904a03b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1362-spawn-timers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1362-spawn-timers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1363-spawn-unhandled-error.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1363-spawn-unhandled-error.ts.json new file mode 100644 index 000000000..53051bb2f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1363-spawn-unhandled-error.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1363-spawn-unhandled-error.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1364-union-truthiness.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1364-union-truthiness.ts.json new file mode 100644 index 000000000..2a830caf8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1364-union-truthiness.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1364-union-truthiness.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1365-union-logical.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1365-union-logical.ts.json new file mode 100644 index 000000000..fbde95453 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1365-union-logical.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1365-union-logical.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1366-union-equality.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1366-union-equality.ts.json new file mode 100644 index 000000000..ec8b58217 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1366-union-equality.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1366-union-equality.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1367-destructuring.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1367-destructuring.ts.json new file mode 100644 index 000000000..64ecc8f05 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1367-destructuring.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1367-destructuring.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1368-constructor-functions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1368-constructor-functions.ts.json new file mode 100644 index 000000000..952b1dd8b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1368-constructor-functions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1368-constructor-functions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1369-promise-union.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1369-promise-union.ts.json new file mode 100644 index 000000000..bfe50a03e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1369-promise-union.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1369-promise-union.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1370-spread.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1370-spread.ts.json new file mode 100644 index 000000000..c5611668b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1370-spread.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1370-spread.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1371-union-template-tostring.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1371-union-template-tostring.ts.json new file mode 100644 index 000000000..c54f03ad5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1371-union-template-tostring.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1371-union-template-tostring.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1372-loose-null-tests.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1372-loose-null-tests.ts.json new file mode 100644 index 000000000..6f93a4ef5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1372-loose-null-tests.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1372-loose-null-tests.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1373-union-array-arms.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1373-union-array-arms.ts.json new file mode 100644 index 000000000..9100e9fc9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1373-union-array-arms.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1373-union-array-arms.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/140-bitwise-operators.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/140-bitwise-operators.ts.json new file mode 100644 index 000000000..421044837 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/140-bitwise-operators.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/140-bitwise-operators.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1400-typedarray-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1400-typedarray-basics.ts.json new file mode 100644 index 000000000..86272b955 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1400-typedarray-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1400-typedarray-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1401-typedarray-slice-set.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1401-typedarray-slice-set.ts.json new file mode 100644 index 000000000..a02a47641 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1401-typedarray-slice-set.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1401-typedarray-slice-set.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1402-buffer-encodings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1402-buffer-encodings.ts.json new file mode 100644 index 000000000..40aeb99d2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1402-buffer-encodings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1402-buffer-encodings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1403-buffer-fs.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1403-buffer-fs.ts.json new file mode 100644 index 000000000..ddcd5346a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1403-buffer-fs.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1403-buffer-fs.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1404-zlib-crypto-bytes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1404-zlib-crypto-bytes.ts.json new file mode 100644 index 000000000..60fc82932 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1404-zlib-crypto-bytes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1404-zlib-crypto-bytes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1405-bytes-unions-arrays.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1405-bytes-unions-arrays.ts.json new file mode 100644 index 000000000..6f6ae8500 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1405-bytes-unions-arrays.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1405-bytes-unions-arrays.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1406-dataview-mp4.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1406-dataview-mp4.ts.json new file mode 100644 index 000000000..35afcc654 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1406-dataview-mp4.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1406-dataview-mp4.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1407-dataview-bounds.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1407-dataview-bounds.ts.json new file mode 100644 index 000000000..0c9a888ce --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1407-dataview-bounds.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1407-dataview-bounds.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1408-string-indexing.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1408-string-indexing.ts.json new file mode 100644 index 000000000..6e10bde5c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1408-string-indexing.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1408-string-indexing.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1409-typedarray-integer-loops.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1409-typedarray-integer-loops.ts.json new file mode 100644 index 000000000..ba8634688 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1409-typedarray-integer-loops.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1409-typedarray-integer-loops.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1420-number-statics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1420-number-statics.ts.json new file mode 100644 index 000000000..02923185f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1420-number-statics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1420-number-statics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1421-number-parse-dynamic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1421-number-parse-dynamic.ts.json new file mode 100644 index 000000000..9a7e6de91 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1421-number-parse-dynamic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1421-number-parse-dynamic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1422-date-iso.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1422-date-iso.ts.json new file mode 100644 index 000000000..815621037 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1422-date-iso.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1422-date-iso.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1423-text-codec.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1423-text-codec.ts.json new file mode 100644 index 000000000..d9e8bdfbd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1423-text-codec.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1423-text-codec.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1424-fs-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1424-fs-options.ts.json new file mode 100644 index 000000000..0ec319028 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1424-fs-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1424-fs-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1425-stdin-tty.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1425-stdin-tty.ts.json new file mode 100644 index 000000000..670bd8534 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1425-stdin-tty.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1425-stdin-tty.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1426-stdin-read.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1426-stdin-read.ts.json new file mode 100644 index 000000000..6ce01746a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1426-stdin-read.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1426-stdin-read.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1427-fromcharcode-lastindexof.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1427-fromcharcode-lastindexof.ts.json new file mode 100644 index 000000000..04e62478f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1427-fromcharcode-lastindexof.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1427-fromcharcode-lastindexof.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1428-settled-await-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1428-settled-await-order.ts.json new file mode 100644 index 000000000..435953b65 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1428-settled-await-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1428-settled-await-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1429-promise-catch-finally.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1429-promise-catch-finally.ts.json new file mode 100644 index 000000000..45aaa56b4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1429-promise-catch-finally.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1429-promise-catch-finally.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1430-promise-race.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1430-promise-race.ts.json new file mode 100644 index 000000000..66728d091 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1430-promise-race.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1430-promise-race.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1431-caught-tostring.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1431-caught-tostring.ts.json new file mode 100644 index 000000000..287bb36de --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1431-caught-tostring.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1431-caught-tostring.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1432-destructured-params.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1432-destructured-params.ts.json new file mode 100644 index 000000000..c944f5a58 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1432-destructured-params.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1432-destructured-params.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1433-filter-narrow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1433-filter-narrow.ts.json new file mode 100644 index 000000000..06180d5c0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1433-filter-narrow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1433-filter-narrow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1434-async-never.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1434-async-never.ts.json new file mode 100644 index 000000000..bc19782ec --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1434-async-never.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1434-async-never.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1435-math-spread.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1435-math-spread.ts.json new file mode 100644 index 000000000..98428aff1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1435-math-spread.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1435-math-spread.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1436-default-undef-param.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1436-default-undef-param.ts.json new file mode 100644 index 000000000..6744a7246 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1436-default-undef-param.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1436-default-undef-param.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1437-pad-default.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1437-pad-default.ts.json new file mode 100644 index 000000000..92360b163 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1437-pad-default.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1437-pad-default.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1438-promise-all.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1438-promise-all.ts.json new file mode 100644 index 000000000..cbe6fe8c9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1438-promise-all.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1438-promise-all.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1440-interval-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1440-interval-basics.ts.json new file mode 100644 index 000000000..07816a115 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1440-interval-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1440-interval-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1441-interval-clear-cross.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1441-interval-clear-cross.ts.json new file mode 100644 index 000000000..c35b31b1e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1441-interval-clear-cross.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1441-interval-clear-cross.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1442-interval-throw.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1442-interval-throw.ts.json new file mode 100644 index 000000000..819dfb3e1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1442-interval-throw.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1442-interval-throw.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1443-signal-handlers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1443-signal-handlers.ts.json new file mode 100644 index 000000000..b131e0dc9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1443-signal-handlers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1443-signal-handlers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1444-exit-listeners.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1444-exit-listeners.ts.json new file mode 100644 index 000000000..508ce679e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1444-exit-listeners.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1444-exit-listeners.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1445-exit-process-exit.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1445-exit-process-exit.ts.json new file mode 100644 index 000000000..6d099b458 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1445-exit-process-exit.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1445-exit-process-exit.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1446-exit-uncaught.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1446-exit-uncaught.ts.json new file mode 100644 index 000000000..b68c0d7c2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1446-exit-uncaught.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1446-exit-uncaught.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1447-stdin-closed-events.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1447-stdin-closed-events.ts.json new file mode 100644 index 000000000..7ecc11c7d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1447-stdin-closed-events.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1447-stdin-closed-events.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1448-stream-columns.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1448-stream-columns.ts.json new file mode 100644 index 000000000..57cdb43e2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1448-stream-columns.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1448-stream-columns.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1450-incdec-expression.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1450-incdec-expression.ts.json new file mode 100644 index 000000000..136a204b7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1450-incdec-expression.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1450-incdec-expression.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1451-instanceof-uint8array-unknown.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1451-instanceof-uint8array-unknown.ts.json new file mode 100644 index 000000000..e0f90fc48 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1451-instanceof-uint8array-unknown.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1451-instanceof-uint8array-unknown.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1452-return-through-finally.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1452-return-through-finally.ts.json new file mode 100644 index 000000000..f9bb6a3d4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1452-return-through-finally.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1452-return-through-finally.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1453-pmap-settled.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1453-pmap-settled.ts.json new file mode 100644 index 000000000..b7060fac3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1453-pmap-settled.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1453-pmap-settled.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1454-nonnull-narrow-and-fcc-bytes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1454-nonnull-narrow-and-fcc-bytes.ts.json new file mode 100644 index 000000000..09495b3ae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1454-nonnull-narrow-and-fcc-bytes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1454-nonnull-narrow-and-fcc-bytes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1455-lambda-union-return-adoption.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1455-lambda-union-return-adoption.ts.json new file mode 100644 index 000000000..1579429c6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1455-lambda-union-return-adoption.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1455-lambda-union-return-adoption.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1460-console-error-warn.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1460-console-error-warn.ts.json new file mode 100644 index 000000000..76e63b9ef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1460-console-error-warn.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1460-console-error-warn.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1461-process-pid-getuid-kill.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1461-process-pid-getuid-kill.ts.json new file mode 100644 index 000000000..85e52e0c3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1461-process-pid-getuid-kill.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1461-process-pid-getuid-kill.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1462-exec-sync.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1462-exec-sync.ts.json new file mode 100644 index 000000000..2a0504f99 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1462-exec-sync.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1462-exec-sync.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1463-timeout-unref.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1463-timeout-unref.ts.json new file mode 100644 index 000000000..128b85a9e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1463-timeout-unref.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1463-timeout-unref.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1464-env-writes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1464-env-writes.ts.json new file mode 100644 index 000000000..1cde135bb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1464-env-writes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1464-env-writes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1465-env-value.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1465-env-value.ts.json new file mode 100644 index 000000000..f38b67e0a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1465-env-value.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1465-env-value.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1466-child-containers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1466-child-containers.ts.json new file mode 100644 index 000000000..f32b669d2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1466-child-containers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1466-child-containers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1467-string-match.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1467-string-match.ts.json new file mode 100644 index 000000000..423a0ef5b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1467-string-match.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1467-string-match.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1468-exec-path.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1468-exec-path.ts.json new file mode 100644 index 000000000..3be174b51 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1468-exec-path.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1468-exec-path.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1469-remove-listener.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1469-remove-listener.ts.json new file mode 100644 index 000000000..3252c1374 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1469-remove-listener.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1469-remove-listener.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1470-child-lifecycle.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1470-child-lifecycle.ts.json new file mode 100644 index 000000000..9dfbc6c1c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1470-child-lifecycle.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1470-child-lifecycle.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1471-child-unref.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1471-child-unref.ts.json new file mode 100644 index 000000000..7ae1ac072 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1471-child-unref.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1471-child-unref.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1472-errno-code.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1472-errno-code.ts.json new file mode 100644 index 000000000..d86b671df --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1472-errno-code.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1472-errno-code.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1473-promisify-execfile.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1473-promisify-execfile.ts.json new file mode 100644 index 000000000..a1cfc1516 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1473-promisify-execfile.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1473-promisify-execfile.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1474-string-decoder.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1474-string-decoder.ts.json new file mode 100644 index 000000000..5a4b1fa26 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1474-string-decoder.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1474-string-decoder.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1475-readline-closed-stdin.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1475-readline-closed-stdin.ts.json new file mode 100644 index 000000000..1da28fb5a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1475-readline-closed-stdin.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1475-readline-closed-stdin.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1476-assign-expression.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1476-assign-expression.ts.json new file mode 100644 index 000000000..0bbbec535 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1476-assign-expression.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1476-assign-expression.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1477-in-expressions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1477-in-expressions.ts.json new file mode 100644 index 000000000..b8e68de7c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1477-in-expressions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1477-in-expressions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1478-promise-reject.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1478-promise-reject.ts.json new file mode 100644 index 000000000..faf641ab5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1478-promise-reject.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1478-promise-reject.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1479-destructuring-assign.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1479-destructuring-assign.ts.json new file mode 100644 index 000000000..df131dbd4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1479-destructuring-assign.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1479-destructuring-assign.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1480-os-network-interfaces.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1480-os-network-interfaces.ts.json new file mode 100644 index 000000000..26c8d14d1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1480-os-network-interfaces.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1480-os-network-interfaces.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1481-string-case-static.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1481-string-case-static.ts.json new file mode 100644 index 000000000..4f082a210 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1481-string-case-static.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1481-string-case-static.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1482-spawnsync-error.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1482-spawnsync-error.ts.json new file mode 100644 index 000000000..0e45af375 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1482-spawnsync-error.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1482-spawnsync-error.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1483-array-slice.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1483-array-slice.ts.json new file mode 100644 index 000000000..a733b4f21 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1483-array-slice.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1483-array-slice.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1520-fs-wider-surface.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1520-fs-wider-surface.ts.json new file mode 100644 index 000000000..7159e8c1d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1520-fs-wider-surface.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1520-fs-wider-surface.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1520-string-split-static.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1520-string-split-static.ts.json new file mode 100644 index 000000000..d5904ce2e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1520-string-split-static.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1520-string-split-static.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1521-fs-lstat-lock.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1521-fs-lstat-lock.ts.json new file mode 100644 index 000000000..281168939 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1521-fs-lstat-lock.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1521-fs-lstat-lock.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1521-string-trim-pad-static.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1521-string-trim-pad-static.ts.json new file mode 100644 index 000000000..9dcd0c75e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1521-string-trim-pad-static.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1521-string-trim-pad-static.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1522-parseint-static.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1522-parseint-static.ts.json new file mode 100644 index 000000000..2790c93b8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1522-parseint-static.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1522-parseint-static.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1522-spawnsync-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1522-spawnsync-options.ts.json new file mode 100644 index 000000000..861c8dd2b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1522-spawnsync-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1522-spawnsync-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1523-isnan-floor-static.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1523-isnan-floor-static.ts.json new file mode 100644 index 000000000..0c6ef6d69 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1523-isnan-floor-static.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1523-isnan-floor-static.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1523-spawn-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1523-spawn-options.ts.json new file mode 100644 index 000000000..efdbd0ea9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1523-spawn-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1523-spawn-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1524-atomics-sleep-static.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1524-atomics-sleep-static.ts.json new file mode 100644 index 000000000..6584fec54 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1524-atomics-sleep-static.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1524-atomics-sleep-static.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1524-catch-narrowing.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1524-catch-narrowing.ts.json new file mode 100644 index 000000000..909ce9640 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1524-catch-narrowing.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1524-catch-narrowing.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1525-child-exit-signal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1525-child-exit-signal.ts.json new file mode 100644 index 000000000..bdca4cfc8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1525-child-exit-signal.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1525-child-exit-signal.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1525-unknown-typeof-validation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1525-unknown-typeof-validation.ts.json new file mode 100644 index 000000000..383b36634 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1525-unknown-typeof-validation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1525-unknown-typeof-validation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1526-set-spread.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1526-set-spread.ts.json new file mode 100644 index 000000000..f16eedefc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1526-set-spread.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1526-set-spread.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1527-logical-mixed-operands.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1527-logical-mixed-operands.ts.json new file mode 100644 index 000000000..fe8f7757e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1527-logical-mixed-operands.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1527-logical-mixed-operands.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1528-delete-records-env.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1528-delete-records-env.ts.json new file mode 100644 index 000000000..cda2fe4de --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1528-delete-records-env.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1528-delete-records-env.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1529-class-with-statics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1529-class-with-statics.ts.json new file mode 100644 index 000000000..686210c64 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1529-class-with-statics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1529-class-with-statics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1530-array-push-variadic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1530-array-push-variadic.ts.json new file mode 100644 index 000000000..1e5e95bf1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1530-array-push-variadic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1530-array-push-variadic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1530-spread-override-completion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1530-spread-override-completion.ts.json new file mode 100644 index 000000000..74150adbc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1530-spread-override-completion.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1530-spread-override-completion.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1531-delete-optional-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1531-delete-optional-fields.ts.json new file mode 100644 index 000000000..2a78c587a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1531-delete-optional-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1531-delete-optional-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1531-process-arch-versions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1531-process-arch-versions.ts.json new file mode 100644 index 000000000..e573f59d1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1531-process-arch-versions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1531-process-arch-versions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1532-array-splice-shift.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1532-array-splice-shift.ts.json new file mode 100644 index 000000000..d64c62681 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1532-array-splice-shift.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1532-array-splice-shift.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1532-union-shared-field-read.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1532-union-shared-field-read.ts.json new file mode 100644 index 000000000..8a21a5fa4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1532-union-shared-field-read.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1532-union-shared-field-read.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1533-bool-equality.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1533-bool-equality.ts.json new file mode 100644 index 000000000..ddaa0e721 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1533-bool-equality.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1533-bool-equality.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1533-path-platform-namespaces.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1533-path-platform-namespaces.ts.json new file mode 100644 index 000000000..d8226480a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1533-path-platform-namespaces.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1533-path-platform-namespaces.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1534-crypto-hash-chain.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1534-crypto-hash-chain.ts.json new file mode 100644 index 000000000..b5dde4b6b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1534-crypto-hash-chain.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1534-crypto-hash-chain.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1534-union-as-arm-cast.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1534-union-as-arm-cast.ts.json new file mode 100644 index 000000000..d85cc51f6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1534-union-as-arm-cast.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1534-union-as-arm-cast.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1535-spawn-fd-stdio.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1535-spawn-fd-stdio.ts.json new file mode 100644 index 000000000..581e88a86 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1535-spawn-fd-stdio.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1535-spawn-fd-stdio.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1535-union-param-defaults.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1535-union-param-defaults.ts.json new file mode 100644 index 000000000..53641289a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1535-union-param-defaults.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1535-union-param-defaults.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1536-destructuring-defaults.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1536-destructuring-defaults.ts.json new file mode 100644 index 000000000..941ae1ba1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1536-destructuring-defaults.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1536-destructuring-defaults.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1536-string-array-sweep.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1536-string-array-sweep.ts.json new file mode 100644 index 000000000..89e4f6e46 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1536-string-array-sweep.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1536-string-array-sweep.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1537-chalk-hybrid/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1537-chalk-hybrid/main.ts.json new file mode 100644 index 000000000..a25c1744e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1537-chalk-hybrid/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1537-chalk-hybrid/colors.ts", + "/tests/corpus/1537-chalk-hybrid/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1537-os-release-spawnsync-stdio.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1537-os-release-spawnsync-stdio.ts.json new file mode 100644 index 000000000..f861e9e8e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1537-os-release-spawnsync-stdio.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1537-os-release-spawnsync-stdio.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1538-await-promiselike-return.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1538-await-promiselike-return.ts.json new file mode 100644 index 000000000..4666c58b5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1538-await-promiselike-return.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1538-await-promiselike-return.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1538-math-static-scalar.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1538-math-static-scalar.ts.json new file mode 100644 index 000000000..a05146ad0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1538-math-static-scalar.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1538-math-static-scalar.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1539-readonly-set-map.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1539-readonly-set-map.ts.json new file mode 100644 index 000000000..45b103e43 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1539-readonly-set-map.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1539-readonly-set-map.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1539-unknown-truthiness.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1539-unknown-truthiness.ts.json new file mode 100644 index 000000000..bbfcc2357 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1539-unknown-truthiness.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1539-unknown-truthiness.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1540-os-userinfo.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1540-os-userinfo.ts.json new file mode 100644 index 000000000..d21984438 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1540-os-userinfo.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1540-os-userinfo.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1540-void-statement.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1540-void-statement.ts.json new file mode 100644 index 000000000..f1ccb3d07 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1540-void-statement.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1540-void-statement.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1541-fs-readdir-dirent.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1541-fs-readdir-dirent.ts.json new file mode 100644 index 000000000..35a828691 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1541-fs-readdir-dirent.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1541-fs-readdir-dirent.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1541-union-keyed-reads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1541-union-keyed-reads.ts.json new file mode 100644 index 000000000..3d9330bd4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1541-union-keyed-reads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1541-union-keyed-reads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1542-map-promise-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1542-map-promise-values.ts.json new file mode 100644 index 000000000..59e1b6bc3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1542-map-promise-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1542-map-promise-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1542-record-literal-into-union.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1542-record-literal-into-union.ts.json new file mode 100644 index 000000000..c9650f54e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1542-record-literal-into-union.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1542-record-literal-into-union.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1543-rest-destructuring.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1543-rest-destructuring.ts.json new file mode 100644 index 000000000..0697bbade --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1543-rest-destructuring.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1543-rest-destructuring.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1543-set-server-handles.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1543-set-server-handles.ts.json new file mode 100644 index 000000000..eb076a058 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1543-set-server-handles.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1543-set-server-handles.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1544-dyn-json-reads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1544-dyn-json-reads.ts.json new file mode 100644 index 000000000..d49edead6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1544-dyn-json-reads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1544-dyn-json-reads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1544-string-matchall.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1544-string-matchall.ts.json new file mode 100644 index 000000000..f9260676d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1544-string-matchall.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1544-string-matchall.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1545-spread-order-and-optional.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1545-spread-order-and-optional.ts.json new file mode 100644 index 000000000..38168a348 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1545-spread-order-and-optional.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1545-spread-order-and-optional.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1546-union-element-reads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1546-union-element-reads.ts.json new file mode 100644 index 000000000..33a87730e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1546-union-element-reads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1546-union-element-reads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1547-computed-key-fold.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1547-computed-key-fold.ts.json new file mode 100644 index 000000000..b1d1e1b21 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1547-computed-key-fold.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1547-computed-key-fold.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1548-boolean-condition-forms.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1548-boolean-condition-forms.ts.json new file mode 100644 index 000000000..bf05a014a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1548-boolean-condition-forms.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1548-boolean-condition-forms.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1549-array-isarray-unions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1549-array-isarray-unions.ts.json new file mode 100644 index 000000000..de059e92d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1549-array-isarray-unions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1549-array-isarray-unions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1550-param-defaults-func-set.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1550-param-defaults-func-set.ts.json new file mode 100644 index 000000000..6841781ac --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1550-param-defaults-func-set.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1550-param-defaults-func-set.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1551-dyn-receiver-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1551-dyn-receiver-methods.ts.json new file mode 100644 index 000000000..c88d11de2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1551-dyn-receiver-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1551-dyn-receiver-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1552-exec-options-record.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1552-exec-options-record.ts.json new file mode 100644 index 000000000..f8b7dcb53 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1552-exec-options-record.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1552-exec-options-record.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1553-truthy-hof-predicates.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1553-truthy-hof-predicates.ts.json new file mode 100644 index 000000000..2bf62ac6d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1553-truthy-hof-predicates.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1553-truthy-hof-predicates.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1554-caught-into-unknown.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1554-caught-into-unknown.ts.json new file mode 100644 index 000000000..bbdb5e03a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1554-caught-into-unknown.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1554-caught-into-unknown.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1555-index-spread-into-declared.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1555-index-spread-into-declared.ts.json new file mode 100644 index 000000000..0eecc0131 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1555-index-spread-into-declared.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1555-index-spread-into-declared.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1556-union-retag-width-arms.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1556-union-retag-width-arms.ts.json new file mode 100644 index 000000000..2d3b228bc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1556-union-retag-width-arms.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1556-union-retag-width-arms.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1557-url-host.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1557-url-host.ts.json new file mode 100644 index 000000000..8f98ec6a7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1557-url-host.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1557-url-host.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1558-any-joins-and-dyn-validation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1558-any-joins-and-dyn-validation.ts.json new file mode 100644 index 000000000..fa67a70bc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1558-any-joins-and-dyn-validation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1558-any-joins-and-dyn-validation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1559-conditional-spread-index-merge.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1559-conditional-spread-index-merge.ts.json new file mode 100644 index 000000000..a54a60758 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1559-conditional-spread-index-merge.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1559-conditional-spread-index-merge.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1560-forof-homogeneous-tuples.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1560-forof-homogeneous-tuples.ts.json new file mode 100644 index 000000000..f2931779e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1560-forof-homogeneous-tuples.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1560-forof-homogeneous-tuples.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1561-forof-strings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1561-forof-strings.ts.json new file mode 100644 index 000000000..b8284ce6d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1561-forof-strings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1561-forof-strings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1561-promise-then.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1561-promise-then.ts.json new file mode 100644 index 000000000..ce32380b1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1561-promise-then.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1561-promise-then.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1562-optional-chain-tails.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1562-optional-chain-tails.ts.json new file mode 100644 index 000000000..533e97c3e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1562-optional-chain-tails.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1562-optional-chain-tails.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1562-spawn-conditional-spread.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1562-spawn-conditional-spread.ts.json new file mode 100644 index 000000000..8dbb22120 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1562-spawn-conditional-spread.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1562-spawn-conditional-spread.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1563-forof-iterator-projections.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1563-forof-iterator-projections.ts.json new file mode 100644 index 000000000..b6bfe7274 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1563-forof-iterator-projections.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1563-forof-iterator-projections.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1563-string-raw-fold.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1563-string-raw-fold.ts.json new file mode 100644 index 000000000..e2a2267d0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1563-string-raw-fold.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1563-string-raw-fold.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1564-fs-watch.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1564-fs-watch.ts.json new file mode 100644 index 000000000..b95c98c02 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1564-fs-watch.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1564-fs-watch.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1564-string-raw.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1564-string-raw.ts.json new file mode 100644 index 000000000..90f0985ba --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1564-string-raw.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1564-string-raw.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1565-spawn-pipe-streams.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1565-spawn-pipe-streams.ts.json new file mode 100644 index 000000000..40a634ef7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1565-spawn-pipe-streams.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1565-spawn-pipe-streams.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1565-union-element-join.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1565-union-element-join.ts.json new file mode 100644 index 000000000..ab2c05372 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1565-union-element-join.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1565-union-element-join.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1566-child-duck-interface.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1566-child-duck-interface.ts.json new file mode 100644 index 000000000..f169996c6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1566-child-duck-interface.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1566-child-duck-interface.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1567-server-close-override.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1567-server-close-override.ts.json new file mode 100644 index 000000000..c8e52d171 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1567-server-close-override.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1567-server-close-override.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1568-x509-fingerprint.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1568-x509-fingerprint.ts.json new file mode 100644 index 000000000..1a3de555b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1568-x509-fingerprint.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1568-x509-fingerprint.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1569-fsp-mkdir-unlink-chmod.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1569-fsp-mkdir-unlink-chmod.ts.json new file mode 100644 index 000000000..03f2500a6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1569-fsp-mkdir-unlink-chmod.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1569-fsp-mkdir-unlink-chmod.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1570-child-unref-kill-reffed.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1570-child-unref-kill-reffed.ts.json new file mode 100644 index 000000000..5b67ffb9f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1570-child-unref-kill-reffed.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1570-child-unref-kill-reffed.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1571-optional-call-tostring-tail.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1571-optional-call-tostring-tail.ts.json new file mode 100644 index 000000000..fba1ec997 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1571-optional-call-tostring-tail.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1571-optional-call-tostring-tail.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1571-stdin-set-raw-mode-non-tty.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1571-stdin-set-raw-mode-non-tty.ts.json new file mode 100644 index 000000000..a5bb65813 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1571-stdin-set-raw-mode-non-tty.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1571-stdin-set-raw-mode-non-tty.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1572-promise-reject-all-tuple.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1572-promise-reject-all-tuple.ts.json new file mode 100644 index 000000000..8e0b60aba --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1572-promise-reject-all-tuple.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1572-promise-reject-all-tuple.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1572-x509-validity-date-gettime.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1572-x509-validity-date-gettime.ts.json new file mode 100644 index 000000000..7338494ec --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1572-x509-validity-date-gettime.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1572-x509-validity-date-gettime.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1573-promisify-execfile-env-spread.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1573-promisify-execfile-env-spread.ts.json new file mode 100644 index 000000000..58e812361 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1573-promisify-execfile-env-spread.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1573-promisify-execfile-env-spread.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1573-tdz-scalar-forward-capture.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1573-tdz-scalar-forward-capture.ts.json new file mode 100644 index 000000000..3f4d4a46b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1573-tdz-scalar-forward-capture.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1573-tdz-scalar-forward-capture.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1574-dyn-optional-method-number-keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1574-dyn-optional-method-number-keys.ts.json new file mode 100644 index 000000000..ff99b0dda --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1574-dyn-optional-method-number-keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1574-dyn-optional-method-number-keys.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1574-promise-all-tuple-literal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1574-promise-all-tuple-literal.ts.json new file mode 100644 index 000000000..207066d6c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1574-promise-all-tuple-literal.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1574-promise-all-tuple-literal.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1575-unknown-assert-into-record.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1575-unknown-assert-into-record.ts.json new file mode 100644 index 000000000..104424dc0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1575-unknown-assert-into-record.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1575-unknown-assert-into-record.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1576-width-coercions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1576-width-coercions.ts.json new file mode 100644 index 000000000..b1b3de991 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1576-width-coercions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1576-width-coercions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1577-url-hostname.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1577-url-hostname.ts.json new file mode 100644 index 000000000..b091a7c82 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1577-url-hostname.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1577-url-hostname.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1578-exec-input-optional.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1578-exec-input-optional.ts.json new file mode 100644 index 000000000..34a55b040 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1578-exec-input-optional.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1578-exec-input-optional.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1579-matchall-index.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1579-matchall-index.ts.json new file mode 100644 index 000000000..19ea9cd7f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1579-matchall-index.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1579-matchall-index.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1580-exec-env-conditional-spread.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1580-exec-env-conditional-spread.ts.json new file mode 100644 index 000000000..73690f4f8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1580-exec-env-conditional-spread.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1580-exec-env-conditional-spread.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1581-declare-const-read.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1581-declare-const-read.ts.json new file mode 100644 index 000000000..3709cd5ca --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1581-declare-const-read.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1581-declare-const-read.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1582-timer-sleep-resolve.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1582-timer-sleep-resolve.ts.json new file mode 100644 index 000000000..f5faeccb4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1582-timer-sleep-resolve.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1582-timer-sleep-resolve.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1583-loops-and-stream-captures.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1583-loops-and-stream-captures.ts.json new file mode 100644 index 000000000..2c2aa63e5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1583-loops-and-stream-captures.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1583-loops-and-stream-captures.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1584-union-field-unassigned.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1584-union-field-unassigned.ts.json new file mode 100644 index 000000000..4643489d8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1584-union-field-unassigned.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1584-union-field-unassigned.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1585-union-field-conditional-ctor.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1585-union-field-conditional-ctor.ts.json new file mode 100644 index 000000000..873ecb76d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1585-union-field-conditional-ctor.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1585-union-field-conditional-ctor.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1586-derived-field-before-super-init.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1586-derived-field-before-super-init.ts.json new file mode 100644 index 000000000..ab7df60e9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1586-derived-field-before-super-init.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1586-derived-field-before-super-init.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1587-any-field-unassigned.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1587-any-field-unassigned.ts.json new file mode 100644 index 000000000..e70b14b5c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1587-any-field-unassigned.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1587-any-field-unassigned.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1590-js-unannotated.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1590-js-unannotated.js.json new file mode 100644 index 000000000..50c17d821 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1590-js-unannotated.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1590-js-unannotated.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1591-js-closures.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1591-js-closures.js.json new file mode 100644 index 000000000..3747d883e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1591-js-closures.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1591-js-closures.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1592-js-classes.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1592-js-classes.js.json new file mode 100644 index 000000000..ab1f7c61b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1592-js-classes.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1592-js-classes.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1593-js-jsdoc-records.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1593-js-jsdoc-records.js.json new file mode 100644 index 000000000..f21596b7d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1593-js-jsdoc-records.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1593-js-jsdoc-records.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1594-js-async.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1594-js-async.js.json new file mode 100644 index 000000000..c24a196e8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1594-js-async.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1594-js-async.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1595-js-island-gap/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1595-js-island-gap/main.js.json new file mode 100644 index 000000000..71f24de61 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1595-js-island-gap/main.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1595-js-island-gap/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1596-cjs-modules/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1596-cjs-modules/main.js.json new file mode 100644 index 000000000..1edd0aa50 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1596-cjs-modules/main.js.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/1596-cjs-modules/lib.js", + "/tests/corpus/1596-cjs-modules/common/index.js", + "/tests/corpus/1596-cjs-modules/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1597-mjs-graph/main.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1597-mjs-graph/main.mjs.json new file mode 100644 index 000000000..b3e2dd324 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1597-mjs-graph/main.mjs.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/1597-mjs-graph/util.mjs", + "/tests/corpus/1597-mjs-graph/stats.mjs", + "/tests/corpus/1597-mjs-graph/main.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1598-cjs-builtin-require/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1598-cjs-builtin-require/main.js.json new file mode 100644 index 000000000..e3173f430 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1598-cjs-builtin-require/main.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1598-cjs-builtin-require/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1599-js-uncaught-throw.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1599-js-uncaught-throw.js.json new file mode 100644 index 000000000..0acf21f5d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1599-js-uncaught-throw.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1599-js-uncaught-throw.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1600-assert-passing.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1600-assert-passing.ts.json new file mode 100644 index 000000000..5212aa5ca --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1600-assert-passing.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1600-assert-passing.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1601-assert-fail-exit.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1601-assert-fail-exit.ts.json new file mode 100644 index 000000000..94795451f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1601-assert-fail-exit.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1601-assert-fail-exit.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1602-assert-caught-error.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1602-assert-caught-error.ts.json new file mode 100644 index 000000000..78e97165f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1602-assert-caught-error.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1602-assert-caught-error.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1603-assert-scalar-messages.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1603-assert-scalar-messages.ts.json new file mode 100644 index 000000000..0597fa1e9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1603-assert-scalar-messages.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1603-assert-scalar-messages.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1604-assert-deep-structures.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1604-assert-deep-structures.ts.json new file mode 100644 index 000000000..0933743e2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1604-assert-deep-structures.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1604-assert-deep-structures.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1605-assert-import-forms.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1605-assert-import-forms.ts.json new file mode 100644 index 000000000..91a54ce71 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1605-assert-import-forms.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1605-assert-import-forms.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1606-assert-strict-module.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1606-assert-strict-module.ts.json new file mode 100644 index 000000000..e434547c8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1606-assert-strict-module.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1606-assert-strict-module.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1607-assert-throws-match.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1607-assert-throws-match.ts.json new file mode 100644 index 000000000..d62cdb07b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1607-assert-throws-match.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1607-assert-throws-match.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1608-cjs-assert/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1608-cjs-assert/main.js.json new file mode 100644 index 000000000..bae739488 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1608-cjs-assert/main.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1608-cjs-assert/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1609-assert-async.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1609-assert-async.ts.json new file mode 100644 index 000000000..6dd4e1d37 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1609-assert-async.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1609-assert-async.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1610-path-win32-full.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1610-path-win32-full.ts.json new file mode 100644 index 000000000..6d3a7a53d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1610-path-win32-full.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1610-path-win32-full.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1611-url-file-bridge-neutral.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1611-url-file-bridge-neutral.ts.json new file mode 100644 index 000000000..795af386c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1611-url-file-bridge-neutral.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1611-url-file-bridge-neutral.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1612-cjs-module-globals.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1612-cjs-module-globals.cjs.json new file mode 100644 index 000000000..908f264f8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1612-cjs-module-globals.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1612-cjs-module-globals.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1613-cjs-esm-proxy-named/main.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1613-cjs-esm-proxy-named/main.mjs.json new file mode 100644 index 000000000..1dcd31359 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1613-cjs-esm-proxy-named/main.mjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1613-cjs-esm-proxy-named/table.cjs", + "/tests/corpus/1613-cjs-esm-proxy-named/main.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1614-js-fence-dodges.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1614-js-fence-dodges.cjs.json new file mode 100644 index 000000000..248b800f6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1614-js-fence-dodges.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1614-js-fence-dodges.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1615-cjs-export-shapes/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1615-cjs-export-shapes/main.cjs.json new file mode 100644 index 000000000..89e6821da --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1615-cjs-export-shapes/main.cjs.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/1615-cjs-export-shapes/table.cjs", + "/tests/corpus/1615-cjs-export-shapes/proxied.cjs", + "/tests/corpus/1615-cjs-export-shapes/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1616-cjs-esm-lexer-invisible/main.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1616-cjs-esm-lexer-invisible/main.mjs.json new file mode 100644 index 000000000..94a1c7bfc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1616-cjs-esm-lexer-invisible/main.mjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1616-cjs-esm-lexer-invisible/cjs.cjs", + "/tests/corpus/1616-cjs-esm-lexer-invisible/main.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1617-cjs-esm-lexer-visible/main.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1617-cjs-esm-lexer-visible/main.mjs.json new file mode 100644 index 000000000..ce2add11b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1617-cjs-esm-lexer-visible/main.mjs.json @@ -0,0 +1,11 @@ +{ + "order": [ + "/tests/corpus/1617-cjs-esm-lexer-visible/shorthand.cjs", + "/tests/corpus/1617-cjs-esm-lexer-visible/assigns.cjs", + "/tests/corpus/1617-cjs-esm-lexer-visible/callval.cjs", + "/tests/corpus/1617-cjs-esm-lexer-visible/getterhead.cjs", + "/tests/corpus/1617-cjs-esm-lexer-visible/wscomma.cjs", + "/tests/corpus/1617-cjs-esm-lexer-visible/main.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1618-cjs-esm-poisoned-tail/main.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1618-cjs-esm-poisoned-tail/main.mjs.json new file mode 100644 index 000000000..e88b06626 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1618-cjs-esm-poisoned-tail/main.mjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1618-cjs-esm-poisoned-tail/cjs.cjs", + "/tests/corpus/1618-cjs-esm-poisoned-tail/main.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1619-cjs-esm-reexport-invisible/main.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1619-cjs-esm-reexport-invisible/main.mjs.json new file mode 100644 index 000000000..ee25d9ddb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1619-cjs-esm-reexport-invisible/main.mjs.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/1619-cjs-esm-reexport-invisible/cjs.cjs", + "/tests/corpus/1619-cjs-esm-reexport-invisible/mid.mjs", + "/tests/corpus/1619-cjs-esm-reexport-invisible/main.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1620-cjs-require-effects-order/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1620-cjs-require-effects-order/main.js.json new file mode 100644 index 000000000..af854ec70 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1620-cjs-require-effects-order/main.js.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/1620-cjs-require-effects-order/greeter.js", + "/tests/corpus/1620-cjs-require-effects-order/status.js", + "/tests/corpus/1620-cjs-require-effects-order/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1621-cjs-require-cache-hit/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1621-cjs-require-cache-hit/main.js.json new file mode 100644 index 000000000..6272294de --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1621-cjs-require-cache-hit/main.js.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1621-cjs-require-cache-hit/counter.js", + "/tests/corpus/1621-cjs-require-cache-hit/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1622-cjs-require-conditional/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1622-cjs-require-conditional/main.js.json new file mode 100644 index 000000000..4e94ae14e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1622-cjs-require-conditional/main.js.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/1622-cjs-require-conditional/taken.js", + "/tests/corpus/1622-cjs-require-conditional/skipped.js", + "/tests/corpus/1622-cjs-require-conditional/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1623-cjs-require-diamond/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1623-cjs-require-diamond/main.js.json new file mode 100644 index 000000000..db459fd3f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1623-cjs-require-diamond/main.js.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/1623-cjs-require-diamond/shared.js", + "/tests/corpus/1623-cjs-require-diamond/left.js", + "/tests/corpus/1623-cjs-require-diamond/right.js", + "/tests/corpus/1623-cjs-require-diamond/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1624-cjs-require-dir-mid-file/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1624-cjs-require-dir-mid-file/main.js.json new file mode 100644 index 000000000..0a225a0da --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1624-cjs-require-dir-mid-file/main.js.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1624-cjs-require-dir-mid-file/common/index.js", + "/tests/corpus/1624-cjs-require-dir-mid-file/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1625-cjs-require-lazy-fn/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1625-cjs-require-lazy-fn/main.js.json new file mode 100644 index 000000000..059e6ad7d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1625-cjs-require-lazy-fn/main.js.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/1625-cjs-require-lazy-fn/lazy.js", + "/tests/corpus/1625-cjs-require-lazy-fn/never.js", + "/tests/corpus/1625-cjs-require-lazy-fn/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1626-cjs-require-mjs/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1626-cjs-require-mjs/main.js.json new file mode 100644 index 000000000..d0511ff1a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1626-cjs-require-mjs/main.js.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/1626-cjs-require-mjs/base.mjs", + "/tests/corpus/1626-cjs-require-mjs/mid.mjs", + "/tests/corpus/1626-cjs-require-mjs/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1627-mjs-import-cjs-requires/main.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1627-mjs-import-cjs-requires/main.mjs.json new file mode 100644 index 000000000..ea2eebd1a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1627-mjs-import-cjs-requires/main.mjs.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/1627-mjs-import-cjs-requires/base.mjs", + "/tests/corpus/1627-mjs-import-cjs-requires/cjspart.js", + "/tests/corpus/1627-mjs-import-cjs-requires/main.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1628-checked-dynamic-builtin-args.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1628-checked-dynamic-builtin-args.cjs.json new file mode 100644 index 000000000..500a27e15 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1628-checked-dynamic-builtin-args.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1628-checked-dynamic-builtin-args.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1629-require-main-filename.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1629-require-main-filename.cjs.json new file mode 100644 index 000000000..a8c4e60b6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1629-require-main-filename.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1629-require-main-filename.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1630-inspect-scalars.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1630-inspect-scalars.ts.json new file mode 100644 index 000000000..7acf3f4f7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1630-inspect-scalars.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1630-inspect-scalars.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1630-rmsync-retry-options.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1630-rmsync-retry-options.cjs.json new file mode 100644 index 000000000..2fe16c7e4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1630-rmsync-retry-options.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1630-rmsync-retry-options.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1631-inspect-arrays.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1631-inspect-arrays.ts.json new file mode 100644 index 000000000..0cf6476da --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1631-inspect-arrays.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1631-inspect-arrays.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1632-inspect-records.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1632-inspect-records.ts.json new file mode 100644 index 000000000..6644902ef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1632-inspect-records.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1632-inspect-records.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1633-inspect-map-set.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1633-inspect-map-set.ts.json new file mode 100644 index 000000000..35efcf754 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1633-inspect-map-set.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1633-inspect-map-set.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1634-inspect-classes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1634-inspect-classes.ts.json new file mode 100644 index 000000000..35fc59c83 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1634-inspect-classes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1634-inspect-classes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1635-inspect-buffer.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1635-inspect-buffer.ts.json new file mode 100644 index 000000000..abfb3680a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1635-inspect-buffer.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1635-inspect-buffer.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1636-util-format.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1636-util-format.ts.json new file mode 100644 index 000000000..a9dbbd503 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1636-util-format.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1636-util-format.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1637-inspect-dyn.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1637-inspect-dyn.ts.json new file mode 100644 index 000000000..122dd6468 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1637-inspect-dyn.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1637-inspect-dyn.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1638-inspect-cjs.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1638-inspect-cjs.cjs.json new file mode 100644 index 000000000..da735df72 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1638-inspect-cjs.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1638-inspect-cjs.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1639-versions-openssl-probe.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1639-versions-openssl-probe.ts.json new file mode 100644 index 000000000..82556fcdf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1639-versions-openssl-probe.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1639-versions-openssl-probe.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1640-fd-read-decode.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1640-fd-read-decode.ts.json new file mode 100644 index 000000000..34cb7323f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1640-fd-read-decode.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1640-fd-read-decode.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1641-string-search.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1641-string-search.ts.json new file mode 100644 index 000000000..b6140458c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1641-string-search.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1641-string-search.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1642-object-fromentries-rows.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1642-object-fromentries-rows.ts.json new file mode 100644 index 000000000..410664dd0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1642-object-fromentries-rows.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1642-object-fromentries-rows.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1643-metadata-dyn-return.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1643-metadata-dyn-return.cjs.json new file mode 100644 index 000000000..94a66cd3a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1643-metadata-dyn-return.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1643-metadata-dyn-return.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1644-ee-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1644-ee-basics.ts.json new file mode 100644 index 000000000..6fa6da7a6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1644-ee-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1644-ee-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1645-ee-extends.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1645-ee-extends.ts.json new file mode 100644 index 000000000..1323bb405 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1645-ee-extends.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1645-ee-extends.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1646-ee-once-remove.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1646-ee-once-remove.ts.json new file mode 100644 index 000000000..9e020f0b3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1646-ee-once-remove.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1646-ee-once-remove.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1647-ee-meta-events.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1647-ee-meta-events.ts.json new file mode 100644 index 000000000..69af3c433 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1647-ee-meta-events.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1647-ee-meta-events.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1648-ee-error-event.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1648-ee-error-event.ts.json new file mode 100644 index 000000000..5015df9df --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1648-ee-error-event.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1648-ee-error-event.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1649-ee-names-counts.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1649-ee-names-counts.ts.json new file mode 100644 index 000000000..4a1d7f125 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1649-ee-names-counts.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1649-ee-names-counts.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1650-ee-prepend.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1650-ee-prepend.ts.json new file mode 100644 index 000000000..5d5eb82f8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1650-ee-prepend.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1650-ee-prepend.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1651-ee-max-listeners.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1651-ee-max-listeners.ts.json new file mode 100644 index 000000000..22a40f8e4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1651-ee-max-listeners.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1651-ee-max-listeners.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1652-ee-snapshot.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1652-ee-snapshot.ts.json new file mode 100644 index 000000000..8b391088c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1652-ee-snapshot.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1652-ee-snapshot.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1653-ee-cjs.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1653-ee-cjs.cjs.json new file mode 100644 index 000000000..ffb040e0f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1653-ee-cjs.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1653-ee-cjs.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1654-ee-namespace.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1654-ee-namespace.ts.json new file mode 100644 index 000000000..461ff07e0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1654-ee-namespace.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1654-ee-namespace.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1655-spawnsync-neutral.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1655-spawnsync-neutral.ts.json new file mode 100644 index 000000000..40e175158 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1655-spawnsync-neutral.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1655-spawnsync-neutral.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1656-execsync-neutral.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1656-execsync-neutral.ts.json new file mode 100644 index 000000000..a093a5b57 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1656-execsync-neutral.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1656-execsync-neutral.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1657-spawn-async-neutral.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1657-spawn-async-neutral.ts.json new file mode 100644 index 000000000..74ae687e2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1657-spawn-async-neutral.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1657-spawn-async-neutral.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1660-buffer-read-write-num.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1660-buffer-read-write-num.ts.json new file mode 100644 index 000000000..7bbbc1ea1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1660-buffer-read-write-num.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1660-buffer-read-write-num.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1661-buffer-encodings-full.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1661-buffer-encodings-full.ts.json new file mode 100644 index 000000000..4f6fd7d4c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1661-buffer-encodings-full.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1661-buffer-encodings-full.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1662-string-decoder-encodings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1662-string-decoder-encodings.ts.json new file mode 100644 index 000000000..8cd532054 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1662-string-decoder-encodings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1662-string-decoder-encodings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1663-buffer-compare-search-fill.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1663-buffer-compare-search-fill.ts.json new file mode 100644 index 000000000..a9e9e8e83 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1663-buffer-compare-search-fill.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1663-buffer-compare-search-fill.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1664-dyn-fn-boundary.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1664-dyn-fn-boundary.cjs.json new file mode 100644 index 000000000..10b4c9980 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1664-dyn-fn-boundary.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1664-dyn-fn-boundary.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1665-dyn-fn-mustcall/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1665-dyn-fn-mustcall/main.cjs.json new file mode 100644 index 000000000..1f5c64b6d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1665-dyn-fn-mustcall/main.cjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1665-dyn-fn-mustcall/common.cjs", + "/tests/corpus/1665-dyn-fn-mustcall/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1666-dyn-fn-identity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1666-dyn-fn-identity.ts.json new file mode 100644 index 000000000..9eda5315d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1666-dyn-fn-identity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1666-dyn-fn-identity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1667-dyn-fn-not-callable.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1667-dyn-fn-not-callable.cjs.json new file mode 100644 index 000000000..0d75efe8e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1667-dyn-fn-not-callable.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1667-dyn-fn-not-callable.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1668-dyn-fn-throws.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1668-dyn-fn-throws.cjs.json new file mode 100644 index 000000000..7ecb4e8f5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1668-dyn-fn-throws.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1668-dyn-fn-throws.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1669-symbol-identity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1669-symbol-identity.ts.json new file mode 100644 index 000000000..dd077fd18 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1669-symbol-identity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1669-symbol-identity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1670-symbol-registry.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1670-symbol-registry.ts.json new file mode 100644 index 000000000..1ff59b9e3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1670-symbol-registry.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1670-symbol-registry.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1671-symbol-typeof.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1671-symbol-typeof.ts.json new file mode 100644 index 000000000..ea468099c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1671-symbol-typeof.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1671-symbol-typeof.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1672-symbol-containers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1672-symbol-containers.ts.json new file mode 100644 index 000000000..ee14e6bd9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1672-symbol-containers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1672-symbol-containers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1673-symbol-cjs.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1673-symbol-cjs.cjs.json new file mode 100644 index 000000000..e424cda1f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1673-symbol-cjs.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1673-symbol-cjs.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1674-symbol-inspect.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1674-symbol-inspect.ts.json new file mode 100644 index 000000000..e33e72042 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1674-symbol-inspect.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1674-symbol-inspect.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1676-func-array-surface.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1676-func-array-surface.ts.json new file mode 100644 index 000000000..6409da37d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1676-func-array-surface.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1676-func-array-surface.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1677-emitter-listeners.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1677-emitter-listeners.ts.json new file mode 100644 index 000000000..05dee718a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1677-emitter-listeners.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1677-emitter-listeners.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1678-emitter-dyn-listeners.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1678-emitter-dyn-listeners.cjs.json new file mode 100644 index 000000000..03a8e773f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1678-emitter-dyn-listeners.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1678-emitter-dyn-listeners.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1679-console-dyn.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1679-console-dyn.js.json new file mode 100644 index 000000000..894ed07a4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1679-console-dyn.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1679-console-dyn.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1680-assert-bytes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1680-assert-bytes.ts.json new file mode 100644 index 000000000..85fc0eb27 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1680-assert-bytes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1680-assert-bytes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1681-assert-funcs.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1681-assert-funcs.ts.json new file mode 100644 index 000000000..aa54b1604 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1681-assert-funcs.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1681-assert-funcs.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1685-stream-readable-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1685-stream-readable-basics.ts.json new file mode 100644 index 000000000..5ef58b512 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1685-stream-readable-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1685-stream-readable-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1686-stream-readable-paused.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1686-stream-readable-paused.ts.json new file mode 100644 index 000000000..485771454 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1686-stream-readable-paused.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1686-stream-readable-paused.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1687-stream-readable-flow-control.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1687-stream-readable-flow-control.ts.json new file mode 100644 index 000000000..51ecfd659 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1687-stream-readable-flow-control.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1687-stream-readable-flow-control.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1688-stream-writable-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1688-stream-writable-basics.ts.json new file mode 100644 index 000000000..97ebaa560 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1688-stream-writable-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1688-stream-writable-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1689-stream-writable-async-drain.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1689-stream-writable-async-drain.ts.json new file mode 100644 index 000000000..a80a46b57 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1689-stream-writable-async-drain.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1689-stream-writable-async-drain.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1690-stream-duplex.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1690-stream-duplex.ts.json new file mode 100644 index 000000000..ede62f671 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1690-stream-duplex.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1690-stream-duplex.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1691-stream-transform.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1691-stream-transform.ts.json new file mode 100644 index 000000000..892a680fd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1691-stream-transform.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1691-stream-transform.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1692-stream-pipe.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1692-stream-pipe.ts.json new file mode 100644 index 000000000..181235a47 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1692-stream-pipe.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1692-stream-pipe.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1693-stream-pipe-backpressure.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1693-stream-pipe-backpressure.ts.json new file mode 100644 index 000000000..154040230 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1693-stream-pipe-backpressure.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1693-stream-pipe-backpressure.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1694-stream-destroy.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1694-stream-destroy.ts.json new file mode 100644 index 000000000..fa4bae4d9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1694-stream-destroy.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1694-stream-destroy.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1695-stream-props.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1695-stream-props.ts.json new file mode 100644 index 000000000..a157613fd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1695-stream-props.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1695-stream-props.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1696-stream-read-inside-read.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1696-stream-read-inside-read.ts.json new file mode 100644 index 000000000..9f9b1bb5a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1696-stream-read-inside-read.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1696-stream-read-inside-read.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1697-stream-tick-vs-timer.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1697-stream-tick-vs-timer.ts.json new file mode 100644 index 000000000..fe609653d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1697-stream-tick-vs-timer.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1697-stream-tick-vs-timer.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1698-stream-uncaught-error.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1698-stream-uncaught-error.ts.json new file mode 100644 index 000000000..482377b37 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1698-stream-uncaught-error.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1698-stream-uncaught-error.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1699-stream-callback-shapes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1699-stream-callback-shapes.ts.json new file mode 100644 index 000000000..2972500f1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1699-stream-callback-shapes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1699-stream-callback-shapes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1700-mustcall-common/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1700-mustcall-common/main.cjs.json new file mode 100644 index 000000000..608acc2b9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1700-mustcall-common/main.cjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1700-mustcall-common/common.cjs", + "/tests/corpus/1700-mustcall-common/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1701-mustcall-exit-report/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1701-mustcall-exit-report/main.cjs.json new file mode 100644 index 000000000..05848b0d7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1701-mustcall-exit-report/main.cjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1701-mustcall-exit-report/common.cjs", + "/tests/corpus/1701-mustcall-exit-report/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1702-dyn-proto-dispatch.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1702-dyn-proto-dispatch.cjs.json new file mode 100644 index 000000000..13709f057 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1702-dyn-proto-dispatch.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1702-dyn-proto-dispatch.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1703-arguments-rest-props.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1703-arguments-rest-props.cjs.json new file mode 100644 index 000000000..bf99dad65 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1703-arguments-rest-props.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1703-arguments-rest-props.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1710-cjs-export-class/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1710-cjs-export-class/main.js.json new file mode 100644 index 000000000..3b365651b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1710-cjs-export-class/main.js.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1710-cjs-export-class/countdown.js", + "/tests/corpus/1710-cjs-export-class/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1711-cjs-export-single-values/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1711-cjs-export-single-values/main.js.json new file mode 100644 index 000000000..efebb3fde --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1711-cjs-export-single-values/main.js.json @@ -0,0 +1,11 @@ +{ + "order": [ + "/tests/corpus/1711-cjs-export-single-values/double.js", + "/tests/corpus/1711-cjs-export-single-values/limit.js", + "/tests/corpus/1711-cjs-export-single-values/version.js", + "/tests/corpus/1711-cjs-export-single-values/offset.js", + "/tests/corpus/1711-cjs-export-single-values/enabled.js", + "/tests/corpus/1711-cjs-export-single-values/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1712-field-incdec.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1712-field-incdec.ts.json new file mode 100644 index 000000000..4011be28e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1712-field-incdec.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1712-field-incdec.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1713-js-dyn-fields.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1713-js-dyn-fields.js.json new file mode 100644 index 000000000..425ad93e5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1713-js-dyn-fields.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1713-js-dyn-fields.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1720-assert-throws-shape.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1720-assert-throws-shape.ts.json new file mode 100644 index 000000000..6143cc5a3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1720-assert-throws-shape.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1720-assert-throws-shape.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1721-assert-throws-regex-class.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1721-assert-throws-regex-class.ts.json new file mode 100644 index 000000000..b00fd7a9d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1721-assert-throws-regex-class.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1721-assert-throws-regex-class.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1722-assert-rejects.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1722-assert-rejects.ts.json new file mode 100644 index 000000000..7eb474cca --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1722-assert-rejects.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1722-assert-rejects.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1723-assert-does-not-reject.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1723-assert-does-not-reject.ts.json new file mode 100644 index 000000000..8b60e173b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1723-assert-does-not-reject.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1723-assert-does-not-reject.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1724-assert-iferror.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1724-assert-iferror.ts.json new file mode 100644 index 000000000..1e3c1c72d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1724-assert-iferror.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1724-assert-iferror.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1725-assert-symbols.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1725-assert-symbols.ts.json new file mode 100644 index 000000000..22e6496eb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1725-assert-symbols.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1725-assert-symbols.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1726-promise-with-resolvers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1726-promise-with-resolvers.ts.json new file mode 100644 index 000000000..d6122276e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1726-promise-with-resolvers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1726-promise-with-resolvers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1727-assert-throws-shape-exit.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1727-assert-throws-shape-exit.ts.json new file mode 100644 index 000000000..2c08aad88 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1727-assert-throws-shape-exit.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1727-assert-throws-shape-exit.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1730-countdown-symbol-keys/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1730-countdown-symbol-keys/main.js.json new file mode 100644 index 000000000..43695092f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1730-countdown-symbol-keys/main.js.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/1730-countdown-symbol-keys/index.js", + "/tests/corpus/1730-countdown-symbol-keys/countdown.js", + "/tests/corpus/1730-countdown-symbol-keys/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1731-symbol-field-shapes.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1731-symbol-field-shapes.cjs.json new file mode 100644 index 000000000..f2c6b126d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1731-symbol-field-shapes.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1731-symbol-field-shapes.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1732-symbol-field-cross-module/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1732-symbol-field-cross-module/main.js.json new file mode 100644 index 000000000..e3ed36509 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1732-symbol-field-cross-module/main.js.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1732-symbol-field-cross-module/timer.js", + "/tests/corpus/1732-symbol-field-cross-module/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1740-stream-extends-readable.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1740-stream-extends-readable.ts.json new file mode 100644 index 000000000..8288bc2c4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1740-stream-extends-readable.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1740-stream-extends-readable.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1741-stream-extends-writable.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1741-stream-extends-writable.ts.json new file mode 100644 index 000000000..7096042d9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1741-stream-extends-writable.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1741-stream-extends-writable.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1742-stream-extends-duplex-transform.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1742-stream-extends-duplex-transform.ts.json new file mode 100644 index 000000000..8e99d7efc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1742-stream-extends-duplex-transform.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1742-stream-extends-duplex-transform.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1743-stream-extends-vt-dispatch.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1743-stream-extends-vt-dispatch.ts.json new file mode 100644 index 000000000..c4b0efe63 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1743-stream-extends-vt-dispatch.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1743-stream-extends-vt-dispatch.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1744-stream-set-encoding.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1744-stream-set-encoding.ts.json new file mode 100644 index 000000000..196b55fac --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1744-stream-set-encoding.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1744-stream-set-encoding.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1745-stream-encoding-js.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1745-stream-encoding-js.cjs.json new file mode 100644 index 000000000..9c1227720 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1745-stream-encoding-js.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1745-stream-encoding-js.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1746-stream-for-await.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1746-stream-for-await.ts.json new file mode 100644 index 000000000..523cf34a1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1746-stream-for-await.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1746-stream-for-await.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1747-stream-for-await-js.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1747-stream-for-await-js.cjs.json new file mode 100644 index 000000000..c1afc2092 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1747-stream-for-await-js.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1747-stream-for-await-js.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1750-http-agent-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1750-http-agent-options.ts.json new file mode 100644 index 000000000..52f8745e6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1750-http-agent-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1750-http-agent-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1751-options-record-stance.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1751-options-record-stance.ts.json new file mode 100644 index 000000000..490c84edd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1751-options-record-stance.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1751-options-record-stance.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1760-surplus-args-drop.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1760-surplus-args-drop.cjs.json new file mode 100644 index 000000000..1dffcdcaf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1760-surplus-args-drop.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1760-surplus-args-drop.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1761-emitter-special-event-names.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1761-emitter-special-event-names.cjs.json new file mode 100644 index 000000000..e9d4d2a80 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1761-emitter-special-event-names.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1761-emitter-special-event-names.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1770-assert-dyn-strict.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1770-assert-dyn-strict.ts.json new file mode 100644 index 000000000..2356b3d74 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1770-assert-dyn-strict.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1770-assert-dyn-strict.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1771-assert-dyn-deep.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1771-assert-dyn-deep.ts.json new file mode 100644 index 000000000..98364c264 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1771-assert-dyn-deep.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1771-assert-dyn-deep.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1772-assert-dyn-js.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1772-assert-dyn-js.cjs.json new file mode 100644 index 000000000..b8cd1bed5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1772-assert-dyn-js.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1772-assert-dyn-js.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1773-assert-dyn-exit.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1773-assert-dyn-exit.ts.json new file mode 100644 index 000000000..ad11d807d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1773-assert-dyn-exit.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1773-assert-dyn-exit.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1780-http-res-surface.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1780-http-res-surface.ts.json new file mode 100644 index 000000000..505991733 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1780-http-res-surface.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1780-http-res-surface.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1781-http-server-shapes.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1781-http-server-shapes.cjs.json new file mode 100644 index 000000000..e69af1047 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1781-http-server-shapes.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1781-http-server-shapes.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1790-computed-key-folds.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1790-computed-key-folds.ts.json new file mode 100644 index 000000000..05d5898d8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1790-computed-key-folds.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1790-computed-key-folds.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1791-searchparams-core.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1791-searchparams-core.ts.json new file mode 100644 index 000000000..11354dd98 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1791-searchparams-core.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1791-searchparams-core.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1792-searchparams-encoding.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1792-searchparams-encoding.ts.json new file mode 100644 index 000000000..358a490b8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1792-searchparams-encoding.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1792-searchparams-encoding.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1793-searchparams-iteration.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1793-searchparams-iteration.ts.json new file mode 100644 index 000000000..32e9cbd8b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1793-searchparams-iteration.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1793-searchparams-iteration.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1794-searchparams-url-live.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1794-searchparams-url-live.ts.json new file mode 100644 index 000000000..dbd7cfa8e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1794-searchparams-url-live.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1794-searchparams-url-live.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1795-dyn-handle-request.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1795-dyn-handle-request.cjs.json new file mode 100644 index 000000000..7864adf34 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1795-dyn-handle-request.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1795-dyn-handle-request.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1796-dyn-handle-body.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1796-dyn-handle-body.cjs.json new file mode 100644 index 000000000..4c4f0f5dd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1796-dyn-handle-body.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1796-dyn-handle-body.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1797-dyn-handle-socket.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1797-dyn-handle-socket.cjs.json new file mode 100644 index 000000000..f09d50611 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1797-dyn-handle-socket.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1797-dyn-handle-socket.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1798-dyn-handle-typed-box.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1798-dyn-handle-typed-box.ts.json new file mode 100644 index 000000000..480d2fba4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1798-dyn-handle-typed-box.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1798-dyn-handle-typed-box.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1800-immediate-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1800-immediate-basics.ts.json new file mode 100644 index 000000000..6168d6231 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1800-immediate-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1800-immediate-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1801-immediate-handle.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1801-immediate-handle.ts.json new file mode 100644 index 000000000..e2655c0e5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1801-immediate-handle.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1801-immediate-handle.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1802-immediate-unref-exit.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1802-immediate-unref-exit.ts.json new file mode 100644 index 000000000..2edccc761 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1802-immediate-unref-exit.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1802-immediate-unref-exit.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1803-timeout-refresh.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1803-timeout-refresh.ts.json new file mode 100644 index 000000000..28e5aea30 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1803-timeout-refresh.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1803-timeout-refresh.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1804-timers-module.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1804-timers-module.ts.json new file mode 100644 index 000000000..a6994d71c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1804-timers-module.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1804-timers-module.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1805-timer-callback-args.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1805-timer-callback-args.ts.json new file mode 100644 index 000000000..04248ed9a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1805-timer-callback-args.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1805-timer-callback-args.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1806-timer-delay-trunc.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1806-timer-delay-trunc.ts.json new file mode 100644 index 000000000..d3600bf68 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1806-timer-delay-trunc.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1806-timer-delay-trunc.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1810-stream-options-const-record.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1810-stream-options-const-record.ts.json new file mode 100644 index 000000000..24ee11d8e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1810-stream-options-const-record.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1810-stream-options-const-record.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1811-stream-option-value-callbacks.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1811-stream-option-value-callbacks.cjs.json new file mode 100644 index 000000000..50b3f5a32 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1811-stream-option-value-callbacks.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1811-stream-option-value-callbacks.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1812-stream-super-options-forwarding.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1812-stream-super-options-forwarding.cjs.json new file mode 100644 index 000000000..5646c2974 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1812-stream-super-options-forwarding.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1812-stream-super-options-forwarding.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1813-stream-finished.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1813-stream-finished.ts.json new file mode 100644 index 000000000..3087585f7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1813-stream-finished.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1813-stream-finished.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1814-stream-pipeline.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1814-stream-pipeline.cjs.json new file mode 100644 index 000000000..5ff83a143 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1814-stream-pipeline.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1814-stream-pipeline.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1815-stream-state-reads.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1815-stream-state-reads.cjs.json new file mode 100644 index 000000000..9f463972e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1815-stream-state-reads.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1815-stream-state-reads.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1820-static-block-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1820-static-block-basics.ts.json new file mode 100644 index 000000000..3c894cc40 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1820-static-block-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1820-static-block-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1821-static-block-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1821-static-block-order.ts.json new file mode 100644 index 000000000..9c059d441 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1821-static-block-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1821-static-block-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1822-static-block-js.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1822-static-block-js.js.json new file mode 100644 index 000000000..9d9c02bd6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1822-static-block-js.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1822-static-block-js.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1823-static-instance-method-names.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1823-static-instance-method-names.ts.json new file mode 100644 index 000000000..7f475eff1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1823-static-instance-method-names.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1823-static-instance-method-names.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1824-for-of-destructuring-defaults.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1824-for-of-destructuring-defaults.ts.json new file mode 100644 index 000000000..c88c78350 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1824-for-of-destructuring-defaults.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1824-for-of-destructuring-defaults.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1825-exhaustive-typeof-switch.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1825-exhaustive-typeof-switch.ts.json new file mode 100644 index 000000000..c63e63330 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1825-exhaustive-typeof-switch.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1825-exhaustive-typeof-switch.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1826-settimeout-arguments-callback.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1826-settimeout-arguments-callback.js.json new file mode 100644 index 000000000..571470f9b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1826-settimeout-arguments-callback.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1826-settimeout-arguments-callback.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1830-enum-numeric-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1830-enum-numeric-basics.ts.json new file mode 100644 index 000000000..5942e5453 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1830-enum-numeric-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1830-enum-numeric-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1831-enum-string-const-reverse.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1831-enum-string-const-reverse.ts.json new file mode 100644 index 000000000..dbbadb979 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1831-enum-string-const-reverse.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1831-enum-string-const-reverse.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1832-enum-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1832-enum-modules/main.ts.json new file mode 100644 index 000000000..03dae24dd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1832-enum-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1832-enum-modules/lib.ts", + "/tests/corpus/1832-enum-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1835-var-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1835-var-basics.ts.json new file mode 100644 index 000000000..192d9028a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1835-var-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1835-var-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1836-var-loop-capture.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1836-var-loop-capture.ts.json new file mode 100644 index 000000000..f3afad1d7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1836-var-loop-capture.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1836-var-loop-capture.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1837-var-undefined-hoisting.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1837-var-undefined-hoisting.ts.json new file mode 100644 index 000000000..c25064345 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1837-var-undefined-hoisting.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1837-var-undefined-hoisting.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1838-var-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1838-var-modules/main.ts.json new file mode 100644 index 000000000..0b04707c3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1838-var-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1838-var-modules/dep.ts", + "/tests/corpus/1838-var-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1839-var-js/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1839-var-js/main.cjs.json new file mode 100644 index 000000000..5a42fc1af --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1839-var-js/main.cjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1839-var-js/lib.cjs", + "/tests/corpus/1839-var-js/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1840-jsdoc-import-type-only/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1840-jsdoc-import-type-only/main.js.json new file mode 100644 index 000000000..55ea57725 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1840-jsdoc-import-type-only/main.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1840-jsdoc-import-type-only/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1850-overload-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1850-overload-basics.ts.json new file mode 100644 index 000000000..d53c4650c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1850-overload-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1850-overload-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1851-overload-return-narrowing.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1851-overload-return-narrowing.ts.json new file mode 100644 index 000000000..9b83d644f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1851-overload-return-narrowing.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1851-overload-return-narrowing.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1852-overload-class-members.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1852-overload-class-members.ts.json new file mode 100644 index 000000000..e98c52210 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1852-overload-class-members.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1852-overload-class-members.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1853-overload-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1853-overload-modules/main.ts.json new file mode 100644 index 000000000..f5ceb6899 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1853-overload-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1853-overload-modules/lib.ts", + "/tests/corpus/1853-overload-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1854-ambient-declare-fn.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1854-ambient-declare-fn.ts.json new file mode 100644 index 000000000..d0f725047 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1854-ambient-declare-fn.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1854-ambient-declare-fn.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1855-ambient-declare-fn-uncaught.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1855-ambient-declare-fn-uncaught.ts.json new file mode 100644 index 000000000..706c2651a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1855-ambient-declare-fn-uncaught.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1855-ambient-declare-fn-uncaught.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1870-unit-type-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1870-unit-type-values.ts.json new file mode 100644 index 000000000..ad624b52a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1870-unit-type-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1870-unit-type-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1871-empty-array-never.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1871-empty-array-never.ts.json new file mode 100644 index 000000000..2d75bd578 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1871-empty-array-never.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1871-empty-array-never.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1872-template-tostring-composite.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1872-template-tostring-composite.ts.json new file mode 100644 index 000000000..2d0a39959 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1872-template-tostring-composite.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1872-template-tostring-composite.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1880-json-declared-field-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1880-json-declared-field-order.ts.json new file mode 100644 index 000000000..9db0fb88e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1880-json-declared-field-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1880-json-declared-field-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1881-default-anon/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1881-default-anon/main.ts.json new file mode 100644 index 000000000..743518b7d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1881-default-anon/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/1881-default-anon/adder.ts", + "/tests/corpus/1881-default-anon/box.ts", + "/tests/corpus/1881-default-anon/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1882-default-cjs-interop/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1882-default-cjs-interop/main.ts.json new file mode 100644 index 000000000..7e62e6148 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1882-default-cjs-interop/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/1882-default-cjs-interop/table.cjs", + "/tests/corpus/1882-default-cjs-interop/scalar.cjs", + "/tests/corpus/1882-default-cjs-interop/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1883-default-exports/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1883-default-exports/main.ts.json new file mode 100644 index 000000000..88341e103 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1883-default-exports/main.ts.json @@ -0,0 +1,11 @@ +{ + "order": [ + "/tests/corpus/1883-default-exports/double.ts", + "/tests/corpus/1883-default-exports/counter.ts", + "/tests/corpus/1883-default-exports/config.ts", + "/tests/corpus/1883-default-exports/pick.ts", + "/tests/corpus/1883-default-exports/hub.ts", + "/tests/corpus/1883-default-exports/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1890-ns-imports/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1890-ns-imports/main.ts.json new file mode 100644 index 000000000..f62347b08 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1890-ns-imports/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1890-ns-imports/geo.ts", + "/tests/corpus/1890-ns-imports/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1891-ns-reexport/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1891-ns-reexport/main.ts.json new file mode 100644 index 000000000..54c5ad368 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1891-ns-reexport/main.ts.json @@ -0,0 +1,10 @@ +{ + "order": [ + "/tests/corpus/1891-ns-reexport/shared.ts", + "/tests/corpus/1891-ns-reexport/agg.ts", + "/tests/corpus/1891-ns-reexport/constants.ts", + "/tests/corpus/1891-ns-reexport/drink.ts", + "/tests/corpus/1891-ns-reexport/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1940-class-values-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1940-class-values-basics.ts.json new file mode 100644 index 000000000..da3f2b704 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1940-class-values-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1940-class-values-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1941-class-values-registry.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1941-class-values-registry.ts.json new file mode 100644 index 000000000..a1e083b41 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1941-class-values-registry.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1941-class-values-registry.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1942-class-expressions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1942-class-expressions.ts.json new file mode 100644 index 000000000..fbed7c555 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1942-class-expressions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1942-class-expressions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1943-class-statics-expanded.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1943-class-statics-expanded.ts.json new file mode 100644 index 000000000..297ea01c7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1943-class-statics-expanded.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1943-class-statics-expanded.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1944-class-values-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1944-class-values-modules/main.ts.json new file mode 100644 index 000000000..eaff750d7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1944-class-values-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1944-class-values-modules/lib.ts", + "/tests/corpus/1944-class-values-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1950-generic-fn-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1950-generic-fn-values.ts.json new file mode 100644 index 000000000..e2ee68a3f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1950-generic-fn-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1950-generic-fn-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1951-generic-classes-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1951-generic-classes-basics.ts.json new file mode 100644 index 000000000..2eb40aa51 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1951-generic-classes-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1951-generic-classes-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1952-generic-class-statics-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1952-generic-class-statics-values.ts.json new file mode 100644 index 000000000..b5b21a0e0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1952-generic-class-statics-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1952-generic-class-statics-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1953-generic-class-hierarchy.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1953-generic-class-hierarchy.ts.json new file mode 100644 index 000000000..f78d6bc9f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1953-generic-class-hierarchy.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1953-generic-class-hierarchy.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1954-generic-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1954-generic-modules/main.ts.json new file mode 100644 index 000000000..e0f7ba1b5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1954-generic-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1954-generic-modules/lib.ts", + "/tests/corpus/1954-generic-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1960-namespace-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1960-namespace-basics.ts.json new file mode 100644 index 000000000..1debb9677 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1960-namespace-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1960-namespace-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1961-namespace-nested.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1961-namespace-nested.ts.json new file mode 100644 index 000000000..d330621ec --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1961-namespace-nested.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1961-namespace-nested.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1962-namespace-classes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1962-namespace-classes.ts.json new file mode 100644 index 000000000..31d7df04a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1962-namespace-classes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1962-namespace-classes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1963-namespace-aliases.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1963-namespace-aliases.ts.json new file mode 100644 index 000000000..383f6f6df --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1963-namespace-aliases.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1963-namespace-aliases.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1964-namespace-type-only.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1964-namespace-type-only.ts.json new file mode 100644 index 000000000..d5f0de186 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1964-namespace-type-only.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1964-namespace-type-only.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1965-namespace-ambient.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1965-namespace-ambient.ts.json new file mode 100644 index 000000000..36dc58bce --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1965-namespace-ambient.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1965-namespace-ambient.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1966-namespace-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1966-namespace-modules/main.ts.json new file mode 100644 index 000000000..c6b34c0c0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1966-namespace-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/1966-namespace-modules/geo.ts", + "/tests/corpus/1966-namespace-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1967-namespace-alias-typeonly.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1967-namespace-alias-typeonly.ts.json new file mode 100644 index 000000000..cf02465d3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1967-namespace-alias-typeonly.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1967-namespace-alias-typeonly.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1968-namespace-import-eq-snapshot.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1968-namespace-import-eq-snapshot.ts.json new file mode 100644 index 000000000..0f3668eb6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1968-namespace-import-eq-snapshot.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1968-namespace-import-eq-snapshot.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1970-decorators-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1970-decorators-basics.ts.json new file mode 100644 index 000000000..5753b4307 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1970-decorators-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1970-decorators-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1971-decorators-rebinding.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1971-decorators-rebinding.ts.json new file mode 100644 index 000000000..7766affeb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1971-decorators-rebinding.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1971-decorators-rebinding.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1972-decorators-throwing.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1972-decorators-throwing.ts.json new file mode 100644 index 000000000..fc019eaf1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1972-decorators-throwing.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1972-decorators-throwing.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1973-decorators-ambient.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1973-decorators-ambient.ts.json new file mode 100644 index 000000000..cecc000dc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1973-decorators-ambient.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1973-decorators-ambient.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1980-primitive-proto-statics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1980-primitive-proto-statics.ts.json new file mode 100644 index 000000000..55fa2b85a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1980-primitive-proto-statics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1980-primitive-proto-statics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1981-date-utc.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1981-date-utc.ts.json new file mode 100644 index 000000000..9187dc29e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1981-date-utc.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1981-date-utc.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1982-freeze-resolve-passthrough.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1982-freeze-resolve-passthrough.ts.json new file mode 100644 index 000000000..024451887 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1982-freeze-resolve-passthrough.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1982-freeze-resolve-passthrough.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1983-array-tuple-surfaces.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1983-array-tuple-surfaces.ts.json new file mode 100644 index 000000000..18ffdb36e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1983-array-tuple-surfaces.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1983-array-tuple-surfaces.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1990-labels-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1990-labels-basics.ts.json new file mode 100644 index 000000000..1bf070ab6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1990-labels-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1990-labels-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1991-for-in-loops.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1991-for-in-loops.ts.json new file mode 100644 index 000000000..9c3e99a21 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1991-for-in-loops.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1991-for-in-loops.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1992-small-syntax.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1992-small-syntax.ts.json new file mode 100644 index 000000000..42c800804 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/1992-small-syntax.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/1992-small-syntax.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/200-strings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/200-strings.ts.json new file mode 100644 index 000000000..a7913f4ad --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/200-strings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/200-strings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2000-generic-methods-basic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2000-generic-methods-basic.ts.json new file mode 100644 index 000000000..c7646ce9a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2000-generic-methods-basic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2000-generic-methods-basic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2001-generic-methods-generic-class.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2001-generic-methods-generic-class.ts.json new file mode 100644 index 000000000..bdd9a8917 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2001-generic-methods-generic-class.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2001-generic-methods-generic-class.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2002-generic-methods-inheritance.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2002-generic-methods-inheritance.ts.json new file mode 100644 index 000000000..1f13e6f08 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2002-generic-methods-inheritance.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2002-generic-methods-inheritance.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2003-generic-methods-object-literal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2003-generic-methods-object-literal.ts.json new file mode 100644 index 000000000..b7051c647 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2003-generic-methods-object-literal.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2003-generic-methods-object-literal.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2004-generic-methods-statics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2004-generic-methods-statics.ts.json new file mode 100644 index 000000000..84123ff5b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2004-generic-methods-statics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2004-generic-methods-statics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/201-templates.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/201-templates.ts.json new file mode 100644 index 000000000..86171e731 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/201-templates.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/201-templates.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2010-generators-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2010-generators-basics.ts.json new file mode 100644 index 000000000..d81e24369 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2010-generators-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2010-generators-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2011-generators-forof.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2011-generators-forof.ts.json new file mode 100644 index 000000000..99e38db61 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2011-generators-forof.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2011-generators-forof.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2012-generators-return-throw.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2012-generators-return-throw.ts.json new file mode 100644 index 000000000..72428eb85 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2012-generators-return-throw.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2012-generators-return-throw.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2013-generators-sent-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2013-generators-sent-values.ts.json new file mode 100644 index 000000000..4f056ce17 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2013-generators-sent-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2013-generators-sent-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2014-generators-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2014-generators-values.ts.json new file mode 100644 index 000000000..93783a036 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2014-generators-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2014-generators-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2015-generators-yieldstar.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2015-generators-yieldstar.ts.json new file mode 100644 index 000000000..dd4cbb67a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2015-generators-yieldstar.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2015-generators-yieldstar.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2016-generators-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2016-generators-rc-stress.ts.json new file mode 100644 index 000000000..3d3e24477 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2016-generators-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2016-generators-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2017-generators-async.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2017-generators-async.ts.json new file mode 100644 index 000000000..e83b7ced6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2017-generators-async.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2017-generators-async.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2018-generators-uncaught.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2018-generators-uncaught.ts.json new file mode 100644 index 000000000..1739c2ba1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2018-generators-uncaught.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2018-generators-uncaught.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2019-generators-loops.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2019-generators-loops.ts.json new file mode 100644 index 000000000..7ff1709d0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2019-generators-loops.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2019-generators-loops.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2020-generic-value-bindings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2020-generic-value-bindings.ts.json new file mode 100644 index 000000000..8b07bff9d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2020-generic-value-bindings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2020-generic-value-bindings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2021-generic-value-binding-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2021-generic-value-binding-modules/main.ts.json new file mode 100644 index 000000000..e6553eb9f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2021-generic-value-binding-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2021-generic-value-binding-modules/lib.ts", + "/tests/corpus/2021-generic-value-binding-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2022-width-index-capture.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2022-width-index-capture.ts.json new file mode 100644 index 000000000..f68a0a05b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2022-width-index-capture.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2022-width-index-capture.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2023-width-readonly.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2023-width-readonly.ts.json new file mode 100644 index 000000000..89a707307 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2023-width-readonly.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2023-width-readonly.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2024-width-array-elems.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2024-width-array-elems.ts.json new file mode 100644 index 000000000..61018a4b5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2024-width-array-elems.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2024-width-array-elems.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2025-width-union-compose.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2025-width-union-compose.ts.json new file mode 100644 index 000000000..eaf2f686a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2025-width-union-compose.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2025-width-union-compose.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2026-width-spread.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2026-width-spread.ts.json new file mode 100644 index 000000000..9c5a10631 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2026-width-spread.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2026-width-spread.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2030-width-nested.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2030-width-nested.ts.json new file mode 100644 index 000000000..9c32799cc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2030-width-nested.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2030-width-nested.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2031-width-tuples.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2031-width-tuples.ts.json new file mode 100644 index 000000000..b6676c957 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2031-width-tuples.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2031-width-tuples.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2032-cjs-export-assigned-class-expression/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2032-cjs-export-assigned-class-expression/main.cjs.json new file mode 100644 index 000000000..a6ba4c14d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2032-cjs-export-assigned-class-expression/main.cjs.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/2032-cjs-export-assigned-class-expression/anon.cjs", + "/tests/corpus/2032-cjs-export-assigned-class-expression/widget.cjs", + "/tests/corpus/2032-cjs-export-assigned-class-expression/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2033-property-assigned-class-extends.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2033-property-assigned-class-extends.cjs.json new file mode 100644 index 000000000..84ede8620 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2033-property-assigned-class-extends.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2033-property-assigned-class-extends.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2035-ternary-array-retag.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2035-ternary-array-retag.cjs.json new file mode 100644 index 000000000..d342f5d92 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2035-ternary-array-retag.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2035-ternary-array-retag.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2036-evolving-array-decl.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2036-evolving-array-decl.cjs.json new file mode 100644 index 000000000..0a2a98a7d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2036-evolving-array-decl.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2036-evolving-array-decl.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2037-fn-decl-hoisting.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2037-fn-decl-hoisting.cjs.json new file mode 100644 index 000000000..86c030035 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2037-fn-decl-hoisting.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2037-fn-decl-hoisting.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2038-evolving-array-js.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2038-evolving-array-js.cjs.json new file mode 100644 index 000000000..908f052ee --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2038-evolving-array-js.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2038-evolving-array-js.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2040-any-bindings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2040-any-bindings.ts.json new file mode 100644 index 000000000..a7be3a5ce --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2040-any-bindings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2040-any-bindings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2040-mixin-heritage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2040-mixin-heritage.ts.json new file mode 100644 index 000000000..0fbe07356 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2040-mixin-heritage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2040-mixin-heritage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2041-any-params-returns.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2041-any-params-returns.ts.json new file mode 100644 index 000000000..0271c7ccf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2041-any-params-returns.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2041-any-params-returns.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2041-mixin-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2041-mixin-values.ts.json new file mode 100644 index 000000000..07cbcd8e6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2041-mixin-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2041-mixin-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2042-any-flow-loops.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2042-any-flow-loops.ts.json new file mode 100644 index 000000000..b80697c41 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2042-any-flow-loops.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2042-any-flow-loops.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2042-mixin-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2042-mixin-modules/main.ts.json new file mode 100644 index 000000000..9b44c8156 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2042-mixin-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2042-mixin-modules/zoo.ts", + "/tests/corpus/2042-mixin-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2043-any-dom-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2043-any-dom-values.ts.json new file mode 100644 index 000000000..65681b644 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2043-any-dom-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2043-any-dom-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2043-mixin-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2043-mixin-rc-stress.ts.json new file mode 100644 index 000000000..e882f99d8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2043-mixin-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2043-mixin-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2044-vtable-sibling-slots.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2044-vtable-sibling-slots.ts.json new file mode 100644 index 000000000..08a724ee0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2044-vtable-sibling-slots.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2044-vtable-sibling-slots.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2045-objlit-accessors-basic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2045-objlit-accessors-basic.ts.json new file mode 100644 index 000000000..60a419b94 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2045-objlit-accessors-basic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2045-objlit-accessors-basic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2045-parameter-properties.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2045-parameter-properties.ts.json new file mode 100644 index 000000000..0eef95885 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2045-parameter-properties.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2045-parameter-properties.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2046-abstract-classes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2046-abstract-classes.ts.json new file mode 100644 index 000000000..99de663b1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2046-abstract-classes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2046-abstract-classes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2046-objlit-accessors-effects.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2046-objlit-accessors-effects.ts.json new file mode 100644 index 000000000..2ded8d466 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2046-objlit-accessors-effects.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2046-objlit-accessors-effects.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2047-objlit-accessors-shapes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2047-objlit-accessors-shapes.ts.json new file mode 100644 index 000000000..008a14093 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2047-objlit-accessors-shapes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2047-objlit-accessors-shapes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2047-optional-class-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2047-optional-class-fields.ts.json new file mode 100644 index 000000000..f267255aa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2047-optional-class-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2047-optional-class-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2050-dynamic-import-own-module/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2050-dynamic-import-own-module/main.ts.json new file mode 100644 index 000000000..328eb6a14 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2050-dynamic-import-own-module/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2050-dynamic-import-own-module/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2051-dynamic-import-then/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2051-dynamic-import-then/main.ts.json new file mode 100644 index 000000000..f562421a1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2051-dynamic-import-then/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2051-dynamic-import-then/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2052-dynamic-import-self.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2052-dynamic-import-self.ts.json new file mode 100644 index 000000000..2b745ad0f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2052-dynamic-import-self.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2052-dynamic-import-self.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2053-typeof-static-fold.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2053-typeof-static-fold.ts.json new file mode 100644 index 000000000..af85697f8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2053-typeof-static-fold.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2053-typeof-static-fold.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2054-destructuring-island-source.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2054-destructuring-island-source.ts.json new file mode 100644 index 000000000..5ceb0c489 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2054-destructuring-island-source.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2054-destructuring-island-source.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2060-empty-tuple.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2060-empty-tuple.ts.json new file mode 100644 index 000000000..6745da1c1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2060-empty-tuple.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2060-empty-tuple.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2070-computed-key-folds.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2070-computed-key-folds.ts.json new file mode 100644 index 000000000..5ec19eb05 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2070-computed-key-folds.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2070-computed-key-folds.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2071-integer-key-enumeration-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2071-integer-key-enumeration-order.ts.json new file mode 100644 index 000000000..19a171730 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2071-integer-key-enumeration-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2071-integer-key-enumeration-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2072-expando-function-members.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2072-expando-function-members.ts.json new file mode 100644 index 000000000..1bbe2efa5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2072-expando-function-members.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2072-expando-function-members.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2073-destructuring-assignment.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2073-destructuring-assignment.ts.json new file mode 100644 index 000000000..810d78a62 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2073-destructuring-assignment.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2073-destructuring-assignment.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2074-island-destructuring.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2074-island-destructuring.ts.json new file mode 100644 index 000000000..6bd66e609 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2074-island-destructuring.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2074-island-destructuring.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2075-index-signature-runtime-keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2075-index-signature-runtime-keys.ts.json new file mode 100644 index 000000000..f438bddab --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2075-index-signature-runtime-keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2075-index-signature-runtime-keys.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2080-destructuring-defaults.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2080-destructuring-defaults.ts.json new file mode 100644 index 000000000..215093fec --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2080-destructuring-defaults.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2080-destructuring-defaults.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2081-destructuring-rest.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2081-destructuring-rest.ts.json new file mode 100644 index 000000000..df1f3c089 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2081-destructuring-rest.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2081-destructuring-rest.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2082-destructuring-assignment.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2082-destructuring-assignment.ts.json new file mode 100644 index 000000000..e1f1d7fe6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2082-destructuring-assignment.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2082-destructuring-assignment.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2083-destructuring-island-decl.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2083-destructuring-island-decl.ts.json new file mode 100644 index 000000000..01ec6a432 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2083-destructuring-island-decl.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2083-destructuring-island-decl.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2084-destructuring-primitive-sources.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2084-destructuring-primitive-sources.ts.json new file mode 100644 index 000000000..01636a5bf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2084-destructuring-primitive-sources.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2084-destructuring-primitive-sources.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2085-destructuring-heads-rest-params.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2085-destructuring-heads-rest-params.ts.json new file mode 100644 index 000000000..6da396008 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2085-destructuring-heads-rest-params.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2085-destructuring-heads-rest-params.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2086-destructuring-island-globals.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2086-destructuring-island-globals.ts.json new file mode 100644 index 000000000..d17a73e31 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2086-destructuring-island-globals.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2086-destructuring-island-globals.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2087-destructuring-for-heads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2087-destructuring-for-heads.ts.json new file mode 100644 index 000000000..b87ac67c8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2087-destructuring-for-heads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2087-destructuring-for-heads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2090-index-signature-number-keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2090-index-signature-number-keys.ts.json new file mode 100644 index 000000000..61526c1a7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2090-index-signature-number-keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2090-index-signature-number-keys.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2091-index-signature-string-intersection.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2091-index-signature-string-intersection.ts.json new file mode 100644 index 000000000..2bdd428f9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2091-index-signature-string-intersection.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2091-index-signature-string-intersection.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2092-package-imports/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2092-package-imports/main.ts.json new file mode 100644 index 000000000..ba89d9e22 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2092-package-imports/main.ts.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/2092-package-imports/src/util.ts", + "/tests/corpus/2092-package-imports/src/extra.ts", + "/tests/corpus/2092-package-imports/src/greet.ts", + "/tests/corpus/2092-package-imports/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2093-timers-promises.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2093-timers-promises.ts.json new file mode 100644 index 000000000..5c6e4502e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2093-timers-promises.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2093-timers-promises.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2094-diagnostics-channel.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2094-diagnostics-channel.ts.json new file mode 100644 index 000000000..db2281ded --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2094-diagnostics-channel.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2094-diagnostics-channel.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2095-js-catch-unknown.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2095-js-catch-unknown.js.json new file mode 100644 index 000000000..244bdaa68 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2095-js-catch-unknown.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2095-js-catch-unknown.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2096-os-type.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2096-os-type.ts.json new file mode 100644 index 000000000..648e146e5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2096-os-type.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2096-os-type.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2097-js-evolving-globals.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2097-js-evolving-globals.js.json new file mode 100644 index 000000000..d3f5ba4d2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2097-js-evolving-globals.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2097-js-evolving-globals.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/210-string-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/210-string-methods.ts.json new file mode 100644 index 000000000..ce89bf9c4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/210-string-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/210-string-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2100-stream-default-hwm.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2100-stream-default-hwm.ts.json new file mode 100644 index 000000000..43059ea77 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2100-stream-default-hwm.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2100-stream-default-hwm.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2101-dyn-param-defaults.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2101-dyn-param-defaults.ts.json new file mode 100644 index 000000000..76e3c761b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2101-dyn-param-defaults.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2101-dyn-param-defaults.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2102-empty-pattern-decls.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2102-empty-pattern-decls.ts.json new file mode 100644 index 000000000..3776943b9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2102-empty-pattern-decls.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2102-empty-pattern-decls.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2103-optional-tuple-elements.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2103-optional-tuple-elements.ts.json new file mode 100644 index 000000000..b1d1e8e44 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2103-optional-tuple-elements.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2103-optional-tuple-elements.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2104-computed-key-destructuring.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2104-computed-key-destructuring.ts.json new file mode 100644 index 000000000..ddaae74fc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2104-computed-key-destructuring.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2104-computed-key-destructuring.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2105-computed-key-static-folds.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2105-computed-key-static-folds.ts.json new file mode 100644 index 000000000..a94003c21 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2105-computed-key-static-folds.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2105-computed-key-static-folds.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2106-comma-expressions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2106-comma-expressions.ts.json new file mode 100644 index 000000000..0ea3c0718 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2106-comma-expressions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2106-comma-expressions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/211-string-unicode.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/211-string-unicode.ts.json new file mode 100644 index 000000000..7cc87f3bb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/211-string-unicode.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/211-string-unicode.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2110-top-object-types.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2110-top-object-types.ts.json new file mode 100644 index 000000000..ac85a408b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2110-top-object-types.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2110-top-object-types.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2111-json-stringify-unknown.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2111-json-stringify-unknown.ts.json new file mode 100644 index 000000000..2fc52f6e3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2111-json-stringify-unknown.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2111-json-stringify-unknown.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2112-array-at-findlast.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2112-array-at-findlast.ts.json new file mode 100644 index 000000000..b3ea550b7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2112-array-at-findlast.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2112-array-at-findlast.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2113-string-index-methods.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2113-string-index-methods.js.json new file mode 100644 index 000000000..f8560ed52 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2113-string-index-methods.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2113-string-index-methods.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/212-string-aliasing-append.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/212-string-aliasing-append.ts.json new file mode 100644 index 000000000..ffce7fa96 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/212-string-aliasing-append.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/212-string-aliasing-append.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2120-package-self-import/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2120-package-self-import/main.ts.json new file mode 100644 index 000000000..79c044e00 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2120-package-self-import/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2120-package-self-import/sib.ts", + "/tests/corpus/2120-package-self-import/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2121-esm-cycle-inert-backedge/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2121-esm-cycle-inert-backedge/main.ts.json new file mode 100644 index 000000000..b836b7569 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2121-esm-cycle-inert-backedge/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2121-esm-cycle-inert-backedge/peer.ts", + "/tests/corpus/2121-esm-cycle-inert-backedge/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2122-import-refusal-crash/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2122-import-refusal-crash/main.ts.json new file mode 100644 index 000000000..2e772aed4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2122-import-refusal-crash/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2122-import-refusal-crash/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2123-ambient-import-crash/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2123-ambient-import-crash/main.ts.json new file mode 100644 index 000000000..a40f9c07d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2123-ambient-import-crash/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2123-ambient-import-crash/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2124-imports-field-wildcard/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2124-imports-field-wildcard/main.ts.json new file mode 100644 index 000000000..9fabc2bd0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2124-imports-field-wildcard/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2124-imports-field-wildcard/src/x.ts", + "/tests/corpus/2124-imports-field-wildcard/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2130-overload-island-returns.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2130-overload-island-returns.ts.json new file mode 100644 index 000000000..61644ca88 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2130-overload-island-returns.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2130-overload-island-returns.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2140-uri-component-codecs.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2140-uri-component-codecs.ts.json new file mode 100644 index 000000000..99bcdcd29 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2140-uri-component-codecs.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2140-uri-component-codecs.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2160-dc-tracing-channel.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2160-dc-tracing-channel.cjs.json new file mode 100644 index 000000000..659cd25a7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2160-dc-tracing-channel.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2160-dc-tracing-channel.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2161-js-object-literal-identity.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2161-js-object-literal-identity.cjs.json new file mode 100644 index 000000000..ac0fbfd4a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2161-js-object-literal-identity.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2161-js-object-literal-identity.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2162-js-dyn-destructure.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2162-js-dyn-destructure.cjs.json new file mode 100644 index 000000000..9477a930f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2162-js-dyn-destructure.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2162-js-dyn-destructure.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2163-js-selfref-const.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2163-js-selfref-const.cjs.json new file mode 100644 index 000000000..c2d203f36 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2163-js-selfref-const.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2163-js-selfref-const.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2164-js-then-dyn-handler.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2164-js-then-dyn-handler.cjs.json new file mode 100644 index 000000000..e577979c0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2164-js-then-dyn-handler.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2164-js-then-dyn-handler.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2165-js-throw-dyn.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2165-js-throw-dyn.cjs.json new file mode 100644 index 000000000..b28a00775 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2165-js-throw-dyn.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2165-js-throw-dyn.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2166-cjs-getter-this/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2166-cjs-getter-this/main.cjs.json new file mode 100644 index 000000000..5245d6db7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2166-cjs-getter-this/main.cjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2166-cjs-getter-this/lib.cjs", + "/tests/corpus/2166-cjs-getter-this/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2170-island-array-exits.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2170-island-array-exits.ts.json new file mode 100644 index 000000000..f2f8ca6d4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2170-island-array-exits.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2170-island-array-exits.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2171-island-json-stringify.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2171-island-json-stringify.ts.json new file mode 100644 index 000000000..1db26af0e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2171-island-json-stringify.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2171-island-json-stringify.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2172-island-regexp-boundary.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2172-island-regexp-boundary.ts.json new file mode 100644 index 000000000..9be306be6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2172-island-regexp-boundary.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2172-island-regexp-boundary.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2190-new-object-and-string-wrappers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2190-new-object-and-string-wrappers.ts.json new file mode 100644 index 000000000..20e4f9fda --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2190-new-object-and-string-wrappers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2190-new-object-and-string-wrappers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2191-uri-encoders.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2191-uri-encoders.ts.json new file mode 100644 index 000000000..3cf16f98d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2191-uri-encoders.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2191-uri-encoders.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2192-object-default-tostring.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2192-object-default-tostring.ts.json new file mode 100644 index 000000000..502e190c2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2192-object-default-tostring.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2192-object-default-tostring.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2193-discarded-stdlib-reads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2193-discarded-stdlib-reads.ts.json new file mode 100644 index 000000000..829a132dc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2193-discarded-stdlib-reads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2193-discarded-stdlib-reads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2194-ambient-undef-chains.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2194-ambient-undef-chains.ts.json new file mode 100644 index 000000000..f3cc8f10f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2194-ambient-undef-chains.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2194-ambient-undef-chains.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2195-require-missing-package/main.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2195-require-missing-package/main.mjs.json new file mode 100644 index 000000000..b747892ab --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2195-require-missing-package/main.mjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2195-require-missing-package/lib.cjs", + "/tests/corpus/2195-require-missing-package/main.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2196-island-computed-key-chain.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2196-island-computed-key-chain.ts.json new file mode 100644 index 000000000..4a54b7f51 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2196-island-computed-key-chain.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2196-island-computed-key-chain.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2210-dyn-promise-crossing.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2210-dyn-promise-crossing.cjs.json new file mode 100644 index 000000000..263857d09 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2210-dyn-promise-crossing.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2210-dyn-promise-crossing.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2211-dc-trace-promise.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2211-dc-trace-promise.cjs.json new file mode 100644 index 000000000..881b3ea38 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2211-dc-trace-promise.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2211-dc-trace-promise.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2212-unhandled-rejection-listener.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2212-unhandled-rejection-listener.cjs.json new file mode 100644 index 000000000..efb5ac99d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2212-unhandled-rejection-listener.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2212-unhandled-rejection-listener.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2213-async-local-storage.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2213-async-local-storage.cjs.json new file mode 100644 index 000000000..bf4b3120f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2213-async-local-storage.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2213-async-local-storage.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2214-dc-bind-store.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2214-dc-bind-store.cjs.json new file mode 100644 index 000000000..5686fa4c5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2214-dc-bind-store.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2214-dc-bind-store.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2215-process-emit-warning-exit.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2215-process-emit-warning-exit.cjs.json new file mode 100644 index 000000000..39e70f3b3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2215-process-emit-warning-exit.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2215-process-emit-warning-exit.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2240-width-class-into-record.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2240-width-class-into-record.ts.json new file mode 100644 index 000000000..09400f941 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2240-width-class-into-record.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2240-width-class-into-record.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2241-width-record-into-class.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2241-width-record-into-class.ts.json new file mode 100644 index 000000000..e7a81f2b4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2241-width-record-into-class.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2241-width-record-into-class.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2242-width-statics-into-record.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2242-width-statics-into-record.ts.json new file mode 100644 index 000000000..9830b70bd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2242-width-statics-into-record.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2242-width-statics-into-record.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2243-width-assert-satisfies-shapes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2243-width-assert-satisfies-shapes.ts.json new file mode 100644 index 000000000..321d3d92e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2243-width-assert-satisfies-shapes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2243-width-assert-satisfies-shapes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2250-tagged-templates.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2250-tagged-templates.ts.json new file mode 100644 index 000000000..f4d596935 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2250-tagged-templates.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2250-tagged-templates.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2251-tagged-templates-dyn.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2251-tagged-templates-dyn.ts.json new file mode 100644 index 000000000..255613f2f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2251-tagged-templates-dyn.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2251-tagged-templates-dyn.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2252-class-iterators.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2252-class-iterators.ts.json new file mode 100644 index 000000000..9aafbee88 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2252-class-iterators.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2252-class-iterators.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2253-union-coercions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2253-union-coercions.ts.json new file mode 100644 index 000000000..d9e86ae6c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2253-union-coercions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2253-union-coercions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2260-http2-constants.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2260-http2-constants.cjs.json new file mode 100644 index 000000000..796b0028b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2260-http2-constants.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2260-http2-constants.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2280-builtin-namespace-destructure.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2280-builtin-namespace-destructure.cjs.json new file mode 100644 index 000000000..71c7abf2f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2280-builtin-namespace-destructure.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2280-builtin-namespace-destructure.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2281-domexception-atob-btoa.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2281-domexception-atob-btoa.cjs.json new file mode 100644 index 000000000..40f042f92 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2281-domexception-atob-btoa.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2281-domexception-atob-btoa.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2282-queue-microtask.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2282-queue-microtask.cjs.json new file mode 100644 index 000000000..278cf9878 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2282-queue-microtask.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2282-queue-microtask.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2283-structured-clone.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2283-structured-clone.cjs.json new file mode 100644 index 000000000..1ad3fdebf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2283-structured-clone.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2283-structured-clone.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2284-regexp-constructor.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2284-regexp-constructor.cjs.json new file mode 100644 index 000000000..d87d38c22 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2284-regexp-constructor.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2284-regexp-constructor.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2285-iferror-dyn.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2285-iferror-dyn.cjs.json new file mode 100644 index 000000000..b3bf5c10f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2285-iferror-dyn.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2285-iferror-dyn.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2286-dyn-object-walks.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2286-dyn-object-walks.cjs.json new file mode 100644 index 000000000..679637055 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2286-dyn-object-walks.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2286-dyn-object-walks.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2300-dyn-record-spread-and-keyed-access.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2300-dyn-record-spread-and-keyed-access.cjs.json new file mode 100644 index 000000000..ce829c9d9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2300-dyn-record-spread-and-keyed-access.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2300-dyn-record-spread-and-keyed-access.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2301-cjs-export-table-dom-attach.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2301-cjs-export-table-dom-attach.cjs.json new file mode 100644 index 000000000..78e39af40 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2301-cjs-export-table-dom-attach.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2301-cjs-export-table-dom-attach.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2310-process-next-tick.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2310-process-next-tick.ts.json new file mode 100644 index 000000000..7f5060917 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2310-process-next-tick.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2310-process-next-tick.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2311-next-tick-js-callbacks.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2311-next-tick-js-callbacks.js.json new file mode 100644 index 000000000..6e6f92851 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2311-next-tick-js-callbacks.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2311-next-tick-js-callbacks.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2312-stream-underscore-assign.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2312-stream-underscore-assign.ts.json new file mode 100644 index 000000000..e015907d3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2312-stream-underscore-assign.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2312-stream-underscore-assign.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2313-stream-underscore-assign-js.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2313-stream-underscore-assign-js.cjs.json new file mode 100644 index 000000000..a9f70a7ab --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2313-stream-underscore-assign-js.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2313-stream-underscore-assign-js.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2314-process-introspection.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2314-process-introspection.ts.json new file mode 100644 index 000000000..ba5f9b072 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2314-process-introspection.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2314-process-introspection.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2320-await-unit.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2320-await-unit.ts.json new file mode 100644 index 000000000..972f73410 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2320-await-unit.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2320-await-unit.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2321-emitter-static-setmax.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2321-emitter-static-setmax.cjs.json new file mode 100644 index 000000000..987497185 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2321-emitter-static-setmax.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2321-emitter-static-setmax.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2322-dyn-array-sort.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2322-dyn-array-sort.cjs.json new file mode 100644 index 000000000..e46d9d43e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2322-dyn-array-sort.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2322-dyn-array-sort.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2323-timer-callback-returns.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2323-timer-callback-returns.ts.json new file mode 100644 index 000000000..04af69b1c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2323-timer-callback-returns.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2323-timer-callback-returns.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2330-tls-server-runtime-options.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2330-tls-server-runtime-options.cjs.json new file mode 100644 index 000000000..63ad93aa1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2330-tls-server-runtime-options.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2330-tls-server-runtime-options.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2331-tls-server-options-typed.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2331-tls-server-options-typed.ts.json new file mode 100644 index 000000000..8aefbf814 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2331-tls-server-options-typed.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2331-tls-server-options-typed.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2350-nan-global.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2350-nan-global.ts.json new file mode 100644 index 000000000..d4b20f5cb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2350-nan-global.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2350-nan-global.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2351-async-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2351-async-methods.ts.json new file mode 100644 index 000000000..4ad22f3d5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2351-async-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2351-async-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2352-void-coercions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2352-void-coercions.ts.json new file mode 100644 index 000000000..f5656ab80 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2352-void-coercions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2352-void-coercions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2353-decorators-member-ambient.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2353-decorators-member-ambient.ts.json new file mode 100644 index 000000000..ae1da10f2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2353-decorators-member-ambient.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2353-decorators-member-ambient.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2354-decorators-expression-ambient.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2354-decorators-expression-ambient.ts.json new file mode 100644 index 000000000..be9cab08b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2354-decorators-expression-ambient.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2354-decorators-expression-ambient.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2360-tuple-to-array.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2360-tuple-to-array.ts.json new file mode 100644 index 000000000..e69cb3526 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2360-tuple-to-array.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2360-tuple-to-array.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2361-assign-index-record.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2361-assign-index-record.ts.json new file mode 100644 index 000000000..231965e43 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2361-assign-index-record.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2361-assign-index-record.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2362-execsync-inherit.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2362-execsync-inherit.ts.json new file mode 100644 index 000000000..671467b21 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2362-execsync-inherit.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2362-execsync-inherit.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2363-nullish-retag.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2363-nullish-retag.ts.json new file mode 100644 index 000000000..3f82a013f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2363-nullish-retag.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2363-nullish-retag.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2364-in-runtime-key.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2364-in-runtime-key.ts.json new file mode 100644 index 000000000..30e028b7b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2364-in-runtime-key.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2364-in-runtime-key.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2365-dyn-into-island.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2365-dyn-into-island.ts.json new file mode 100644 index 000000000..ab013ec93 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2365-dyn-into-island.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2365-dyn-into-island.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2366-string-well-formed.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2366-string-well-formed.ts.json new file mode 100644 index 000000000..99b4be9f0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2366-string-well-formed.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2366-string-well-formed.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2367-regexp-escape.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2367-regexp-escape.ts.json new file mode 100644 index 000000000..843048366 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2367-regexp-escape.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2367-regexp-escape.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2368-set-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2368-set-methods.ts.json new file mode 100644 index 000000000..57770e84d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2368-set-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2368-set-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2369-promise-try.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2369-promise-try.ts.json new file mode 100644 index 000000000..4eaebd878 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2369-promise-try.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2369-promise-try.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2370-group-by.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2370-group-by.ts.json new file mode 100644 index 000000000..c0dd61e32 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2370-group-by.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2370-group-by.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2371-iterator-helpers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2371-iterator-helpers.ts.json new file mode 100644 index 000000000..a573228d3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2371-iterator-helpers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2371-iterator-helpers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2380-buffer-module-named-import.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2380-buffer-module-named-import.ts.json new file mode 100644 index 000000000..ed0270cab --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2380-buffer-module-named-import.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2380-buffer-module-named-import.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2381-builtin-default-imports.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2381-builtin-default-imports.js.json new file mode 100644 index 000000000..882eeb410 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2381-builtin-default-imports.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2381-builtin-default-imports.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2382-cycle-two-decl/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2382-cycle-two-decl/main.ts.json new file mode 100644 index 000000000..de0365655 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2382-cycle-two-decl/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/2382-cycle-two-decl/b.ts", + "/tests/corpus/2382-cycle-two-decl/a.ts", + "/tests/corpus/2382-cycle-two-decl/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2383-cycle-assertdoc/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2383-cycle-assertdoc/main.js.json new file mode 100644 index 000000000..681508f07 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2383-cycle-assertdoc/main.js.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/2383-cycle-assertdoc/assert-doc.js", + "/tests/corpus/2383-cycle-assertdoc/builders.js", + "/tests/corpus/2383-cycle-assertdoc/index.js", + "/tests/corpus/2383-cycle-assertdoc/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2384-cycle-mixed-bindings/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2384-cycle-mixed-bindings/main.ts.json new file mode 100644 index 000000000..4590bccb9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2384-cycle-mixed-bindings/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/2384-cycle-mixed-bindings/render.ts", + "/tests/corpus/2384-cycle-mixed-bindings/config.ts", + "/tests/corpus/2384-cycle-mixed-bindings/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2385-builtin-reexport-facade/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2385-builtin-reexport-facade/main.ts.json new file mode 100644 index 000000000..d0c1274ec --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2385-builtin-reexport-facade/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2385-builtin-reexport-facade/facade.ts", + "/tests/corpus/2385-builtin-reexport-facade/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2386-string-to-chars.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2386-string-to-chars.ts.json new file mode 100644 index 000000000..4bae0bf64 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2386-string-to-chars.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2386-string-to-chars.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2387-tonumber-argv.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2387-tonumber-argv.ts.json new file mode 100644 index 000000000..bd1521dea --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2387-tonumber-argv.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2387-tonumber-argv.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2388-tonumber-grammar-zoo.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2388-tonumber-grammar-zoo.ts.json new file mode 100644 index 000000000..dd00598ea --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2388-tonumber-grammar-zoo.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2388-tonumber-grammar-zoo.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2389-tonumber-unary-plus.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2389-tonumber-unary-plus.ts.json new file mode 100644 index 000000000..b3817278b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2389-tonumber-unary-plus.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2389-tonumber-unary-plus.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2390-dot-requires/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2390-dot-requires/main.cjs.json new file mode 100644 index 000000000..f3e160073 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2390-dot-requires/main.cjs.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/2390-dot-requires/shared.cjs", + "/tests/corpus/2390-dot-requires/sub/index.cjs", + "/tests/corpus/2390-dot-requires/sub/child.cjs", + "/tests/corpus/2390-dot-requires/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2391-default-builtin-imports/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2391-default-builtin-imports/main.ts.json new file mode 100644 index 000000000..14ea0def4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2391-default-builtin-imports/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2391-default-builtin-imports/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2392-block-guard-alias-scope.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2392-block-guard-alias-scope.ts.json new file mode 100644 index 000000000..3887b8d9d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2392-block-guard-alias-scope.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2392-block-guard-alias-scope.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2393-loop-exit-guard-narrow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2393-loop-exit-guard-narrow.ts.json new file mode 100644 index 000000000..00b98c317 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2393-loop-exit-guard-narrow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2393-loop-exit-guard-narrow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2394-loop-narrow-containment.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2394-loop-narrow-containment.ts.json new file mode 100644 index 000000000..ce9aa3749 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2394-loop-narrow-containment.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2394-loop-narrow-containment.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2395-while-cond-guard.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2395-while-cond-guard.ts.json new file mode 100644 index 000000000..33c887999 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2395-while-cond-guard.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2395-while-cond-guard.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2396-born-narrowed-decl.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2396-born-narrowed-decl.ts.json new file mode 100644 index 000000000..f31aabb38 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2396-born-narrowed-decl.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2396-born-narrowed-decl.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2397-branch-kill-merge.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2397-branch-kill-merge.ts.json new file mode 100644 index 000000000..a5f6d8412 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2397-branch-kill-merge.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2397-branch-kill-merge.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2398-switch-arm-kill.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2398-switch-arm-kill.ts.json new file mode 100644 index 000000000..cec933d20 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2398-switch-arm-kill.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2398-switch-arm-kill.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2399-reassign-kill-polarity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2399-reassign-kill-polarity.ts.json new file mode 100644 index 000000000..ca3bbc4e8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2399-reassign-kill-polarity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2399-reassign-kill-polarity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/240-stdout-write.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/240-stdout-write.ts.json new file mode 100644 index 000000000..29fe5a040 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/240-stdout-write.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/240-stdout-write.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2400-kill-return-edge.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2400-kill-return-edge.ts.json new file mode 100644 index 000000000..8da8a140b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2400-kill-return-edge.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2400-kill-return-edge.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2401-kill-break-staging.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2401-kill-break-staging.ts.json new file mode 100644 index 000000000..13ad5ab99 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2401-kill-break-staging.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2401-kill-break-staging.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2402-labeled-break-kill.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2402-labeled-break-kill.ts.json new file mode 100644 index 000000000..b49cade38 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2402-labeled-break-kill.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2402-labeled-break-kill.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2403-kill-continue-backedge.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2403-kill-continue-backedge.ts.json new file mode 100644 index 000000000..d3d7bfbdd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2403-kill-continue-backedge.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2403-kill-continue-backedge.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2404-kill-throw-catch.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2404-kill-throw-catch.ts.json new file mode 100644 index 000000000..8f98ebf22 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2404-kill-throw-catch.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2404-kill-throw-catch.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2405-sibling-arm-narrow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2405-sibling-arm-narrow.ts.json new file mode 100644 index 000000000..7b0519812 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2405-sibling-arm-narrow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2405-sibling-arm-narrow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2406-switch-clause-sibling-narrow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2406-switch-clause-sibling-narrow.ts.json new file mode 100644 index 000000000..3c94f037b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2406-switch-clause-sibling-narrow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2406-switch-clause-sibling-narrow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2407-infinite-loop-seal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2407-infinite-loop-seal.ts.json new file mode 100644 index 000000000..08987bd13 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2407-infinite-loop-seal.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2407-infinite-loop-seal.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2408-loop-terminality-reopen.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2408-loop-terminality-reopen.ts.json new file mode 100644 index 000000000..1f59929b0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2408-loop-terminality-reopen.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2408-loop-terminality-reopen.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2409-loop-body-return-not-terminal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2409-loop-body-return-not-terminal.ts.json new file mode 100644 index 000000000..2585932a5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2409-loop-body-return-not-terminal.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2409-loop-body-return-not-terminal.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2410-stacked-cases-terminality.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2410-stacked-cases-terminality.ts.json new file mode 100644 index 000000000..54d0ed5ed --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2410-stacked-cases-terminality.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2410-stacked-cases-terminality.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2411-exhaustive-switch-terminality.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2411-exhaustive-switch-terminality.ts.json new file mode 100644 index 000000000..84990ace3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2411-exhaustive-switch-terminality.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2411-exhaustive-switch-terminality.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2412-dowhile-guard-trailing-test.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2412-dowhile-guard-trailing-test.ts.json new file mode 100644 index 000000000..b0df59238 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2412-dowhile-guard-trailing-test.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2412-dowhile-guard-trailing-test.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2413-dowhile-kill-renarrow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2413-dowhile-kill-renarrow.ts.json new file mode 100644 index 000000000..9e2b6c5b3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2413-dowhile-kill-renarrow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2413-dowhile-kill-renarrow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2414-dowhile-continue-kill.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2414-dowhile-continue-kill.ts.json new file mode 100644 index 000000000..963610e71 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2414-dowhile-continue-kill.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2414-dowhile-continue-kill.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2415-dowhile-break-trailing-test.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2415-dowhile-break-trailing-test.ts.json new file mode 100644 index 000000000..4e6601113 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2415-dowhile-break-trailing-test.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2415-dowhile-break-trailing-test.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2416-spread-ternary-positions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2416-spread-ternary-positions.ts.json new file mode 100644 index 000000000..e31878110 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2416-spread-ternary-positions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2416-spread-ternary-positions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2417-ternary-local-inference.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2417-ternary-local-inference.ts.json new file mode 100644 index 000000000..a411686ed --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2417-ternary-local-inference.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2417-ternary-local-inference.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2418-wrapped-ternary-arms.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2418-wrapped-ternary-arms.ts.json new file mode 100644 index 000000000..f431d3781 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2418-wrapped-ternary-arms.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2418-wrapped-ternary-arms.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2419-selector-ternary-union.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2419-selector-ternary-union.ts.json new file mode 100644 index 000000000..dd848a5f3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2419-selector-ternary-union.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2419-selector-ternary-union.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2420-nullish-null-identity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2420-nullish-null-identity.ts.json new file mode 100644 index 000000000..56fba9cc1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2420-nullish-null-identity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2420-nullish-null-identity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2421-float-lane-inference.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2421-float-lane-inference.ts.json new file mode 100644 index 000000000..a65a9636f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2421-float-lane-inference.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2421-float-lane-inference.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2422-ieee-div-rem-corners.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2422-ieee-div-rem-corners.ts.json new file mode 100644 index 000000000..e784ed287 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2422-ieee-div-rem-corners.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2422-ieee-div-rem-corners.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2423-param-null-reassign.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2423-param-null-reassign.ts.json new file mode 100644 index 000000000..84e916ef4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2423-param-null-reassign.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2423-param-null-reassign.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2424-ternary-miss-first-narrowing.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2424-ternary-miss-first-narrowing.ts.json new file mode 100644 index 000000000..b21d24a7b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2424-ternary-miss-first-narrowing.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2424-ternary-miss-first-narrowing.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2425-elseif-head-exit-narrow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2425-elseif-head-exit-narrow.ts.json new file mode 100644 index 000000000..a51a0cd5f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2425-elseif-head-exit-narrow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2425-elseif-head-exit-narrow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2426-default-snapshot-mutable/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2426-default-snapshot-mutable/main.ts.json new file mode 100644 index 000000000..6d1b4c68b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2426-default-snapshot-mutable/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/2426-default-snapshot-mutable/m.ts", + "/tests/corpus/2426-default-snapshot-mutable/live.ts", + "/tests/corpus/2426-default-snapshot-mutable/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2427-perf-hooks-now.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2427-perf-hooks-now.ts.json new file mode 100644 index 000000000..afef766dc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2427-perf-hooks-now.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2427-perf-hooks-now.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2428-field-redeclare-inherited.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2428-field-redeclare-inherited.ts.json new file mode 100644 index 000000000..12abe011a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2428-field-redeclare-inherited.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2428-field-redeclare-inherited.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2429-destructure-class-instance.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2429-destructure-class-instance.ts.json new file mode 100644 index 000000000..64fd5b56f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2429-destructure-class-instance.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2429-destructure-class-instance.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2430-empty-literal-unknown-field.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2430-empty-literal-unknown-field.js.json new file mode 100644 index 000000000..ce1356e53 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2430-empty-literal-unknown-field.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2430-empty-literal-unknown-field.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2431-primitive-ctor-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2431-primitive-ctor-values.ts.json new file mode 100644 index 000000000..65e64efd7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2431-primitive-ctor-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2431-primitive-ctor-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2432-generic-member-fields-async.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2432-generic-member-fields-async.ts.json new file mode 100644 index 000000000..9027b5a3d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2432-generic-member-fields-async.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2432-generic-member-fields-async.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2433-as-const-command-tables.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2433-as-const-command-tables.ts.json new file mode 100644 index 000000000..fe0dae5ad --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2433-as-const-command-tables.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2433-as-const-command-tables.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2434-deferred-init-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2434-deferred-init-fields.ts.json new file mode 100644 index 000000000..991f9e28b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2434-deferred-init-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2434-deferred-init-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2435-loose-same-kind-equality.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2435-loose-same-kind-equality.ts.json new file mode 100644 index 000000000..aba616dba --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2435-loose-same-kind-equality.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2435-loose-same-kind-equality.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2440-console-inspect-args.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2440-console-inspect-args.ts.json new file mode 100644 index 000000000..544e7529f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2440-console-inspect-args.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2440-console-inspect-args.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2441-console-process-argv.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2441-console-process-argv.ts.json new file mode 100644 index 000000000..7c1c308dd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2441-console-process-argv.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2441-console-process-argv.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2442-union-literal-arm-widening.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2442-union-literal-arm-widening.ts.json new file mode 100644 index 000000000..dfa2ac7e6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2442-union-literal-arm-widening.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2442-union-literal-arm-widening.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2443-union-literal-shadow-narrowing.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2443-union-literal-shadow-narrowing.ts.json new file mode 100644 index 000000000..d987b7836 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2443-union-literal-shadow-narrowing.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2443-union-literal-shadow-narrowing.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2444-union-literal-reducer-spread.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2444-union-literal-reducer-spread.ts.json new file mode 100644 index 000000000..739c720d9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2444-union-literal-reducer-spread.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2444-union-literal-reducer-spread.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2445-math-minmax-nary.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2445-math-minmax-nary.ts.json new file mode 100644 index 000000000..22ae013ac --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2445-math-minmax-nary.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2445-math-minmax-nary.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2446-performance-global.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2446-performance-global.ts.json new file mode 100644 index 000000000..5b6912287 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2446-performance-global.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2446-performance-global.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2447-island-boundary-slots/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2447-island-boundary-slots/main.ts.json new file mode 100644 index 000000000..fd3847f1c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2447-island-boundary-slots/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2447-island-boundary-slots/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2448-entries-null-arms-regex-arrays.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2448-entries-null-arms-regex-arrays.ts.json new file mode 100644 index 000000000..a27615da2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2448-entries-null-arms-regex-arrays.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2448-entries-null-arms-regex-arrays.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2449-js-dyn-worlds/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2449-js-dyn-worlds/main.js.json new file mode 100644 index 000000000..56c99f300 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2449-js-dyn-worlds/main.js.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2449-js-dyn-worlds/walker.js", + "/tests/corpus/2449-js-dyn-worlds/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2450-private-instance-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2450-private-instance-methods.ts.json new file mode 100644 index 000000000..f1553901d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2450-private-instance-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2450-private-instance-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2451-private-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2451-private-fields.ts.json new file mode 100644 index 000000000..fb1e53549 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2451-private-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2451-private-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2452-private-statics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2452-private-statics.ts.json new file mode 100644 index 000000000..5bfbbb9d6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2452-private-statics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2452-private-statics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2453-private-accessors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2453-private-accessors.ts.json new file mode 100644 index 000000000..061f01964 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2453-private-accessors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2453-private-accessors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2454-private-generator-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2454-private-generator-methods.ts.json new file mode 100644 index 000000000..31a9736cb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2454-private-generator-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2454-private-generator-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2455-private-brand-checks.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2455-private-brand-checks.ts.json new file mode 100644 index 000000000..6198af5bc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2455-private-brand-checks.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2455-private-brand-checks.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2456-private-async-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2456-private-async-methods.ts.json new file mode 100644 index 000000000..481e5064b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2456-private-async-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2456-private-async-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2457-private-members.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2457-private-members.js.json new file mode 100644 index 000000000..a9f6474e6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2457-private-members.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2457-private-members.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2460-qs-parse-grammar.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2460-qs-parse-grammar.ts.json new file mode 100644 index 000000000..2f69df03e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2460-qs-parse-grammar.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2460-qs-parse-grammar.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2461-qs-parse-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2461-qs-parse-options.ts.json new file mode 100644 index 000000000..3a0207485 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2461-qs-parse-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2461-qs-parse-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2462-qs-stringify.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2462-qs-stringify.ts.json new file mode 100644 index 000000000..37351bcb6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2462-qs-stringify.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2462-qs-stringify.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2463-qs-escape-unescape.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2463-qs-escape-unescape.ts.json new file mode 100644 index 000000000..25082fdbf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2463-qs-escape-unescape.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2463-qs-escape-unescape.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2464-qs-require-forms.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2464-qs-require-forms.cjs.json new file mode 100644 index 000000000..2baa4637e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2464-qs-require-forms.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2464-qs-require-forms.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2470-mockable-module-shape.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2470-mockable-module-shape.js.json new file mode 100644 index 000000000..15ca95c9b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2470-mockable-module-shape.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2470-mockable-module-shape.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2471-record-keyed-write-hasown.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2471-record-keyed-write-hasown.js.json new file mode 100644 index 000000000..7612ba080 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2471-record-keyed-write-hasown.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2471-record-keyed-write-hasown.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2472-string-regexp-union.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2472-string-regexp-union.ts.json new file mode 100644 index 000000000..91660c739 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2472-string-regexp-union.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2472-string-regexp-union.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2473-option-table-widths.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2473-option-table-widths.js.json new file mode 100644 index 000000000..f1fc7cc3f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2473-option-table-widths.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2473-option-table-widths.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2474-island-literal-forms.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2474-island-literal-forms.ts.json new file mode 100644 index 000000000..a8a8c0d1a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2474-island-literal-forms.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2474-island-literal-forms.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2475-variadic-wrapper-island.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2475-variadic-wrapper-island.js.json new file mode 100644 index 000000000..89b4a1466 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2475-variadic-wrapper-island.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2475-variadic-wrapper-island.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2476-map-regex-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2476-map-regex-values.ts.json new file mode 100644 index 000000000..041b0a55d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2476-map-regex-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2476-map-regex-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2480-recursive-record-tree.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2480-recursive-record-tree.ts.json new file mode 100644 index 000000000..0c492c48d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2480-recursive-record-tree.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2480-recursive-record-tree.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2481-mutual-recursive-records.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2481-mutual-recursive-records.ts.json new file mode 100644 index 000000000..58a937ddd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2481-mutual-recursive-records.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2481-mutual-recursive-records.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2482-recursive-union-tree.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2482-recursive-union-tree.ts.json new file mode 100644 index 000000000..7c4442e0a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2482-recursive-union-tree.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2482-recursive-union-tree.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2483-recursive-record-cycles.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2483-recursive-record-cycles.ts.json new file mode 100644 index 000000000..65863f52b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2483-recursive-record-cycles.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2483-recursive-record-cycles.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2484-json-stringify-circular.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2484-json-stringify-circular.ts.json new file mode 100644 index 000000000..fd7f56625 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2484-json-stringify-circular.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2484-json-stringify-circular.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2485-inspect-circular-refs.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2485-inspect-circular-refs.ts.json new file mode 100644 index 000000000..e19e5f550 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2485-inspect-circular-refs.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2485-inspect-circular-refs.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2486-recursive-record-boundaries.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2486-recursive-record-boundaries.ts.json new file mode 100644 index 000000000..9d711b834 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2486-recursive-record-boundaries.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2486-recursive-record-boundaries.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2487-recursive-deep-equal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2487-recursive-deep-equal.ts.json new file mode 100644 index 000000000..4317402d6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2487-recursive-deep-equal.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2487-recursive-deep-equal.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2488-ast-walker.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2488-ast-walker.ts.json new file mode 100644 index 000000000..dd5c224f5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2488-ast-walker.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2488-ast-walker.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2490-find-miss-null-compare.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2490-find-miss-null-compare.ts.json new file mode 100644 index 000000000..15effde52 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2490-find-miss-null-compare.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2490-find-miss-null-compare.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2491-strict-unit-compare-no-arm.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2491-strict-unit-compare-no-arm.ts.json new file mode 100644 index 000000000..c9d3aaa6d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2491-strict-unit-compare-no-arm.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2491-strict-unit-compare-no-arm.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2492-loose-null-compare-unions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2492-loose-null-compare-unions.ts.json new file mode 100644 index 000000000..bd80cc2b7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2492-loose-null-compare-unions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2492-loose-null-compare-unions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2493-switch-unit-cases.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2493-switch-unit-cases.ts.json new file mode 100644 index 000000000..3e37e5c17 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2493-switch-unit-cases.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2493-switch-unit-cases.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2494-no-arm-compare-effects.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2494-no-arm-compare-effects.ts.json new file mode 100644 index 000000000..7f86e5aac --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2494-no-arm-compare-effects.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2494-no-arm-compare-effects.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2500-net-autosel-timeout.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2500-net-autosel-timeout.ts.json new file mode 100644 index 000000000..b21c69451 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2500-net-autosel-timeout.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2500-net-autosel-timeout.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2510-dyn-evolving-array-map.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2510-dyn-evolving-array-map.ts.json new file mode 100644 index 000000000..de147465f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2510-dyn-evolving-array-map.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2510-dyn-evolving-array-map.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2511-dyn-evolving-array-filter-foreach.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2511-dyn-evolving-array-filter-foreach.ts.json new file mode 100644 index 000000000..c7658a486 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2511-dyn-evolving-array-filter-foreach.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2511-dyn-evolving-array-filter-foreach.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2512-dyn-evolving-array-mixed-push.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2512-dyn-evolving-array-mixed-push.ts.json new file mode 100644 index 000000000..f65e7f7ff --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2512-dyn-evolving-array-mixed-push.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2512-dyn-evolving-array-mixed-push.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2513-dyn-evolving-array-derived.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2513-dyn-evolving-array-derived.ts.json new file mode 100644 index 000000000..492976e7f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2513-dyn-evolving-array-derived.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2513-dyn-evolving-array-derived.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2520-private-statics-class-name-calls.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2520-private-statics-class-name-calls.ts.json new file mode 100644 index 000000000..7b8fe7818 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2520-private-statics-class-name-calls.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2520-private-statics-class-name-calls.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2521-private-statics-class-expression.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2521-private-statics-class-expression.ts.json new file mode 100644 index 000000000..052b3fd86 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2521-private-statics-class-expression.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2521-private-statics-class-expression.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2522-private-statics-decorated.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2522-private-statics-decorated.ts.json new file mode 100644 index 000000000..9e106e481 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2522-private-statics-decorated.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2522-private-statics-decorated.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2523-private-statics-aliased-class.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2523-private-statics-aliased-class.ts.json new file mode 100644 index 000000000..b68bee837 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2523-private-statics-aliased-class.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2523-private-statics-aliased-class.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2530-object-destructuring-decl.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2530-object-destructuring-decl.ts.json new file mode 100644 index 000000000..1ad7e9181 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2530-object-destructuring-decl.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2530-object-destructuring-decl.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2531-array-tuple-destructuring-decl.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2531-array-tuple-destructuring-decl.ts.json new file mode 100644 index 000000000..bf988491e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2531-array-tuple-destructuring-decl.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2531-array-tuple-destructuring-decl.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2532-param-destructuring-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2532-param-destructuring-options.ts.json new file mode 100644 index 000000000..bc1ed2392 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2532-param-destructuring-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2532-param-destructuring-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2533-forof-destructuring.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2533-forof-destructuring.ts.json new file mode 100644 index 000000000..25e6db7f0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2533-forof-destructuring.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2533-forof-destructuring.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2534-object-rest-decl.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2534-object-rest-decl.ts.json new file mode 100644 index 000000000..ee5586588 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2534-object-rest-decl.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2534-object-rest-decl.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2535-destructuring-assign-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2535-destructuring-assign-basics.ts.json new file mode 100644 index 000000000..a6e2da123 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2535-destructuring-assign-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2535-destructuring-assign-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2536-destructuring-assign-nested.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2536-destructuring-assign-nested.ts.json new file mode 100644 index 000000000..ea2b0d194 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2536-destructuring-assign-nested.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2536-destructuring-assign-nested.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2537-destructuring-assign-member-targets.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2537-destructuring-assign-member-targets.ts.json new file mode 100644 index 000000000..e0785d629 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2537-destructuring-assign-member-targets.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2537-destructuring-assign-member-targets.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2538-destructuring-assign-class-source.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2538-destructuring-assign-class-source.ts.json new file mode 100644 index 000000000..c77478048 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2538-destructuring-assign-class-source.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2538-destructuring-assign-class-source.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2539-class-instance-rest.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2539-class-instance-rest.ts.json new file mode 100644 index 000000000..24673793c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2539-class-instance-rest.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2539-class-instance-rest.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2540-accessor-destructuring-defaults.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2540-accessor-destructuring-defaults.ts.json new file mode 100644 index 000000000..36d691bd3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2540-accessor-destructuring-defaults.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2540-accessor-destructuring-defaults.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2541-destructuring-eval-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2541-destructuring-eval-order.ts.json new file mode 100644 index 000000000..919012b1b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2541-destructuring-eval-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2541-destructuring-eval-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2550-generics-keyof-pick.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2550-generics-keyof-pick.ts.json new file mode 100644 index 000000000..ca9cdc854 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2550-generics-keyof-pick.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2550-generics-keyof-pick.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2551-generics-value-aliases.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2551-generics-value-aliases.ts.json new file mode 100644 index 000000000..5c778a192 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2551-generics-value-aliases.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2551-generics-value-aliases.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2552-generics-iface-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2552-generics-iface-methods.ts.json new file mode 100644 index 000000000..25947bcbf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2552-generics-iface-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2552-generics-iface-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2553-generics-signature-bindings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2553-generics-signature-bindings.ts.json new file mode 100644 index 000000000..df7e57e7f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2553-generics-signature-bindings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2553-generics-signature-bindings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2554-generics-frontier-mix.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2554-generics-frontier-mix.ts.json new file mode 100644 index 000000000..cd7240024 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2554-generics-frontier-mix.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2554-generics-frontier-mix.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2555-generics-keyof-writes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2555-generics-keyof-writes.ts.json new file mode 100644 index 000000000..babdbe142 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2555-generics-keyof-writes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2555-generics-keyof-writes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2556-crypto-introspection.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2556-crypto-introspection.ts.json new file mode 100644 index 000000000..93814473a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2556-crypto-introspection.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2556-crypto-introspection.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2556-width-hybrid-shapes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2556-width-hybrid-shapes.ts.json new file mode 100644 index 000000000..fecafa8fc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2556-width-hybrid-shapes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2556-width-hybrid-shapes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2557-tls-ca-store.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2557-tls-ca-store.ts.json new file mode 100644 index 000000000..cdd237c25 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2557-tls-ca-store.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2557-tls-ca-store.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2557-width-field-lifts.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2557-width-field-lifts.ts.json new file mode 100644 index 000000000..f6e328354 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2557-width-field-lifts.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2557-width-field-lifts.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2558-index-signature-func-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2558-index-signature-func-values.ts.json new file mode 100644 index 000000000..4d5a3f138 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2558-index-signature-func-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2558-index-signature-func-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2558-rejection-events.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2558-rejection-events.cjs.json new file mode 100644 index 000000000..378ae434e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2558-rejection-events.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2558-rejection-events.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2559-index-signature-container-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2559-index-signature-container-values.ts.json new file mode 100644 index 000000000..7cc480f2a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2559-index-signature-container-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2559-index-signature-container-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2560-arraybuffer-dataview-set.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2560-arraybuffer-dataview-set.ts.json new file mode 100644 index 000000000..25e13a435 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2560-arraybuffer-dataview-set.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2560-arraybuffer-dataview-set.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2561-object-is.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2561-object-is.ts.json new file mode 100644 index 000000000..ba5d3775d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2561-object-is.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2561-object-is.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2562-intl-numberformat-en-us.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2562-intl-numberformat-en-us.ts.json new file mode 100644 index 000000000..fbdb5acd7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2562-intl-numberformat-en-us.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2562-intl-numberformat-en-us.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2563-stream-promises-pipeline.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2563-stream-promises-pipeline.ts.json new file mode 100644 index 000000000..140def851 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2563-stream-promises-pipeline.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2563-stream-promises-pipeline.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2564-stream-promises-finished.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2564-stream-promises-finished.ts.json new file mode 100644 index 000000000..d11f6a71a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2564-stream-promises-finished.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2564-stream-promises-finished.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2565-stream-promises-js.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2565-stream-promises-js.cjs.json new file mode 100644 index 000000000..22f60ada5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2565-stream-promises-js.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2565-stream-promises-js.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2566-promise-reject-dyn-reason.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2566-promise-reject-dyn-reason.js.json new file mode 100644 index 000000000..ed077434b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2566-promise-reject-dyn-reason.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2566-promise-reject-dyn-reason.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2567-rest-spread-forward.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2567-rest-spread-forward.js.json new file mode 100644 index 000000000..6562527bd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2567-rest-spread-forward.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2567-rest-spread-forward.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2568-rest-spread-forward-dynamic.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2568-rest-spread-forward-dynamic.js.json new file mode 100644 index 000000000..b8c1cf4e2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2568-rest-spread-forward-dynamic.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2568-rest-spread-forward-dynamic.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2569-upcast-identity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2569-upcast-identity.ts.json new file mode 100644 index 000000000..5d5038218 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2569-upcast-identity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2569-upcast-identity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2570-buffer-arg-validation.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2570-buffer-arg-validation.cjs.json new file mode 100644 index 000000000..4bb4936c3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2570-buffer-arg-validation.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2570-buffer-arg-validation.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2571-searchparams-arg-validation.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2571-searchparams-arg-validation.cjs.json new file mode 100644 index 000000000..7f02624a5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2571-searchparams-arg-validation.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2571-searchparams-arg-validation.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2572-readable-emitted-readable-flag.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2572-readable-emitted-readable-flag.cjs.json new file mode 100644 index 000000000..a92b93a2e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2572-readable-emitted-readable-flag.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2572-readable-emitted-readable-flag.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2573-fs-url-arg-ladders.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2573-fs-url-arg-ladders.cjs.json new file mode 100644 index 000000000..fc3920b6d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2573-fs-url-arg-ladders.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2573-fs-url-arg-ladders.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2574-emitter-max-listeners-ladders.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2574-emitter-max-listeners-ladders.cjs.json new file mode 100644 index 000000000..645e74089 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2574-emitter-max-listeners-ladders.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2574-emitter-max-listeners-ladders.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2575-string-destructuring-decl.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2575-string-destructuring-decl.ts.json new file mode 100644 index 000000000..96063a2cb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2575-string-destructuring-decl.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2575-string-destructuring-decl.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2576-string-destructuring-assign.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2576-string-destructuring-assign.ts.json new file mode 100644 index 000000000..c5ab789ed --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2576-string-destructuring-assign.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2576-string-destructuring-assign.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2577-builtin-global-destructuring.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2577-builtin-global-destructuring.js.json new file mode 100644 index 000000000..c746ccc91 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2577-builtin-global-destructuring.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2577-builtin-global-destructuring.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2578-jsval-into-unknown-rows.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2578-jsval-into-unknown-rows.ts.json new file mode 100644 index 000000000..74aee532f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2578-jsval-into-unknown-rows.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2578-jsval-into-unknown-rows.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2579-jsval-object-param-crossing.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2579-jsval-object-param-crossing.js.json new file mode 100644 index 000000000..49e26f551 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2579-jsval-object-param-crossing.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2579-jsval-object-param-crossing.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2580-jsval-routed-keyed-ops.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2580-jsval-routed-keyed-ops.js.json new file mode 100644 index 000000000..70b9f1e59 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2580-jsval-routed-keyed-ops.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2580-jsval-routed-keyed-ops.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2581-jsval-routed-calls.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2581-jsval-routed-calls.js.json new file mode 100644 index 000000000..5af1ff5cc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2581-jsval-routed-calls.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2581-jsval-routed-calls.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2582-jsval-object-statics.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2582-jsval-object-statics.js.json new file mode 100644 index 000000000..bc91c8b20 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2582-jsval-object-statics.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2582-jsval-object-statics.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2582-jsval-routed-keyed-ops.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2582-jsval-routed-keyed-ops.js.json new file mode 100644 index 000000000..eb1689d50 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2582-jsval-routed-keyed-ops.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2582-jsval-routed-keyed-ops.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2583-dyn-nullish-coalesce.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2583-dyn-nullish-coalesce.js.json new file mode 100644 index 000000000..c3b82f7a7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2583-dyn-nullish-coalesce.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2583-dyn-nullish-coalesce.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2583-jsval-routed-calls.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2583-jsval-routed-calls.js.json new file mode 100644 index 000000000..fda256459 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2583-jsval-routed-calls.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2583-jsval-routed-calls.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2584-jsval-object-statics.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2584-jsval-object-statics.js.json new file mode 100644 index 000000000..ff9d14e66 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2584-jsval-object-statics.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2584-jsval-object-statics.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2584-union-dyn-collapse.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2584-union-dyn-collapse.ts.json new file mode 100644 index 000000000..967108ddd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2584-union-dyn-collapse.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2584-union-dyn-collapse.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2585-dyn-nullish-coalesce.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2585-dyn-nullish-coalesce.js.json new file mode 100644 index 000000000..5f45a7b53 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2585-dyn-nullish-coalesce.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2585-dyn-nullish-coalesce.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2585-unknown-array.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2585-unknown-array.ts.json new file mode 100644 index 000000000..5612284b3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2585-unknown-array.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2585-unknown-array.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2586-object-assign-spread.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2586-object-assign-spread.js.json new file mode 100644 index 000000000..2f26f1240 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2586-object-assign-spread.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2586-object-assign-spread.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2587-array-entries-forof.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2587-array-entries-forof.ts.json new file mode 100644 index 000000000..3b3e5bede --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2587-array-entries-forof.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2587-array-entries-forof.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2588-array-entries-chains.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2588-array-entries-chains.ts.json new file mode 100644 index 000000000..857e0e283 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2588-array-entries-chains.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2588-array-entries-chains.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2589-object-create-null.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2589-object-create-null.cjs.json new file mode 100644 index 000000000..388768114 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2589-object-create-null.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2589-object-create-null.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2590-object-create-dynamic.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2590-object-create-dynamic.js.json new file mode 100644 index 000000000..4c91d282e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2590-object-create-dynamic.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2590-object-create-dynamic.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2591-ambient-generic-traps.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2591-ambient-generic-traps.ts.json new file mode 100644 index 000000000..c7a7a7bc6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2591-ambient-generic-traps.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2591-ambient-generic-traps.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2592-ambient-trap-uncaught.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2592-ambient-trap-uncaught.ts.json new file mode 100644 index 000000000..9a437202e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2592-ambient-trap-uncaught.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2592-ambient-trap-uncaught.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2593-generic-inert-bindings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2593-generic-inert-bindings.ts.json new file mode 100644 index 000000000..cc6d8f4c4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2593-generic-inert-bindings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2593-generic-inert-bindings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2594-nullish-generic-bindings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2594-nullish-generic-bindings.ts.json new file mode 100644 index 000000000..9d934e90c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2594-nullish-generic-bindings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2594-nullish-generic-bindings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2595-fs-arg-ladders.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2595-fs-arg-ladders.cjs.json new file mode 100644 index 000000000..94334819a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2595-fs-arg-ladders.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2595-fs-arg-ladders.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2596-net-arg-ladders.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2596-net-arg-ladders.cjs.json new file mode 100644 index 000000000..0981d52b7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2596-net-arg-ladders.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2596-net-arg-ladders.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2597-dgram-send-ladders.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2597-dgram-send-ladders.cjs.json new file mode 100644 index 000000000..2f45d237d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2597-dgram-send-ladders.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2597-dgram-send-ladders.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2598-tls-arg-ladders.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2598-tls-arg-ladders.cjs.json new file mode 100644 index 000000000..72061dda3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2598-tls-arg-ladders.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2598-tls-arg-ladders.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2599-stream-arg-ladders.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2599-stream-arg-ladders.cjs.json new file mode 100644 index 000000000..31a9817bb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2599-stream-arg-ladders.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2599-stream-arg-ladders.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2600-dyn-keyed-write-harness.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2600-dyn-keyed-write-harness.js.json new file mode 100644 index 000000000..4543d87f7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2600-dyn-keyed-write-harness.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2600-dyn-keyed-write-harness.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2601-dyn-keyed-write-ops.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2601-dyn-keyed-write-ops.js.json new file mode 100644 index 000000000..15ca0eb50 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2601-dyn-keyed-write-ops.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2601-dyn-keyed-write-ops.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2602-dyn-array-destructure.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2602-dyn-array-destructure.js.json new file mode 100644 index 000000000..f6653a6c6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2602-dyn-array-destructure.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2602-dyn-array-destructure.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2603-island-keyed-write-dyn.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2603-island-keyed-write-dyn.js.json new file mode 100644 index 000000000..a2b27b4d5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2603-island-keyed-write-dyn.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2603-island-keyed-write-dyn.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2604-cycle-classes-mutual/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2604-cycle-classes-mutual/main.ts.json new file mode 100644 index 000000000..18b58e67d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2604-cycle-classes-mutual/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/2604-cycle-classes-mutual/group.ts", + "/tests/corpus/2604-cycle-classes-mutual/item.ts", + "/tests/corpus/2604-cycle-classes-mutual/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2605-cycle-three-module/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2605-cycle-three-module/main.ts.json new file mode 100644 index 000000000..2dfe9cf07 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2605-cycle-three-module/main.ts.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/2605-cycle-three-module/c.ts", + "/tests/corpus/2605-cycle-three-module/b.ts", + "/tests/corpus/2605-cycle-three-module/a.ts", + "/tests/corpus/2605-cycle-three-module/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2606-dynamic-import-cycle/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2606-dynamic-import-cycle/main.ts.json new file mode 100644 index 000000000..5382d575f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2606-dynamic-import-cycle/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2606-dynamic-import-cycle/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2608-regex-named-groups.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2608-regex-named-groups.ts.json new file mode 100644 index 000000000..c4e5c2d0a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2608-regex-named-groups.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2608-regex-named-groups.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2609-regex-named-replace.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2609-regex-named-replace.ts.json new file mode 100644 index 000000000..3607271cb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2609-regex-named-replace.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2609-regex-named-replace.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2610-regex-named-matchall.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2610-regex-named-matchall.ts.json new file mode 100644 index 000000000..23893a1aa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2610-regex-named-matchall.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2610-regex-named-matchall.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2611-regex-named-groups-js.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2611-regex-named-groups-js.cjs.json new file mode 100644 index 000000000..b711b109d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2611-regex-named-groups-js.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2611-regex-named-groups-js.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2613-for-init-uninitialized-let.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2613-for-init-uninitialized-let.ts.json new file mode 100644 index 000000000..4ebd2f89a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2613-for-init-uninitialized-let.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2613-for-init-uninitialized-let.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2614-trap-binding-later-writes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2614-trap-binding-later-writes.ts.json new file mode 100644 index 000000000..0bc833646 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2614-trap-binding-later-writes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2614-trap-binding-later-writes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2615-nullish-field-record-binding.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2615-nullish-field-record-binding.ts.json new file mode 100644 index 000000000..08f9b6523 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2615-nullish-field-record-binding.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2615-nullish-field-record-binding.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2616-js-collect-probe-defers.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2616-js-collect-probe-defers.js.json new file mode 100644 index 000000000..a321b224f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2616-js-collect-probe-defers.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2616-js-collect-probe-defers.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2617-enum-static-field-import/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2617-enum-static-field-import/main.ts.json new file mode 100644 index 000000000..d3e6234ec --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2617-enum-static-field-import/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2617-enum-static-field-import/a.ts", + "/tests/corpus/2617-enum-static-field-import/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2618-ee-emit-override.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2618-ee-emit-override.ts.json new file mode 100644 index 000000000..b4404853c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2618-ee-emit-override.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2618-ee-emit-override.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2619-ee-override-chain.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2619-ee-override-chain.ts.json new file mode 100644 index 000000000..8a4781876 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2619-ee-override-chain.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2619-ee-override-chain.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2620-ee-override-once-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2620-ee-override-once-order.ts.json new file mode 100644 index 000000000..a17e6c05b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2620-ee-override-once-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2620-ee-override-once-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2621-ee-override-error-throw.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2621-ee-override-error-throw.ts.json new file mode 100644 index 000000000..9fff6ac4e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2621-ee-override-error-throw.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2621-ee-override-error-throw.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2622-ee-override-filter.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2622-ee-override-filter.ts.json new file mode 100644 index 000000000..f0f36c056 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2622-ee-override-filter.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2622-ee-override-filter.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2623-ee-job-queue.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2623-ee-job-queue.ts.json new file mode 100644 index 000000000..3a018e3e4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2623-ee-job-queue.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2623-ee-job-queue.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2624-ee-override-js.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2624-ee-override-js.cjs.json new file mode 100644 index 000000000..b63e2d655 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2624-ee-override-js.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2624-ee-override-js.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2625-bytes-views.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2625-bytes-views.ts.json new file mode 100644 index 000000000..1ee4050dc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2625-bytes-views.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2625-bytes-views.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2626-stream-event-names.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2626-stream-event-names.ts.json new file mode 100644 index 000000000..bed3d3e8a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2626-stream-event-names.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2626-stream-event-names.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2627-stream-ticks-are-nextticks.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2627-stream-ticks-are-nextticks.ts.json new file mode 100644 index 000000000..d5ab0696a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2627-stream-ticks-are-nextticks.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2627-stream-ticks-are-nextticks.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2628-stream-push-encodings.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2628-stream-push-encodings.cjs.json new file mode 100644 index 000000000..e1ba0efb3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2628-stream-push-encodings.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2628-stream-push-encodings.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2629-stream-consumers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2629-stream-consumers.ts.json new file mode 100644 index 000000000..e562433df --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2629-stream-consumers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2629-stream-consumers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2630-stream-consumers-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2630-stream-consumers-errors.ts.json new file mode 100644 index 000000000..0f69dc52e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2630-stream-consumers-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2630-stream-consumers-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2631-create-require/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2631-create-require/main.ts.json new file mode 100644 index 000000000..c8132a52e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2631-create-require/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2631-create-require/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2632-dyn-jsval-iterate.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2632-dyn-jsval-iterate.js.json new file mode 100644 index 000000000..294976733 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2632-dyn-jsval-iterate.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2632-dyn-jsval-iterate.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2633-island-promise-crossing.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2633-island-promise-crossing.js.json new file mode 100644 index 000000000..380d81bca --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2633-island-promise-crossing.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2633-island-promise-crossing.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2634-stream-pipeline-arg-ladders.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2634-stream-pipeline-arg-ladders.cjs.json new file mode 100644 index 000000000..f151870c8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2634-stream-pipeline-arg-ladders.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2634-stream-pipeline-arg-ladders.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2635-trap-binding-unmappable-written.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2635-trap-binding-unmappable-written.ts.json new file mode 100644 index 000000000..ba7927755 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2635-trap-binding-unmappable-written.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2635-trap-binding-unmappable-written.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2636-trap-binding-ambient-rooted-rewrite.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2636-trap-binding-ambient-rooted-rewrite.ts.json new file mode 100644 index 000000000..e20ec972c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2636-trap-binding-ambient-rooted-rewrite.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2636-trap-binding-ambient-rooted-rewrite.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2637-create-require-bare/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2637-create-require-bare/main.ts.json new file mode 100644 index 000000000..260dd7489 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2637-create-require-bare/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2637-create-require-bare/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2638-http-dyn-res-compat.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2638-http-dyn-res-compat.cjs.json new file mode 100644 index 000000000..0a27385f4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2638-http-dyn-res-compat.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2638-http-dyn-res-compat.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2639-http-dyn-req-pause.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2639-http-dyn-req-pause.cjs.json new file mode 100644 index 000000000..69493c645 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2639-http-dyn-req-pause.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2639-http-dyn-req-pause.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2640-net-dyn-socket-compat.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2640-net-dyn-socket-compat.cjs.json new file mode 100644 index 000000000..4429c81fe --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2640-net-dyn-socket-compat.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2640-net-dyn-socket-compat.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2641-http-agent-surface.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2641-http-agent-surface.cjs.json new file mode 100644 index 000000000..b51eb22f1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2641-http-agent-surface.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2641-http-agent-surface.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2642-http-agent-maxsockets.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2642-http-agent-maxsockets.cjs.json new file mode 100644 index 000000000..f94989f94 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2642-http-agent-maxsockets.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2642-http-agent-maxsockets.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2643-or-default-retag.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2643-or-default-retag.ts.json new file mode 100644 index 000000000..aae84e9bd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2643-or-default-retag.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2643-or-default-retag.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2644-http-client-url-argument.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2644-http-client-url-argument.ts.json new file mode 100644 index 000000000..24f0f6217 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2644-http-client-url-argument.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2644-http-client-url-argument.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2645-https-client-url-argument.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2645-https-client-url-argument.ts.json new file mode 100644 index 000000000..d8016e81c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2645-https-client-url-argument.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2645-https-client-url-argument.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2646-top-level-await.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2646-top-level-await.ts.json new file mode 100644 index 000000000..24bd17e3b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2646-top-level-await.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2646-top-level-await.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2647-top-level-await-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2647-top-level-await-modules/main.ts.json new file mode 100644 index 000000000..16d5bc6d2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2647-top-level-await-modules/main.ts.json @@ -0,0 +1,10 @@ +{ + "order": [ + "/tests/corpus/2647-top-level-await-modules/shared.ts", + "/tests/corpus/2647-top-level-await-modules/left.ts", + "/tests/corpus/2647-top-level-await-modules/sibling.ts", + "/tests/corpus/2647-top-level-await-modules/right.ts", + "/tests/corpus/2647-top-level-await-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2648-top-level-await-rejection.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2648-top-level-await-rejection.ts.json new file mode 100644 index 000000000..b2ffea400 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2648-top-level-await-rejection.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2648-top-level-await-rejection.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2649-top-level-await-pending.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2649-top-level-await-pending.ts.json new file mode 100644 index 000000000..d0764c922 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2649-top-level-await-pending.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2649-top-level-await-pending.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2650-top-level-await-self-import.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2650-top-level-await-self-import.ts.json new file mode 100644 index 000000000..584d9c53e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2650-top-level-await-self-import.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2650-top-level-await-self-import.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2651-top-level-await-pending-unhandled.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2651-top-level-await-pending-unhandled.ts.json new file mode 100644 index 000000000..9a6101d32 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2651-top-level-await-pending-unhandled.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2651-top-level-await-pending-unhandled.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2652-top-level-await-dynamic/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2652-top-level-await-dynamic/main.ts.json new file mode 100644 index 000000000..6b54185c0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2652-top-level-await-dynamic/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2652-top-level-await-dynamic/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2653-top-level-await-rejection-stops-loop.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2653-top-level-await-rejection-stops-loop.ts.json new file mode 100644 index 000000000..31c35df2e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2653-top-level-await-rejection-stops-loop.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2653-top-level-await-rejection-stops-loop.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2654-top-level-await-unrelated-rejection.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2654-top-level-await-unrelated-rejection.ts.json new file mode 100644 index 000000000..1a945872c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2654-top-level-await-unrelated-rejection.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2654-top-level-await-unrelated-rejection.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2655-top-level-await-cycle/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2655-top-level-await-cycle/main.ts.json new file mode 100644 index 000000000..b265469af --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2655-top-level-await-cycle/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2655-top-level-await-cycle/b.ts", + "/tests/corpus/2655-top-level-await-cycle/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2656-top-level-await-cycle-order/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2656-top-level-await-cycle-order/main.ts.json new file mode 100644 index 000000000..009c1fc58 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2656-top-level-await-cycle-order/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2656-top-level-await-cycle-order/a.ts", + "/tests/corpus/2656-top-level-await-cycle-order/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2657-top-level-await-cycle-dynamic/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2657-top-level-await-cycle-dynamic/main.ts.json new file mode 100644 index 000000000..08daf3ce3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2657-top-level-await-cycle-dynamic/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2657-top-level-await-cycle-dynamic/b.ts", + "/tests/corpus/2657-top-level-await-cycle-dynamic/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2658-top-level-await-sync-completion/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2658-top-level-await-sync-completion/main.ts.json new file mode 100644 index 000000000..bacced72c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2658-top-level-await-sync-completion/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2658-top-level-await-sync-completion/dep.ts", + "/tests/corpus/2658-top-level-await-sync-completion/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2659-top-level-await-dynamic-cycle/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2659-top-level-await-dynamic-cycle/main.ts.json new file mode 100644 index 000000000..9efbe220b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2659-top-level-await-dynamic-cycle/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2659-top-level-await-dynamic-cycle/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2660-top-level-await-cycle-rejection/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2660-top-level-await-cycle-rejection/main.ts.json new file mode 100644 index 000000000..d86cebaef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2660-top-level-await-cycle-rejection/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2660-top-level-await-cycle-rejection/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2661-top-level-await-dynamic-runtime-root/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2661-top-level-await-dynamic-runtime-root/main.ts.json new file mode 100644 index 000000000..a279d5eb6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2661-top-level-await-dynamic-runtime-root/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2661-top-level-await-dynamic-runtime-root/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2662-top-level-await-cycle-external-wait/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2662-top-level-await-cycle-external-wait/main.ts.json new file mode 100644 index 000000000..702fd35be --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2662-top-level-await-cycle-external-wait/main.ts.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/2662-top-level-await-cycle-external-wait/b.ts", + "/tests/corpus/2662-top-level-await-cycle-external-wait/a.ts", + "/tests/corpus/2662-top-level-await-cycle-external-wait/waiter.ts", + "/tests/corpus/2662-top-level-await-cycle-external-wait/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2663-top-level-await-dependency-errors/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2663-top-level-await-dependency-errors/main.ts.json new file mode 100644 index 000000000..9ca45d0be --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2663-top-level-await-dependency-errors/main.ts.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/2663-top-level-await-dependency-errors/listener.ts", + "/tests/corpus/2663-top-level-await-dependency-errors/async-bad.ts", + "/tests/corpus/2663-top-level-await-dependency-errors/sync-bad.ts", + "/tests/corpus/2663-top-level-await-dependency-errors/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2664-top-level-await-same-checkpoint-rejection.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2664-top-level-await-same-checkpoint-rejection.ts.json new file mode 100644 index 000000000..e557092f7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2664-top-level-await-same-checkpoint-rejection.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2664-top-level-await-same-checkpoint-rejection.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2665-top-level-await-unhandled-listener-liveness.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2665-top-level-await-unhandled-listener-liveness.ts.json new file mode 100644 index 000000000..7928d9cc6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2665-top-level-await-unhandled-listener-liveness.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2665-top-level-await-unhandled-listener-liveness.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2666-array-to-sorted.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2666-array-to-sorted.ts.json new file mode 100644 index 000000000..950f884f0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2666-array-to-sorted.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2666-array-to-sorted.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2667-array-to-sorted-any.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2667-array-to-sorted-any.ts.json new file mode 100644 index 000000000..187b861e9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2667-array-to-sorted-any.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2667-array-to-sorted-any.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2668-stored-number-array-iterator.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2668-stored-number-array-iterator.ts.json new file mode 100644 index 000000000..a54da299f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2668-stored-number-array-iterator.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2668-stored-number-array-iterator.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2669-array-copying-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2669-array-copying-methods.ts.json new file mode 100644 index 000000000..36fe337f8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2669-array-copying-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2669-array-copying-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2670-uint8array-copy-iterate.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2670-uint8array-copy-iterate.ts.json new file mode 100644 index 000000000..65ec292d7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2670-uint8array-copy-iterate.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2670-uint8array-copy-iterate.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2671-array-copying-js.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2671-array-copying-js.cjs.json new file mode 100644 index 000000000..9f79be30f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2671-array-copying-js.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2671-array-copying-js.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2672-http-request-response-callback.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2672-http-request-response-callback.ts.json new file mode 100644 index 000000000..f1ffebbed --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2672-http-request-response-callback.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2672-http-request-response-callback.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2673-top-level-await-implicit-module.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2673-top-level-await-implicit-module.ts.json new file mode 100644 index 000000000..922532f06 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2673-top-level-await-implicit-module.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2673-top-level-await-implicit-module.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2674-top-level-for-await-implicit-module.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2674-top-level-for-await-implicit-module.ts.json new file mode 100644 index 000000000..60a2024e6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2674-top-level-for-await-implicit-module.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2674-top-level-for-await-implicit-module.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2675-create-require-nested-esm.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2675-create-require-nested-esm.js.json new file mode 100644 index 000000000..e545d35c8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2675-create-require-nested-esm.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2675-create-require-nested-esm.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2675-process-self-reexec.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2675-process-self-reexec.ts.json new file mode 100644 index 000000000..69bcb81df --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2675-process-self-reexec.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2675-process-self-reexec.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2676-indexed-read-strict-equality.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2676-indexed-read-strict-equality.ts.json new file mode 100644 index 000000000..7e2a7347d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2676-indexed-read-strict-equality.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2676-indexed-read-strict-equality.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2676-record-clone-overrides.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2676-record-clone-overrides.ts.json new file mode 100644 index 000000000..952c6d8a2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2676-record-clone-overrides.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2676-record-clone-overrides.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2676-top-level-await-ambiguous/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2676-top-level-await-ambiguous/main.ts.json new file mode 100644 index 000000000..d54da155a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2676-top-level-await-ambiguous/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2676-top-level-await-ambiguous/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2677-runtime-optional-closure.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2677-runtime-optional-closure.ts.json new file mode 100644 index 000000000..61c213625 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2677-runtime-optional-closure.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2677-runtime-optional-closure.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2677-top-level-await-module-scope/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2677-top-level-await-module-scope/main.ts.json new file mode 100644 index 000000000..9ebc191b7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2677-top-level-await-module-scope/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/2677-top-level-await-module-scope/a.ts", + "/tests/corpus/2677-top-level-await-module-scope/b.ts", + "/tests/corpus/2677-top-level-await-module-scope/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2678-date-instances.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2678-date-instances.ts.json new file mode 100644 index 000000000..6e52f3ac9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2678-date-instances.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2678-date-instances.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2678-large-string-sparse-index.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2678-large-string-sparse-index.ts.json new file mode 100644 index 000000000..9744eddf5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2678-large-string-sparse-index.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2678-large-string-sparse-index.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2678-util-parseargs.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2678-util-parseargs.ts.json new file mode 100644 index 000000000..86cbb225f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2678-util-parseargs.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2678-util-parseargs.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2679-util-parseargs-cjs.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2679-util-parseargs-cjs.cjs.json new file mode 100644 index 000000000..b4ed3c80b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2679-util-parseargs-cjs.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2679-util-parseargs-cjs.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2680-util-parseargs-default.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2680-util-parseargs-default.ts.json new file mode 100644 index 000000000..d13aa9b30 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2680-util-parseargs-default.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2680-util-parseargs-default.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2681-util-parseargs-dynamic.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2681-util-parseargs-dynamic.js.json new file mode 100644 index 000000000..8924f7461 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2681-util-parseargs-dynamic.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2681-util-parseargs-dynamic.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2682-fs-rename.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2682-fs-rename.ts.json new file mode 100644 index 000000000..4cecf4693 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2682-fs-rename.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2682-fs-rename.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2683-filter-truthy-predicate.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2683-filter-truthy-predicate.ts.json new file mode 100644 index 000000000..186d4fa63 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2683-filter-truthy-predicate.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2683-filter-truthy-predicate.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2683-fs-rename-js.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2683-fs-rename-js.cjs.json new file mode 100644 index 000000000..cfc4944b0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2683-fs-rename-js.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2683-fs-rename-js.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2684-filter-no-predicate-dyn.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2684-filter-no-predicate-dyn.cjs.json new file mode 100644 index 000000000..56abca8bc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2684-filter-no-predicate-dyn.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2684-filter-no-predicate-dyn.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2684-fs-rename-abort.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2684-fs-rename-abort.ts.json new file mode 100644 index 000000000..2a394d0ef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2684-fs-rename-abort.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2684-fs-rename-abort.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2685-array-unshift-reverse.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2685-array-unshift-reverse.ts.json new file mode 100644 index 000000000..3bf3c7dab --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2685-array-unshift-reverse.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2685-array-unshift-reverse.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2685-fs-write-sync.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2685-fs-write-sync.ts.json new file mode 100644 index 000000000..c4cd80419 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2685-fs-write-sync.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2685-fs-write-sync.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2686-fs-file-handle.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2686-fs-file-handle.ts.json new file mode 100644 index 000000000..331fb8aad --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2686-fs-file-handle.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2686-fs-file-handle.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2687-fsp-write-file-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2687-fsp-write-file-options.ts.json new file mode 100644 index 000000000..b62d8e912 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2687-fsp-write-file-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2687-fsp-write-file-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2687-process-write-args.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2687-process-write-args.ts.json new file mode 100644 index 000000000..157d03014 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2687-process-write-args.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2687-process-write-args.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2688-fs-stats-disk-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2688-fs-stats-disk-fields.ts.json new file mode 100644 index 000000000..0a19313f3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2688-fs-stats-disk-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2688-fs-stats-disk-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2689-http-server-timeout-properties.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2689-http-server-timeout-properties.ts.json new file mode 100644 index 000000000..e9f62b365 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2689-http-server-timeout-properties.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2689-http-server-timeout-properties.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2690-https-server-timeout-option.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2690-https-server-timeout-option.ts.json new file mode 100644 index 000000000..8a781c514 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2690-https-server-timeout-option.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2690-https-server-timeout-option.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2691-retained-lowering-record-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2691-retained-lowering-record-order.ts.json new file mode 100644 index 000000000..e9a8fbc42 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2691-retained-lowering-record-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2691-retained-lowering-record-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2692-inline-record-assert-index.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2692-inline-record-assert-index.ts.json new file mode 100644 index 000000000..3c225a517 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2692-inline-record-assert-index.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2692-inline-record-assert-index.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2692-string-accumulation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2692-string-accumulation.ts.json new file mode 100644 index 000000000..6e208688a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2692-string-accumulation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2692-string-accumulation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2693-math-constants.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2693-math-constants.ts.json new file mode 100644 index 000000000..f7a6625d9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2693-math-constants.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2693-math-constants.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2700-array-sort-complexity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2700-array-sort-complexity.ts.json new file mode 100644 index 000000000..f7b1823d0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2700-array-sort-complexity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2700-array-sort-complexity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2700-http-static-trailers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2700-http-static-trailers.ts.json new file mode 100644 index 000000000..54ebb1332 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2700-http-static-trailers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2700-http-static-trailers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2700-wasi-core.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2700-wasi-core.ts.json new file mode 100644 index 000000000..dc79981bb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2700-wasi-core.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2700-wasi-core.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2701-array-sort-snapshot.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2701-array-sort-snapshot.ts.json new file mode 100644 index 000000000..4c3913ad4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2701-array-sort-snapshot.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2701-array-sort-snapshot.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2701-http-static-trailer-wire.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2701-http-static-trailer-wire.ts.json new file mode 100644 index 000000000..369680cf6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2701-http-static-trailer-wire.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2701-http-static-trailer-wire.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2701-import-meta/main.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2701-import-meta/main.mjs.json new file mode 100644 index 000000000..dfbaf5066 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2701-import-meta/main.mjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2701-import-meta/module with space.mjs", + "/tests/corpus/2701-import-meta/main.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2702-http-static-trailer-end.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2702-http-static-trailer-end.ts.json new file mode 100644 index 000000000..6a0950ed4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2702-http-static-trailer-end.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2702-http-static-trailer-end.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2702-type-import-link-static/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2702-type-import-link-static/main.ts.json new file mode 100644 index 000000000..6c651b362 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2702-type-import-link-static/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2702-type-import-link-static/types.ts", + "/tests/corpus/2702-type-import-link-static/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2702-uint8array-to-sorted.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2702-uint8array-to-sorted.ts.json new file mode 100644 index 000000000..694107846 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2702-uint8array-to-sorted.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2702-uint8array-to-sorted.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2703-array-sparse-sort.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2703-array-sparse-sort.ts.json new file mode 100644 index 000000000..8989141e1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2703-array-sparse-sort.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2703-array-sparse-sort.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2703-type-import-link-static-reexport/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2703-type-import-link-static-reexport/main.ts.json new file mode 100644 index 000000000..142fac401 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2703-type-import-link-static-reexport/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/2703-type-import-link-static-reexport/types.ts", + "/tests/corpus/2703-type-import-link-static-reexport/middle.ts", + "/tests/corpus/2703-type-import-link-static-reexport/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2704-array-sparse-to-sorted.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2704-array-sparse-to-sorted.ts.json new file mode 100644 index 000000000..6f18a347e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2704-array-sparse-to-sorted.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2704-array-sparse-to-sorted.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2704-type-import-link-static-success/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2704-type-import-link-static-success/main.ts.json new file mode 100644 index 000000000..59715174e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2704-type-import-link-static-success/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2704-type-import-link-static-success/types.ts", + "/tests/corpus/2704-type-import-link-static-success/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2705-array-sparse-sort-append.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2705-array-sparse-sort-append.ts.json new file mode 100644 index 000000000..c93adcab3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2705-array-sparse-sort-append.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2705-array-sparse-sort-append.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2705-type-import-link-dynamic/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2705-type-import-link-dynamic/main.ts.json new file mode 100644 index 000000000..850681c22 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2705-type-import-link-dynamic/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2705-type-import-link-dynamic/types.ts", + "/tests/corpus/2705-type-import-link-dynamic/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2706-array-search-missing-needle.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2706-array-search-missing-needle.ts.json new file mode 100644 index 000000000..5c2d2b1da --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2706-array-search-missing-needle.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2706-array-search-missing-needle.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2706-type-import-link-dynamic-success/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2706-type-import-link-dynamic-success/main.ts.json new file mode 100644 index 000000000..da2f5ac73 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2706-type-import-link-dynamic-success/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2706-type-import-link-dynamic-success/types.ts", + "/tests/corpus/2706-type-import-link-dynamic-success/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2707-array-search-huge-sparse.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2707-array-search-huge-sparse.ts.json new file mode 100644 index 000000000..3c7cc1fbc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2707-array-search-huge-sparse.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2707-array-search-huge-sparse.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2707-type-import-link-static-default-reexport/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2707-type-import-link-static-default-reexport/main.ts.json new file mode 100644 index 000000000..ccf4ae13c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2707-type-import-link-static-default-reexport/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/2707-type-import-link-static-default-reexport/types.ts", + "/tests/corpus/2707-type-import-link-static-default-reexport/reexport.ts", + "/tests/corpus/2707-type-import-link-static-default-reexport/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2708-type-import-link-dynamic/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2708-type-import-link-dynamic/main.ts.json new file mode 100644 index 000000000..6de18782b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2708-type-import-link-dynamic/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2708-type-import-link-dynamic/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2720-array-read-parity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2720-array-read-parity.ts.json new file mode 100644 index 000000000..604ba42ee --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2720-array-read-parity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2720-array-read-parity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2721-array-nested-missing-receiver.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2721-array-nested-missing-receiver.ts.json new file mode 100644 index 000000000..46e5bd20d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2721-array-nested-missing-receiver.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2721-array-nested-missing-receiver.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2750-array-sparse-foundation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2750-array-sparse-foundation.ts.json new file mode 100644 index 000000000..ae03fde12 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2750-array-sparse-foundation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2750-array-sparse-foundation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2751-buffer-concat-sparse-list.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2751-buffer-concat-sparse-list.ts.json new file mode 100644 index 000000000..46f477317 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2751-buffer-concat-sparse-list.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2751-buffer-concat-sparse-list.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2752-array-optional-stores.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2752-array-optional-stores.ts.json new file mode 100644 index 000000000..d62f97bbd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2752-array-optional-stores.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2752-array-optional-stores.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2753-array-optional-method-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2753-array-optional-method-values.ts.json new file mode 100644 index 000000000..63c3b53d7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2753-array-optional-method-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2753-array-optional-method-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2754-array-property-undefined.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2754-array-property-undefined.ts.json new file mode 100644 index 000000000..4f33355bc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2754-array-property-undefined.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2754-array-property-undefined.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2755-array-optional-literal-forwarding.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2755-array-optional-literal-forwarding.ts.json new file mode 100644 index 000000000..956e9f682 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2755-array-optional-literal-forwarding.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2755-array-optional-literal-forwarding.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2780-array-parity-composition.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2780-array-parity-composition.ts.json new file mode 100644 index 000000000..5cdc5d46e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2780-array-parity-composition.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2780-array-parity-composition.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2781-array-missing-value-escape.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2781-array-missing-value-escape.ts.json new file mode 100644 index 000000000..6db27f07d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2781-array-missing-value-escape.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2781-array-missing-value-escape.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2782-array-sparse-callbacks.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2782-array-sparse-callbacks.ts.json new file mode 100644 index 000000000..736a74ee8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2782-array-sparse-callbacks.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2782-array-sparse-callbacks.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2783-array-defaults-rest.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2783-array-defaults-rest.ts.json new file mode 100644 index 000000000..924811cd6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2783-array-defaults-rest.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2783-array-defaults-rest.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2784-array-reduce-missing-result.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2784-array-reduce-missing-result.ts.json new file mode 100644 index 000000000..6f3616db4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2784-array-reduce-missing-result.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2784-array-reduce-missing-result.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2785-array-missing-destructuring.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2785-array-missing-destructuring.ts.json new file mode 100644 index 000000000..8a4aceae8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2785-array-missing-destructuring.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2785-array-missing-destructuring.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2786-array-sparse-serialization.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2786-array-sparse-serialization.ts.json new file mode 100644 index 000000000..6441be04e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2786-array-sparse-serialization.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2786-array-sparse-serialization.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2787-array-missing-string-arithmetic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2787-array-missing-string-arithmetic.ts.json new file mode 100644 index 000000000..1334a0328 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2787-array-missing-string-arithmetic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2787-array-missing-string-arithmetic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2788-array-missing-builtin-conversions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2788-array-missing-builtin-conversions.ts.json new file mode 100644 index 000000000..4a073bad8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2788-array-missing-builtin-conversions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2788-array-missing-builtin-conversions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2789-array-missing-optional-tostring.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2789-array-missing-optional-tostring.ts.json new file mode 100644 index 000000000..cf3f9181d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2789-array-missing-optional-tostring.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2789-array-missing-optional-tostring.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2790-array-missing-tagged-substitutions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2790-array-missing-tagged-substitutions.ts.json new file mode 100644 index 000000000..e6866cb43 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2790-array-missing-tagged-substitutions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2790-array-missing-tagged-substitutions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2790-dynamic-import-self-name/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2790-dynamic-import-self-name/main.ts.json new file mode 100644 index 000000000..80edf611a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2790-dynamic-import-self-name/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2790-dynamic-import-self-name/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2791-record-optional-keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2791-record-optional-keys.ts.json new file mode 100644 index 000000000..8c6dbe6c0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2791-record-optional-keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2791-record-optional-keys.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2792-record-optional-spread-entries.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2792-record-optional-spread-entries.ts.json new file mode 100644 index 000000000..dc2449d44 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2792-record-optional-spread-entries.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2792-record-optional-spread-entries.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2793-union-conversion-identity-capture.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2793-union-conversion-identity-capture.ts.json new file mode 100644 index 000000000..6b41ee76c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2793-union-conversion-identity-capture.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2793-union-conversion-identity-capture.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2794-array-generic-callback-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2794-array-generic-callback-values.ts.json new file mode 100644 index 000000000..ae8d8423a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2794-array-generic-callback-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2794-array-generic-callback-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2795-array-optional-typedarray-source.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2795-array-optional-typedarray-source.ts.json new file mode 100644 index 000000000..150e5264d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2795-array-optional-typedarray-source.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2795-array-optional-typedarray-source.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2796-array-sparse-class-value-instanceof.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2796-array-sparse-class-value-instanceof.ts.json new file mode 100644 index 000000000..f540d46dc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2796-array-sparse-class-value-instanceof.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2796-array-sparse-class-value-instanceof.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2800-array-expression-consumers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2800-array-expression-consumers.ts.json new file mode 100644 index 000000000..eb0d1245d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2800-array-expression-consumers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2800-array-expression-consumers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2801-array-switch-consumers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2801-array-switch-consumers.ts.json new file mode 100644 index 000000000..187ae3839 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2801-array-switch-consumers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2801-array-switch-consumers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2820-array-missing-method-receivers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2820-array-missing-method-receivers.ts.json new file mode 100644 index 000000000..063c8c419 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2820-array-missing-method-receivers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2820-array-missing-method-receivers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2821-array-optional-numeric-comparisons.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2821-array-optional-numeric-comparisons.ts.json new file mode 100644 index 000000000..ffa22fdad --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2821-array-optional-numeric-comparisons.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2821-array-optional-numeric-comparisons.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2830-cjs-require-self-name/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2830-cjs-require-self-name/main.cjs.json new file mode 100644 index 000000000..5a5a7ab18 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2830-cjs-require-self-name/main.cjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2830-cjs-require-self-name/lib.cjs", + "/tests/corpus/2830-cjs-require-self-name/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2840-finally-completions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2840-finally-completions.ts.json new file mode 100644 index 000000000..13a43933a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2840-finally-completions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2840-finally-completions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2841-using-sync.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2841-using-sync.ts.json new file mode 100644 index 000000000..1500777df --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2841-using-sync.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2841-using-sync.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2842-await-using.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2842-await-using.ts.json new file mode 100644 index 000000000..9b4f83f14 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2842-await-using.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2842-await-using.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2843-using-suppressed-error.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2843-using-suppressed-error.ts.json new file mode 100644 index 000000000..68aad09b4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2843-using-suppressed-error.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2843-using-suppressed-error.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2844-node-disposable-resources.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2844-node-disposable-resources.ts.json new file mode 100644 index 000000000..03abf8abc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2844-node-disposable-resources.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2844-node-disposable-resources.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2845-for-using-of.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2845-for-using-of.ts.json new file mode 100644 index 000000000..1cd4423fc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2845-for-using-of.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2845-for-using-of.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2846-generator-using.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2846-generator-using.ts.json new file mode 100644 index 000000000..af2c796bd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2846-generator-using.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2846-generator-using.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2850-async-generators-protocol.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2850-async-generators-protocol.ts.json new file mode 100644 index 000000000..96374ee65 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2850-async-generators-protocol.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2850-async-generators-protocol.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2851-async-generators-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2851-async-generators-values.ts.json new file mode 100644 index 000000000..cd05b5e23 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2851-async-generators-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2851-async-generators-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2852-timers-promises-interval.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2852-timers-promises-interval.ts.json new file mode 100644 index 000000000..20a313e08 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2852-timers-promises-interval.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2852-timers-promises-interval.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2854-leading-bom-literals.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2854-leading-bom-literals.ts.json new file mode 100644 index 000000000..d810a609c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2854-leading-bom-literals.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2854-leading-bom-literals.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2855-searchparams-sort-complexity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2855-searchparams-sort-complexity.ts.json new file mode 100644 index 000000000..68944cf9a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2855-searchparams-sort-complexity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2855-searchparams-sort-complexity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2856-dynamic-any-local-operators.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2856-dynamic-any-local-operators.ts.json new file mode 100644 index 000000000..4c007fefc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2856-dynamic-any-local-operators.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2856-dynamic-any-local-operators.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2857-branded-primitives.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2857-branded-primitives.ts.json new file mode 100644 index 000000000..e3b768828 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2857-branded-primitives.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2857-branded-primitives.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2858-import-meta-resolve/main.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2858-import-meta-resolve/main.mjs.json new file mode 100644 index 000000000..3fd278f58 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2858-import-meta-resolve/main.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2858-import-meta-resolve/main.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2859-import-meta-resolve-dynamic/main.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2859-import-meta-resolve-dynamic/main.mjs.json new file mode 100644 index 000000000..68076fe12 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2859-import-meta-resolve-dynamic/main.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2859-import-meta-resolve-dynamic/main.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2860-require-resolve/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2860-require-resolve/main.cjs.json new file mode 100644 index 000000000..20e39fb6d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2860-require-resolve/main.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2860-require-resolve/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2861-readable-iterator-close.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2861-readable-iterator-close.ts.json new file mode 100644 index 000000000..919f9563e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2861-readable-iterator-close.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2861-readable-iterator-close.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2862-web-readable-async-iteration.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2862-web-readable-async-iteration.ts.json new file mode 100644 index 000000000..66ed93544 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2862-web-readable-async-iteration.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2862-web-readable-async-iteration.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2863-class-async-iterator.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2863-class-async-iterator.ts.json new file mode 100644 index 000000000..95d8c86f8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2863-class-async-iterator.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2863-class-async-iterator.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2864-array-class-method-receivers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2864-array-class-method-receivers.ts.json new file mode 100644 index 000000000..49693b6f2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2864-array-class-method-receivers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2864-array-class-method-receivers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2865-cjs-process-alias.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2865-cjs-process-alias.cjs.json new file mode 100644 index 000000000..d59b0a960 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2865-cjs-process-alias.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2865-cjs-process-alias.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2866-dyn-switch.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2866-dyn-switch.ts.json new file mode 100644 index 000000000..4b88cd53f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2866-dyn-switch.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2866-dyn-switch.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2867-array-shift-length.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2867-array-shift-length.js.json new file mode 100644 index 000000000..f7479d93e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2867-array-shift-length.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2867-array-shift-length.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2868-empty-record-promise-presence.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2868-empty-record-promise-presence.js.json new file mode 100644 index 000000000..6f77c03c1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2868-empty-record-promise-presence.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2868-empty-record-promise-presence.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2869-nullish-mixed-lazy.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2869-nullish-mixed-lazy.ts.json new file mode 100644 index 000000000..28db8b0d8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2869-nullish-mixed-lazy.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2869-nullish-mixed-lazy.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2870-and-dropped-truthy-arm.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2870-and-dropped-truthy-arm.ts.json new file mode 100644 index 000000000..4a7c0fbd0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2870-and-dropped-truthy-arm.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2870-and-dropped-truthy-arm.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2871-optional-promise-to-unknown.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2871-optional-promise-to-unknown.ts.json new file mode 100644 index 000000000..46281c6bc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2871-optional-promise-to-unknown.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2871-optional-promise-to-unknown.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2872-unobserved-dynamic-event.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2872-unobserved-dynamic-event.ts.json new file mode 100644 index 000000000..5f9987002 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2872-unobserved-dynamic-event.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2872-unobserved-dynamic-event.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2873-optional-receiver-loop-lifetime.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2873-optional-receiver-loop-lifetime.js.json new file mode 100644 index 000000000..da647b0e3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2873-optional-receiver-loop-lifetime.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2873-optional-receiver-loop-lifetime.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2874-nullable-callback-field-cycle.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2874-nullable-callback-field-cycle.js.json new file mode 100644 index 000000000..b1542fe43 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2874-nullable-callback-field-cycle.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2874-nullable-callback-field-cycle.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2875-evolving-let-read-before-write.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2875-evolving-let-read-before-write.js.json new file mode 100644 index 000000000..ca6917921 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2875-evolving-let-read-before-write.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2875-evolving-let-read-before-write.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2876-class-unknown-roundtrip.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2876-class-unknown-roundtrip.ts.json new file mode 100644 index 000000000..7b19aa538 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2876-class-unknown-roundtrip.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2876-class-unknown-roundtrip.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2877-child-unknown-roundtrip.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2877-child-unknown-roundtrip.ts.json new file mode 100644 index 000000000..7afcc18bd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2877-child-unknown-roundtrip.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2877-child-unknown-roundtrip.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2878-class-private-unknown.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2878-class-private-unknown.cjs.json new file mode 100644 index 000000000..16c035257 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2878-class-private-unknown.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2878-class-private-unknown.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2880-cjs-module-graph/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2880-cjs-module-graph/main.cjs.json new file mode 100644 index 000000000..c120d1b78 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2880-cjs-module-graph/main.cjs.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/2880-cjs-module-graph/leaf.cjs", + "/tests/corpus/2880-cjs-module-graph/child.cjs", + "/tests/corpus/2880-cjs-module-graph/failed.cjs", + "/tests/corpus/2880-cjs-module-graph/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2890-crypto-static-utility.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2890-crypto-static-utility.ts.json new file mode 100644 index 000000000..f11424a1b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2890-crypto-static-utility.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2890-crypto-static-utility.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2891-json-record-key-escapes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2891-json-record-key-escapes.ts.json new file mode 100644 index 000000000..5785ab0a8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2891-json-record-key-escapes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2891-json-record-key-escapes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2892-windows-console-unicode.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2892-windows-console-unicode.ts.json new file mode 100644 index 000000000..eb5109681 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2892-windows-console-unicode.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2892-windows-console-unicode.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2893-child-stdin-duplex.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2893-child-stdin-duplex.ts.json new file mode 100644 index 000000000..596251bdd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2893-child-stdin-duplex.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2893-child-stdin-duplex.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2894-child-stdin-backpressure.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2894-child-stdin-backpressure.ts.json new file mode 100644 index 000000000..f267a1bc3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2894-child-stdin-backpressure.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2894-child-stdin-backpressure.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2895-child-stdin-write-after-end.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2895-child-stdin-write-after-end.ts.json new file mode 100644 index 000000000..9f75afb0b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2895-child-stdin-write-after-end.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2895-child-stdin-write-after-end.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2896-child-stdin-write-after-finish.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2896-child-stdin-write-after-finish.ts.json new file mode 100644 index 000000000..98cf14161 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2896-child-stdin-write-after-finish.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2896-child-stdin-write-after-finish.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2897-child-stdin-destroy.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2897-child-stdin-destroy.ts.json new file mode 100644 index 000000000..ebe15962a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2897-child-stdin-destroy.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2897-child-stdin-destroy.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2898-child-stdin-spawn-failure.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2898-child-stdin-spawn-failure.ts.json new file mode 100644 index 000000000..ffada756f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2898-child-stdin-spawn-failure.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2898-child-stdin-spawn-failure.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2899-nested-mutual-recursion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2899-nested-mutual-recursion.ts.json new file mode 100644 index 000000000..74694c8bc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2899-nested-mutual-recursion.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2899-nested-mutual-recursion.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2900-float64array-static.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2900-float64array-static.ts.json new file mode 100644 index 000000000..94dfbdea4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2900-float64array-static.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2900-float64array-static.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2900-void-conditional-arrow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2900-void-conditional-arrow.ts.json new file mode 100644 index 000000000..581379cc2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2900-void-conditional-arrow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2900-void-conditional-arrow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2901-bigint-core.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2901-bigint-core.ts.json new file mode 100644 index 000000000..c676a5a9a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2901-bigint-core.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2901-bigint-core.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2902-bigint-bytes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2902-bigint-bytes.ts.json new file mode 100644 index 000000000..920423978 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2902-bigint-bytes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2902-bigint-bytes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2903-bigint-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2903-bigint-storage.ts.json new file mode 100644 index 000000000..c0f383cce --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2903-bigint-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2903-bigint-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2904-bigint-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2904-bigint-errors.ts.json new file mode 100644 index 000000000..9ac2f9398 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2904-bigint-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2904-bigint-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2905-bigint-edges.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2905-bigint-edges.ts.json new file mode 100644 index 000000000..c9ebd3323 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2905-bigint-edges.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2905-bigint-edges.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2906-bigint-wasi-width.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2906-bigint-wasi-width.ts.json new file mode 100644 index 000000000..cf1bb050d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2906-bigint-wasi-width.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2906-bigint-wasi-width.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2910-overloaded-callable-alias.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2910-overloaded-callable-alias.ts.json new file mode 100644 index 000000000..bfafd7673 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2910-overloaded-callable-alias.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2910-overloaded-callable-alias.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2911-execfile-callback.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2911-execfile-callback.ts.json new file mode 100644 index 000000000..e0208d0e1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2911-execfile-callback.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2911-execfile-callback.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2912-execfile-callback-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2912-execfile-callback-options.ts.json new file mode 100644 index 000000000..337a38f39 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2912-execfile-callback-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2912-execfile-callback-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2912-promisify-fs-readfile.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2912-promisify-fs-readfile.ts.json new file mode 100644 index 000000000..4b8cf57eb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2912-promisify-fs-readfile.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2912-promisify-fs-readfile.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2913-builtin-callable-alias.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2913-builtin-callable-alias.ts.json new file mode 100644 index 000000000..91315dfc8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2913-builtin-callable-alias.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2913-builtin-callable-alias.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2914-fixed-tuple-call-spread.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2914-fixed-tuple-call-spread.ts.json new file mode 100644 index 000000000..9108c2883 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2914-fixed-tuple-call-spread.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2914-fixed-tuple-call-spread.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2915-path-function-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2915-path-function-values.ts.json new file mode 100644 index 000000000..201c8e831 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2915-path-function-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2915-path-function-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2916-path-function-values-cjs.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2916-path-function-values-cjs.ts.json new file mode 100644 index 000000000..e20b1b74e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2916-path-function-values-cjs.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2916-path-function-values-cjs.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2917-builtin-callable-widths.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2917-builtin-callable-widths.ts.json new file mode 100644 index 000000000..3ad3a4f43 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2917-builtin-callable-widths.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2917-builtin-callable-widths.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2918-builtin-callable-widths-cjs.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2918-builtin-callable-widths-cjs.ts.json new file mode 100644 index 000000000..8506c7518 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2918-builtin-callable-widths-cjs.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2918-builtin-callable-widths-cjs.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2919-fs-function-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2919-fs-function-values.ts.json new file mode 100644 index 000000000..60413a514 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2919-fs-function-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2919-fs-function-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2920-fs-promises-function-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2920-fs-promises-function-values.ts.json new file mode 100644 index 000000000..d665757e8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2920-fs-promises-function-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2920-fs-promises-function-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2921-zlib-callbacks.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2921-zlib-callbacks.ts.json new file mode 100644 index 000000000..d5f9e3698 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2921-zlib-callbacks.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2921-zlib-callbacks.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2922-dyn-bitwise-not.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2922-dyn-bitwise-not.cjs.json new file mode 100644 index 000000000..25f03d9d1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2922-dyn-bitwise-not.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2922-dyn-bitwise-not.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2923-cjs-factory-export/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2923-cjs-factory-export/main.cjs.json new file mode 100644 index 000000000..3c2f05caf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2923-cjs-factory-export/main.cjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2923-cjs-factory-export/factory.cjs", + "/tests/corpus/2923-cjs-factory-export/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2930-union-receiver-calls.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2930-union-receiver-calls.ts.json new file mode 100644 index 000000000..d56346e9c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2930-union-receiver-calls.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2930-union-receiver-calls.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2931-union-dynamic-field-call.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2931-union-dynamic-field-call.js.json new file mode 100644 index 000000000..c30781d1b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2931-union-dynamic-field-call.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2931-union-dynamic-field-call.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2932-create-require-program/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2932-create-require-program/main.ts.json new file mode 100644 index 000000000..a637ff94e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2932-create-require-program/main.ts.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/2932-create-require-program/local.cjs", + "/tests/corpus/2932-create-require-program/factory.cjs", + "/tests/corpus/2932-create-require-program/side.cjs", + "/tests/corpus/2932-create-require-program/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2933-static-dynamic-import/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2933-static-dynamic-import/main.ts.json new file mode 100644 index 000000000..cba5c7a51 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2933-static-dynamic-import/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2933-static-dynamic-import/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2934-static-import-stored.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2934-static-import-stored.ts.json new file mode 100644 index 000000000..b34a89b8f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2934-static-import-stored.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2934-static-import-stored.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2935-module-namespace-values/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2935-module-namespace-values/main.ts.json new file mode 100644 index 000000000..a058c62c0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2935-module-namespace-values/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2935-module-namespace-values/mod.ts", + "/tests/corpus/2935-module-namespace-values/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2936-static-loose-equality.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2936-static-loose-equality.ts.json new file mode 100644 index 000000000..c00fda1bc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2936-static-loose-equality.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2936-static-loose-equality.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2937-bitwise-hot-loop.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2937-bitwise-hot-loop.ts.json new file mode 100644 index 000000000..13332b011 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2937-bitwise-hot-loop.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2937-bitwise-hot-loop.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2938-fs-sync-overloads.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2938-fs-sync-overloads.cjs.json new file mode 100644 index 000000000..e3c05c0f5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2938-fs-sync-overloads.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2938-fs-sync-overloads.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2939-child-shell-text.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2939-child-shell-text.ts.json new file mode 100644 index 000000000..70546dac4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2939-child-shell-text.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2939-child-shell-text.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2940-date-parse.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2940-date-parse.ts.json new file mode 100644 index 000000000..2599d8cef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2940-date-parse.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2940-date-parse.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2940-fsp-realpath.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2940-fsp-realpath.ts.json new file mode 100644 index 000000000..878617434 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2940-fsp-realpath.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2940-fsp-realpath.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2941-fsp-lstat-identity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2941-fsp-lstat-identity.ts.json new file mode 100644 index 000000000..a6a59b775 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2941-fsp-lstat-identity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2941-fsp-lstat-identity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2941-process-exit-code.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2941-process-exit-code.ts.json new file mode 100644 index 000000000..c310a2df0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2941-process-exit-code.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2941-process-exit-code.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2942-fsp-readdir-dirent.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2942-fsp-readdir-dirent.ts.json new file mode 100644 index 000000000..0927dab1f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2942-fsp-readdir-dirent.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2942-fsp-readdir-dirent.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2942-process-exit-code-override.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2942-process-exit-code-override.ts.json new file mode 100644 index 000000000..5b3bc6b6a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2942-process-exit-code-override.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2942-process-exit-code-override.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2943-process-exit-code-invalid.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2943-process-exit-code-invalid.ts.json new file mode 100644 index 000000000..3cb7f19e0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2943-process-exit-code-invalid.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2943-process-exit-code-invalid.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2944-process-exit-code-wrap.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2944-process-exit-code-wrap.ts.json new file mode 100644 index 000000000..ceeb330cb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2944-process-exit-code-wrap.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2944-process-exit-code-wrap.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2945-url-origin-username.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2945-url-origin-username.ts.json new file mode 100644 index 000000000..00494e2a0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2945-url-origin-username.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2945-url-origin-username.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2946-child-fork-ipc/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2946-child-fork-ipc/main.ts.json new file mode 100644 index 000000000..fede7a9ca --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2946-child-fork-ipc/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2946-child-fork-ipc/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2946-url-port-hash.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2946-url-port-hash.ts.json new file mode 100644 index 000000000..507328655 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2946-url-port-hash.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2946-url-port-hash.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2947-set-readonly-seeds.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2947-set-readonly-seeds.ts.json new file mode 100644 index 000000000..615152f6c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2947-set-readonly-seeds.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2947-set-readonly-seeds.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2948-child-fork-eof-callback/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2948-child-fork-eof-callback/main.ts.json new file mode 100644 index 000000000..b2622692e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2948-child-fork-eof-callback/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2948-child-fork-eof-callback/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2948-stdio-callback-record.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2948-stdio-callback-record.ts.json new file mode 100644 index 000000000..3f06f8862 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2948-stdio-callback-record.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2948-stdio-callback-record.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2949-child-fork-default/main.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2949-child-fork-default/main.mjs.json new file mode 100644 index 000000000..10ba2648c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2949-child-fork-default/main.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2949-child-fork-default/main.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2949-url-password.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2949-url-password.ts.json new file mode 100644 index 000000000..7fd80ce5f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2949-url-password.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2949-url-password.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2950-fs-descriptor-publication.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2950-fs-descriptor-publication.ts.json new file mode 100644 index 000000000..780a4469f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2950-fs-descriptor-publication.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2950-fs-descriptor-publication.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2951-math-static-analytic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2951-math-static-analytic.ts.json new file mode 100644 index 000000000..7fa4dbc3f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2951-math-static-analytic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2951-math-static-analytic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2952-math-static-remaining.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2952-math-static-remaining.ts.json new file mode 100644 index 000000000..947151b79 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2952-math-static-remaining.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2952-math-static-remaining.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2953-http-header-validation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2953-http-header-validation.ts.json new file mode 100644 index 000000000..65e874915 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2953-http-header-validation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2953-http-header-validation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2954-http-outgoing-headers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2954-http-outgoing-headers.ts.json new file mode 100644 index 000000000..fecc5108e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2954-http-outgoing-headers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2954-http-outgoing-headers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2955-http-static-state.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2955-http-static-state.ts.json new file mode 100644 index 000000000..c7a3b2984 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2955-http-static-state.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2955-http-static-state.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2956-http-static-informational.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2956-http-static-informational.ts.json new file mode 100644 index 000000000..f205db0ef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2956-http-static-informational.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2956-http-static-informational.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2957-http-static-response-controls.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2957-http-static-response-controls.ts.json new file mode 100644 index 000000000..fb80afe8c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2957-http-static-response-controls.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2957-http-static-response-controls.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2961-emitter-computed-names.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2961-emitter-computed-names.cjs.json new file mode 100644 index 000000000..31ea8dcce --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2961-emitter-computed-names.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2961-emitter-computed-names.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2962-emitter-computed-optional.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2962-emitter-computed-optional.ts.json new file mode 100644 index 000000000..a1891f6b5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2962-emitter-computed-optional.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2962-emitter-computed-optional.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2963-child-fork-dispatch/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2963-child-fork-dispatch/main.ts.json new file mode 100644 index 000000000..2d3f9614a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2963-child-fork-dispatch/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2963-child-fork-dispatch/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2964-indexed-compound.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2964-indexed-compound.ts.json new file mode 100644 index 000000000..8a6c1d4f8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2964-indexed-compound.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2964-indexed-compound.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2966-numeric-array-read-fusion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2966-numeric-array-read-fusion.ts.json new file mode 100644 index 000000000..1d593ba13 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2966-numeric-array-read-fusion.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2966-numeric-array-read-fusion.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2967-numeric-array-read-lifetime.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2967-numeric-array-read-lifetime.ts.json new file mode 100644 index 000000000..e5d36ec9e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2967-numeric-array-read-lifetime.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2967-numeric-array-read-lifetime.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2968-numeric-array-borrow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2968-numeric-array-borrow.ts.json new file mode 100644 index 000000000..1a7f001e2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2968-numeric-array-borrow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2968-numeric-array-borrow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2969-scalar-record-results.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2969-scalar-record-results.ts.json new file mode 100644 index 000000000..9a55bf954 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2969-scalar-record-results.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2969-scalar-record-results.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2970-constant-numeric-tables.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2970-constant-numeric-tables.ts.json new file mode 100644 index 000000000..12efaf30e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2970-constant-numeric-tables.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2970-constant-numeric-tables.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2971-constant-table-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2971-constant-table-modules/main.ts.json new file mode 100644 index 000000000..28c1fc3b2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2971-constant-table-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/2971-constant-table-modules/tables.ts", + "/tests/corpus/2971-constant-table-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2972-http-static-distinct-snapshots.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2972-http-static-distinct-snapshots.ts.json new file mode 100644 index 000000000..a58bc5d31 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2972-http-static-distinct-snapshots.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2972-http-static-distinct-snapshots.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2972-math-receiver-borrow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2972-math-receiver-borrow.ts.json new file mode 100644 index 000000000..9282fecdc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2972-math-receiver-borrow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2972-math-receiver-borrow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2973-http-static-agent.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2973-http-static-agent.ts.json new file mode 100644 index 000000000..a2128ed05 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2973-http-static-agent.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2973-http-static-agent.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2973-integer-bitwise-arithmetic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2973-integer-bitwise-arithmetic.ts.json new file mode 100644 index 000000000..5f59cc2a0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2973-integer-bitwise-arithmetic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2973-integer-bitwise-arithmetic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2974-array-search-from-index.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2974-array-search-from-index.ts.json new file mode 100644 index 000000000..2b13b2b9e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2974-array-search-from-index.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2974-array-search-from-index.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2974-http-static-module-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2974-http-static-module-values.ts.json new file mode 100644 index 000000000..5964b828b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2974-http-static-module-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2974-http-static-module-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2974-numeric-remainder.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2974-numeric-remainder.ts.json new file mode 100644 index 000000000..8c89ccdf8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2974-numeric-remainder.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2974-numeric-remainder.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2975-bigint-default-radix.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2975-bigint-default-radix.ts.json new file mode 100644 index 000000000..3a0abd9b9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2975-bigint-default-radix.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2975-bigint-default-radix.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2975-http-static-client-controls.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2975-http-static-client-controls.ts.json new file mode 100644 index 000000000..297a887da --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2975-http-static-client-controls.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2975-http-static-client-controls.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2976-http-static-incoming-state.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2976-http-static-incoming-state.ts.json new file mode 100644 index 000000000..6eb1604d5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2976-http-static-incoming-state.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2976-http-static-incoming-state.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2976-json-stringify-no-arguments.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2976-json-stringify-no-arguments.js.json new file mode 100644 index 000000000..7ba1abc55 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2976-json-stringify-no-arguments.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2976-json-stringify-no-arguments.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2977-http-static-incoming-timeout.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2977-http-static-incoming-timeout.ts.json new file mode 100644 index 000000000..c274f9339 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2977-http-static-incoming-timeout.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2977-http-static-incoming-timeout.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2977-nested-array-binding-defaults.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2977-nested-array-binding-defaults.js.json new file mode 100644 index 000000000..c40e8243f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2977-nested-array-binding-defaults.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2977-nested-array-binding-defaults.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2978-http-static-client-timeout.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2978-http-static-client-timeout.ts.json new file mode 100644 index 000000000..3e523b0eb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2978-http-static-client-timeout.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2978-http-static-client-timeout.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2978-regexp-optional-subject.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2978-regexp-optional-subject.js.json new file mode 100644 index 000000000..1ef87cef8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2978-regexp-optional-subject.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2978-regexp-optional-subject.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2979-array-search-mixed-needles.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2979-array-search-mixed-needles.js.json new file mode 100644 index 000000000..2687ddfb8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2979-array-search-mixed-needles.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2979-array-search-mixed-needles.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2979-http-static-server-timeout.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2979-http-static-server-timeout.ts.json new file mode 100644 index 000000000..199b3d053 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2979-http-static-server-timeout.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2979-http-static-server-timeout.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2980-http-static-server-timeout-default.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2980-http-static-server-timeout-default.ts.json new file mode 100644 index 000000000..b9c868e0b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2980-http-static-server-timeout-default.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2980-http-static-server-timeout-default.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2980-string-position-arguments.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2980-string-position-arguments.js.json new file mode 100644 index 000000000..18d18be31 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2980-string-position-arguments.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2980-string-position-arguments.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2981-http-static-events.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2981-http-static-events.ts.json new file mode 100644 index 000000000..68d39ff0e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2981-http-static-events.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2981-http-static-events.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2981-string-optional-positions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2981-string-optional-positions.ts.json new file mode 100644 index 000000000..4f3efa7c2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2981-string-optional-positions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2981-string-optional-positions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2982-http-static-close-all.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2982-http-static-close-all.ts.json new file mode 100644 index 000000000..060c29b18 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2982-http-static-close-all.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2982-http-static-close-all.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2982-string-position-coercion-order.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2982-string-position-coercion-order.js.json new file mode 100644 index 000000000..d4865ab04 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2982-string-position-coercion-order.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2982-string-position-coercion-order.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2983-http-static-close-idle.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2983-http-static-close-idle.ts.json new file mode 100644 index 000000000..a8bc1174e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2983-http-static-close-idle.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2983-http-static-close-idle.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2984-http-static-close-upgrade.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2984-http-static-close-upgrade.ts.json new file mode 100644 index 000000000..5d52738d9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2984-http-static-close-upgrade.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2984-http-static-close-upgrade.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2985-http-static-message-destroy.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2985-http-static-message-destroy.ts.json new file mode 100644 index 000000000..3a0cc2d7c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2985-http-static-message-destroy.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2985-http-static-message-destroy.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2986-http-static-client-socket-finish.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2986-http-static-client-socket-finish.ts.json new file mode 100644 index 000000000..09fbe80a2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2986-http-static-client-socket-finish.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2986-http-static-client-socket-finish.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2987-http-static-timeout-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2987-http-static-timeout-errors.ts.json new file mode 100644 index 000000000..bd0a9361c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2987-http-static-timeout-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2987-http-static-timeout-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2988-http-static-client-abort.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2988-http-static-client-abort.ts.json new file mode 100644 index 000000000..43512a28d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2988-http-static-client-abort.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2988-http-static-client-abort.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2989-http-static-response-timeout-handled.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2989-http-static-response-timeout-handled.ts.json new file mode 100644 index 000000000..1d12a8b96 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2989-http-static-response-timeout-handled.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2989-http-static-response-timeout-handled.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2990-http-static-request-timeout-handled.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2990-http-static-request-timeout-handled.ts.json new file mode 100644 index 000000000..93d361187 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2990-http-static-request-timeout-handled.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2990-http-static-request-timeout-handled.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2991-array-indexed-equality.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2991-array-indexed-equality.ts.json new file mode 100644 index 000000000..98013878a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2991-array-indexed-equality.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2991-array-indexed-equality.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2992-stream-rows.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2992-stream-rows.ts.json new file mode 100644 index 000000000..00eb284dc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2992-stream-rows.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2992-stream-rows.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2993-fiber-stack-lifetimes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2993-fiber-stack-lifetimes.ts.json new file mode 100644 index 000000000..59811d48c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2993-fiber-stack-lifetimes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2993-fiber-stack-lifetimes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2994-fromcharcode-scalar.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2994-fromcharcode-scalar.ts.json new file mode 100644 index 000000000..3416244ef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2994-fromcharcode-scalar.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2994-fromcharcode-scalar.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2995-math-hyperbolic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2995-math-hyperbolic.ts.json new file mode 100644 index 000000000..0edffb6dd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2995-math-hyperbolic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2995-math-hyperbolic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2996-math-near-one.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2996-math-near-one.ts.json new file mode 100644 index 000000000..c99342d18 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2996-math-near-one.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2996-math-near-one.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2997-math-integer-float.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2997-math-integer-float.ts.json new file mode 100644 index 000000000..c2138168b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/2997-math-integer-float.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/2997-math-integer-float.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/300-if-else.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/300-if-else.ts.json new file mode 100644 index 000000000..ac6495afe --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/300-if-else.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/300-if-else.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3001-caught-typeof-object.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3001-caught-typeof-object.js.json new file mode 100644 index 000000000..97c78a78e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3001-caught-typeof-object.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3001-caught-typeof-object.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3002-promise-then-two.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3002-promise-then-two.ts.json new file mode 100644 index 000000000..3bf120c31 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3002-promise-then-two.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3002-promise-then-two.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/301-while.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/301-while.ts.json new file mode 100644 index 000000000..c2f4da110 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/301-while.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/301-while.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/302-for.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/302-for.ts.json new file mode 100644 index 000000000..2e1884184 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/302-for.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/302-for.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3020-string-last-index-position.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3020-string-last-index-position.ts.json new file mode 100644 index 000000000..81e044d78 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3020-string-last-index-position.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3020-string-last-index-position.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3021-buffer-union-narrow-callback.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3021-buffer-union-narrow-callback.ts.json new file mode 100644 index 000000000..494adff57 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3021-buffer-union-narrow-callback.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3021-buffer-union-narrow-callback.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3022-string-affix-positions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3022-string-affix-positions.ts.json new file mode 100644 index 000000000..5adcce0fc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3022-string-affix-positions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3022-string-affix-positions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3023-string-affix-position-coercion.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3023-string-affix-position-coercion.js.json new file mode 100644 index 000000000..33764475b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3023-string-affix-position-coercion.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3023-string-affix-position-coercion.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3024-string-number-narrow-for-in.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3024-string-number-narrow-for-in.ts.json new file mode 100644 index 000000000..fc6dfa558 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3024-string-number-narrow-for-in.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3024-string-number-narrow-for-in.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3025-string-search-position-coercion.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3025-string-search-position-coercion.js.json new file mode 100644 index 000000000..8dd4a0547 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3025-string-search-position-coercion.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3025-string-search-position-coercion.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3026-array-last-index-of.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3026-array-last-index-of.js.json new file mode 100644 index 000000000..b0ce6b691 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3026-array-last-index-of.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3026-array-last-index-of.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3027-array-last-index-of-records.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3027-array-last-index-of-records.ts.json new file mode 100644 index 000000000..6d604d78c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3027-array-last-index-of-records.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3027-array-last-index-of-records.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3028-string-search-dynamic-needle.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3028-string-search-dynamic-needle.js.json new file mode 100644 index 000000000..23d1ef2ef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3028-string-search-dynamic-needle.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3028-string-search-dynamic-needle.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3029-string-search-union-needle.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3029-string-search-union-needle.js.json new file mode 100644 index 000000000..8e8636cc4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3029-string-search-union-needle.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3029-string-search-union-needle.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/303-break-continue.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/303-break-continue.ts.json new file mode 100644 index 000000000..14e8148f8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/303-break-continue.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/303-break-continue.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3030-array-search-no-arg.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3030-array-search-no-arg.js.json new file mode 100644 index 000000000..6473e2d86 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3030-array-search-no-arg.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3030-array-search-no-arg.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3031-array-relative-index-coercion.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3031-array-relative-index-coercion.js.json new file mode 100644 index 000000000..12521080b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3031-array-relative-index-coercion.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3031-array-relative-index-coercion.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3031-string-last-index-search-value.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3031-string-last-index-search-value.js.json new file mode 100644 index 000000000..ecb08d18b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3031-string-last-index-search-value.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3031-string-last-index-search-value.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3032-string-search-value.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3032-string-search-value.js.json new file mode 100644 index 000000000..181ea0ff4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3032-string-search-value.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3032-string-search-value.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3033-string-search-needle-coercion.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3033-string-search-needle-coercion.js.json new file mode 100644 index 000000000..4974f7384 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3033-string-search-needle-coercion.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3033-string-search-needle-coercion.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3034-arguments-with-parameters.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3034-arguments-with-parameters.js.json new file mode 100644 index 000000000..65751e750 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3034-arguments-with-parameters.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3034-arguments-with-parameters.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3035-string-positioned-search-value.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3035-string-positioned-search-value.js.json new file mode 100644 index 000000000..e8bf5f147 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3035-string-positioned-search-value.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3035-string-positioned-search-value.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3036-string-object-search-value.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3036-string-object-search-value.js.json new file mode 100644 index 000000000..413b399ad --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3036-string-object-search-value.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3036-string-object-search-value.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3037-number-nullish-conversion.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3037-number-nullish-conversion.js.json new file mode 100644 index 000000000..3e4250562 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3037-number-nullish-conversion.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3037-number-nullish-conversion.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3038-number-scalar-unions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3038-number-scalar-unions.ts.json new file mode 100644 index 000000000..79afc7301 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3038-number-scalar-unions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3038-number-scalar-unions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3039-string-repeat-count.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3039-string-repeat-count.js.json new file mode 100644 index 000000000..9e1fce64d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3039-string-repeat-count.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3039-string-repeat-count.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/304-compound-incdec.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/304-compound-incdec.ts.json new file mode 100644 index 000000000..d6f7d3bf9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/304-compound-incdec.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/304-compound-incdec.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3040-string-prototype-call.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3040-string-prototype-call.js.json new file mode 100644 index 000000000..636b0bcd2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3040-string-prototype-call.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3040-string-prototype-call.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3041-string-prototype-object-call.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3041-string-prototype-object-call.js.json new file mode 100644 index 000000000..eec0527f5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3041-string-prototype-object-call.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3041-string-prototype-object-call.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3042-string-padding-coercion.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3042-string-padding-coercion.js.json new file mode 100644 index 000000000..26020cb4c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3042-string-padding-coercion.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3042-string-padding-coercion.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3043-string-split-arguments.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3043-string-split-arguments.js.json new file mode 100644 index 000000000..4f2685985 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3043-string-split-arguments.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3043-string-split-arguments.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3044-array-slice-splice-positions.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3044-array-slice-splice-positions.js.json new file mode 100644 index 000000000..5e16ca466 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3044-array-slice-splice-positions.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3044-array-slice-splice-positions.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3045-array-indexed-mutation.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3045-array-indexed-mutation.js.json new file mode 100644 index 000000000..a4bb52daf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3045-array-indexed-mutation.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3045-array-indexed-mutation.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3046-array-indexed-ref-identity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3046-array-indexed-ref-identity.ts.json new file mode 100644 index 000000000..5523b83bd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3046-array-indexed-ref-identity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3046-array-indexed-ref-identity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3047-object-prototype-tag.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3047-object-prototype-tag.js.json new file mode 100644 index 000000000..c60eac1b2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3047-object-prototype-tag.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3047-object-prototype-tag.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3048-object-own-prototype.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3048-object-own-prototype.ts.json new file mode 100644 index 000000000..8a611761a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3048-object-own-prototype.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3048-object-own-prototype.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3049-array-flat-depth.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3049-array-flat-depth.ts.json new file mode 100644 index 000000000..34ff317a4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3049-array-flat-depth.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3049-array-flat-depth.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/305-truthiness.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/305-truthiness.ts.json new file mode 100644 index 000000000..92adb7e70 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/305-truthiness.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/305-truthiness.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3050-array-splice-insert.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3050-array-splice-insert.ts.json new file mode 100644 index 000000000..85e9c89a1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3050-array-splice-insert.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3050-array-splice-insert.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3051-array-join-default.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3051-array-join-default.ts.json new file mode 100644 index 000000000..6a1e2de03 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3051-array-join-default.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3051-array-join-default.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3052-array-construction.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3052-array-construction.ts.json new file mode 100644 index 000000000..f3d8a57c9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3052-array-construction.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3052-array-construction.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3053-array-construction-js.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3053-array-construction-js.js.json new file mode 100644 index 000000000..cbd3aa80b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3053-array-construction-js.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3053-array-construction-js.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3054-dynamic-abort-record.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3054-dynamic-abort-record.ts.json new file mode 100644 index 000000000..942e7112e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3054-dynamic-abort-record.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3054-dynamic-abort-record.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3055-default-builtin-nodenext/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3055-default-builtin-nodenext/main.ts.json new file mode 100644 index 000000000..136611f2d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3055-default-builtin-nodenext/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3055-default-builtin-nodenext/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3056-default-builtin-bundler/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3056-default-builtin-bundler/main.ts.json new file mode 100644 index 000000000..3100b0fe6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3056-default-builtin-bundler/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3056-default-builtin-bundler/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3057-default-builtin-nodenext-dynamic/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3057-default-builtin-nodenext-dynamic/main.ts.json new file mode 100644 index 000000000..f97bc686c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3057-default-builtin-nodenext-dynamic/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3057-default-builtin-nodenext-dynamic/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3058-optional-array-chain-join.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3058-optional-array-chain-join.ts.json new file mode 100644 index 000000000..497eb91b8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3058-optional-array-chain-join.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3058-optional-array-chain-join.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3059-arguments-property-names.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3059-arguments-property-names.ts.json new file mode 100644 index 000000000..8b0453463 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3059-arguments-property-names.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3059-arguments-property-names.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3060-dynamic-host-global.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3060-dynamic-host-global.ts.json new file mode 100644 index 000000000..78388c746 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3060-dynamic-host-global.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3060-dynamic-host-global.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3061-concurrent-fiber-stacks.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3061-concurrent-fiber-stacks.ts.json new file mode 100644 index 000000000..25eddf269 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3061-concurrent-fiber-stacks.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3061-concurrent-fiber-stacks.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3062-runtime-optional-record-guards.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3062-runtime-optional-record-guards.ts.json new file mode 100644 index 000000000..dfdfcd681 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3062-runtime-optional-record-guards.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3062-runtime-optional-record-guards.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3063-runtime-optional-class-guards.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3063-runtime-optional-class-guards.ts.json new file mode 100644 index 000000000..83323e146 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3063-runtime-optional-class-guards.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3063-runtime-optional-class-guards.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3064-installed-entry-imports/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3064-installed-entry-imports/main.ts.json new file mode 100644 index 000000000..abd5fb060 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3064-installed-entry-imports/main.ts.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/3064-installed-entry-imports/state.ts", + "/tests/corpus/3064-installed-entry-imports/core/run.ts", + "/tests/corpus/3064-installed-entry-imports/core/index.ts", + "/tests/corpus/3064-installed-entry-imports/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3065-installed-entry-js/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3065-installed-entry-js/main.js.json new file mode 100644 index 000000000..f69073660 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3065-installed-entry-js/main.js.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/3065-installed-entry-js/value.js", + "/tests/corpus/3065-installed-entry-js/lib/index.js", + "/tests/corpus/3065-installed-entry-js/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3066-source-debugging/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3066-source-debugging/main.ts.json new file mode 100644 index 000000000..d6281b1b6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3066-source-debugging/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/3066-source-debugging/helper.ts", + "/tests/corpus/3066-source-debugging/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3067-cjs-function-export-require/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3067-cjs-function-export-require/main.cjs.json new file mode 100644 index 000000000..ba624e589 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3067-cjs-function-export-require/main.cjs.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/3067-cjs-function-export-require/dependency.cjs", + "/tests/corpus/3067-cjs-function-export-require/member.cjs", + "/tests/corpus/3067-cjs-function-export-require/single.cjs", + "/tests/corpus/3067-cjs-function-export-require/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3068-debug-variables/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3068-debug-variables/main.ts.json new file mode 100644 index 000000000..5d9fd6b37 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3068-debug-variables/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/3068-debug-variables/other.ts", + "/tests/corpus/3068-debug-variables/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3068-url-checked-identity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3068-url-checked-identity.ts.json new file mode 100644 index 000000000..aa4beb1ca --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3068-url-checked-identity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3068-url-checked-identity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3069-set-checked-seed.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3069-set-checked-seed.js.json new file mode 100644 index 000000000..e75fe8380 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3069-set-checked-seed.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3069-set-checked-seed.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3069-tuple-spread.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3069-tuple-spread.ts.json new file mode 100644 index 000000000..aa1ae9733 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3069-tuple-spread.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3069-tuple-spread.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3070-checked-object-accessors.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3070-checked-object-accessors.js.json new file mode 100644 index 000000000..610f46a56 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3070-checked-object-accessors.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3070-checked-object-accessors.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3070-collection-views.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3070-collection-views.ts.json new file mode 100644 index 000000000..ebe7822c6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3070-collection-views.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3070-collection-views.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3071-checked-specialization-narrowing.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3071-checked-specialization-narrowing.js.json new file mode 100644 index 000000000..7d2b33ae8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3071-checked-specialization-narrowing.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3071-checked-specialization-narrowing.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3071-map-contextual-record-seeds.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3071-map-contextual-record-seeds.ts.json new file mode 100644 index 000000000..33a7e38b0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3071-map-contextual-record-seeds.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3071-map-contextual-record-seeds.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3072-optional-union-receivers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3072-optional-union-receivers.ts.json new file mode 100644 index 000000000..47bf9e0d4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3072-optional-union-receivers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3072-optional-union-receivers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3072-weak-process-streams.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3072-weak-process-streams.js.json new file mode 100644 index 000000000..68398501c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3072-weak-process-streams.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3072-weak-process-streams.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3073-optional-callable-module.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3073-optional-callable-module.js.json new file mode 100644 index 000000000..6838dda82 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3073-optional-callable-module.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3073-optional-callable-module.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3073-union-keyed-reads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3073-union-keyed-reads.ts.json new file mode 100644 index 000000000..6b80e36fb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3073-union-keyed-reads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3073-union-keyed-reads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3074-discriminated-intersections.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3074-discriminated-intersections.ts.json new file mode 100644 index 000000000..7f03464ac --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3074-discriminated-intersections.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3074-discriminated-intersections.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3075-recursive-contextual-literals.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3075-recursive-contextual-literals.ts.json new file mode 100644 index 000000000..c2b7f5eaa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3075-recursive-contextual-literals.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3075-recursive-contextual-literals.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3076-nullish-record-defaults.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3076-nullish-record-defaults.ts.json new file mode 100644 index 000000000..f4a6413c9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3076-nullish-record-defaults.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3076-nullish-record-defaults.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3077-optional-union-array-reads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3077-optional-union-array-reads.ts.json new file mode 100644 index 000000000..9e84ec9ef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3077-optional-union-array-reads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3077-optional-union-array-reads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3078-forward-mutable-captures.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3078-forward-mutable-captures.ts.json new file mode 100644 index 000000000..f51b818a5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3078-forward-mutable-captures.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3078-forward-mutable-captures.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3079-forward-mutable-tdz.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3079-forward-mutable-tdz.ts.json new file mode 100644 index 000000000..a4ed20e44 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3079-forward-mutable-tdz.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3079-forward-mutable-tdz.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3080-exhaustive-never-bindings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3080-exhaustive-never-bindings.ts.json new file mode 100644 index 000000000..3c53f2624 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3080-exhaustive-never-bindings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3080-exhaustive-never-bindings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3081-recursive-array-destinations.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3081-recursive-array-destinations.ts.json new file mode 100644 index 000000000..78d87bc16 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3081-recursive-array-destinations.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3081-recursive-array-destinations.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3082-forward-write-unwind.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3082-forward-write-unwind.ts.json new file mode 100644 index 000000000..cc86d595c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3082-forward-write-unwind.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3082-forward-write-unwind.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3083-set-string-seed.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3083-set-string-seed.ts.json new file mode 100644 index 000000000..1c7ef044a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3083-set-string-seed.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3083-set-string-seed.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3084-record-own-membership.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3084-record-own-membership.ts.json new file mode 100644 index 000000000..cb79209c1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3084-record-own-membership.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3084-record-own-membership.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3085-conditional-record-construction.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3085-conditional-record-construction.ts.json new file mode 100644 index 000000000..e7df0ac9a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3085-conditional-record-construction.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3085-conditional-record-construction.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3086-error-constructor-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3086-error-constructor-options.ts.json new file mode 100644 index 000000000..d06d208c9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3086-error-constructor-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3086-error-constructor-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3087-error-options-lifetime.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3087-error-options-lifetime.ts.json new file mode 100644 index 000000000..523da4452 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3087-error-options-lifetime.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3087-error-options-lifetime.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3088-array-wide-callbacks.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3088-array-wide-callbacks.ts.json new file mode 100644 index 000000000..0c2aa441b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3088-array-wide-callbacks.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3088-array-wide-callbacks.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3089-array-find-narrowing.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3089-array-find-narrowing.ts.json new file mode 100644 index 000000000..28621dbb5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3089-array-find-narrowing.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3089-array-find-narrowing.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3090-json-discriminated-records.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3090-json-discriminated-records.ts.json new file mode 100644 index 000000000..ee1bc076a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3090-json-discriminated-records.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3090-json-discriminated-records.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3091-json-recursive-discriminants.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3091-json-recursive-discriminants.ts.json new file mode 100644 index 000000000..a15f07460 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3091-json-recursive-discriminants.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3091-json-recursive-discriminants.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3092-number-union-predicates.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3092-number-union-predicates.ts.json new file mode 100644 index 000000000..43f23c622 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3092-number-union-predicates.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3092-number-union-predicates.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3093-error-option-data.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3093-error-option-data.ts.json new file mode 100644 index 000000000..0f53b23ef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3093-error-option-data.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3093-error-option-data.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3094-json-replacer-traversal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3094-json-replacer-traversal.ts.json new file mode 100644 index 000000000..a03f51b46 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3094-json-replacer-traversal.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3094-json-replacer-traversal.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3095-json-reviver-traversal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3095-json-reviver-traversal.ts.json new file mode 100644 index 000000000..b8d9e769d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3095-json-reviver-traversal.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3095-json-reviver-traversal.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3096-json-callback-nonfinite.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3096-json-callback-nonfinite.ts.json new file mode 100644 index 000000000..dc62543cb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3096-json-callback-nonfinite.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3096-json-callback-nonfinite.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3097-json-callback-reentrancy.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3097-json-callback-reentrancy.ts.json new file mode 100644 index 000000000..e13f323a8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3097-json-callback-reentrancy.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3097-json-callback-reentrancy.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3098-json-callback-space.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3098-json-callback-space.ts.json new file mode 100644 index 000000000..cbdf3b4d2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3098-json-callback-space.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3098-json-callback-space.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3099-json-callback-functions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3099-json-callback-functions.ts.json new file mode 100644 index 000000000..a0d2559e7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3099-json-callback-functions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3099-json-callback-functions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3100-json-callback-holder.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3100-json-callback-holder.js.json new file mode 100644 index 000000000..1e5c6cc5b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3100-json-callback-holder.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3100-json-callback-holder.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3101-json-callback-bytes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3101-json-callback-bytes.ts.json new file mode 100644 index 000000000..4b0e9fe29 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3101-json-callback-bytes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3101-json-callback-bytes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3102-json-unknown-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3102-json-unknown-fields.ts.json new file mode 100644 index 000000000..15aab7def --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3102-json-unknown-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3102-json-unknown-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3103-scalar-record-nested-control-flow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3103-scalar-record-nested-control-flow.ts.json new file mode 100644 index 000000000..a0f37f9f8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3103-scalar-record-nested-control-flow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3103-scalar-record-nested-control-flow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3104-native-analysis-tables-loops.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3104-native-analysis-tables-loops.ts.json new file mode 100644 index 000000000..d951843ef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3104-native-analysis-tables-loops.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3104-native-analysis-tables-loops.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3105-nullable-collections.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3105-nullable-collections.ts.json new file mode 100644 index 000000000..7dd50d1b0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3105-nullable-collections.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3105-nullable-collections.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3106-mixed-insertion-spreads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3106-mixed-insertion-spreads.ts.json new file mode 100644 index 000000000..e82a8b280 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3106-mixed-insertion-spreads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3106-mixed-insertion-spreads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3107-nullable-collection-lifetimes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3107-nullable-collection-lifetimes.ts.json new file mode 100644 index 000000000..3ae1392fe --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3107-nullable-collection-lifetimes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3107-nullable-collection-lifetimes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3108-for-await-sync-arrays.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3108-for-await-sync-arrays.js.json new file mode 100644 index 000000000..440973593 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3108-for-await-sync-arrays.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3108-for-await-sync-arrays.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3108-identity-map-keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3108-identity-map-keys.ts.json new file mode 100644 index 000000000..c07b0d71a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3108-identity-map-keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3108-identity-map-keys.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3109-destructuring-unknown-defaults.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3109-destructuring-unknown-defaults.js.json new file mode 100644 index 000000000..556d23a9e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3109-destructuring-unknown-defaults.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3109-destructuring-unknown-defaults.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3109-identity-union-collections.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3109-identity-union-collections.ts.json new file mode 100644 index 000000000..b997f893b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3109-identity-union-collections.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3109-identity-union-collections.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3110-builtin-error-families.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3110-builtin-error-families.ts.json new file mode 100644 index 000000000..3d107c948 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3110-builtin-error-families.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3110-builtin-error-families.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3110-identity-collection-mutation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3110-identity-collection-mutation.ts.json new file mode 100644 index 000000000..0e96fa59e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3110-identity-collection-mutation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3110-identity-collection-mutation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3111-identity-collection-cycles.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3111-identity-collection-cycles.ts.json new file mode 100644 index 000000000..3445b22f2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3111-identity-collection-cycles.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3111-identity-collection-cycles.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3112-union-switch-control-flow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3112-union-switch-control-flow.ts.json new file mode 100644 index 000000000..c40e4bd71 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3112-union-switch-control-flow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3112-union-switch-control-flow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3113-union-array-removal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3113-union-array-removal.ts.json new file mode 100644 index 000000000..efaf3861d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3113-union-array-removal.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3113-union-array-removal.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3114-union-record-field-write.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3114-union-record-field-write.ts.json new file mode 100644 index 000000000..99ac815e6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3114-union-record-field-write.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3114-union-record-field-write.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3115-zlib-static-compression-levels.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3115-zlib-static-compression-levels.ts.json new file mode 100644 index 000000000..0b97b33e1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3115-zlib-static-compression-levels.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3115-zlib-static-compression-levels.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3116-sequence-expression-lifetimes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3116-sequence-expression-lifetimes.ts.json new file mode 100644 index 000000000..99aae3609 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3116-sequence-expression-lifetimes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3116-sequence-expression-lifetimes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3117-unknown-switch-control-flow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3117-unknown-switch-control-flow.ts.json new file mode 100644 index 000000000..244792f42 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3117-unknown-switch-control-flow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3117-unknown-switch-control-flow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3118-recursive-union-spread.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3118-recursive-union-spread.ts.json new file mode 100644 index 000000000..4bd56df5f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3118-recursive-union-spread.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3118-recursive-union-spread.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3119-runtime-optional-spread.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3119-runtime-optional-spread.ts.json new file mode 100644 index 000000000..02767fec9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3119-runtime-optional-spread.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3119-runtime-optional-spread.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3120-dynamic-property-descriptors.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3120-dynamic-property-descriptors.js.json new file mode 100644 index 000000000..cd1de483c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3120-dynamic-property-descriptors.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3120-dynamic-property-descriptors.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3120-generator-method-loop-bindings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3120-generator-method-loop-bindings.ts.json new file mode 100644 index 000000000..52fa2f3b5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3120-generator-method-loop-bindings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3120-generator-method-loop-bindings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3120-ir-nonfinite-numbers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3120-ir-nonfinite-numbers.ts.json new file mode 100644 index 000000000..ac4b4ce4a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3120-ir-nonfinite-numbers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3120-ir-nonfinite-numbers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3121-compound-assignment-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3121-compound-assignment-values.js.json new file mode 100644 index 000000000..1b68ac571 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3121-compound-assignment-values.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3121-compound-assignment-values.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3121-dynamic-accessor-descriptors.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3121-dynamic-accessor-descriptors.js.json new file mode 100644 index 000000000..b15e83a5e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3121-dynamic-accessor-descriptors.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3121-dynamic-accessor-descriptors.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3122-dynamic-delete-descriptors.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3122-dynamic-delete-descriptors.cjs.json new file mode 100644 index 000000000..0427bb32e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3122-dynamic-delete-descriptors.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3122-dynamic-delete-descriptors.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3122-dynamic-delete-descriptors.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3122-dynamic-delete-descriptors.js.json new file mode 100644 index 000000000..4dade56c2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3122-dynamic-delete-descriptors.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3122-dynamic-delete-descriptors.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3122-js-async-class-methods.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3122-js-async-class-methods.js.json new file mode 100644 index 000000000..45d86b864 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3122-js-async-class-methods.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3122-js-async-class-methods.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3123-destructured-global-tdz.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3123-destructured-global-tdz.js.json new file mode 100644 index 000000000..584e7f67f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3123-destructured-global-tdz.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3123-destructured-global-tdz.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3124-array-prototype-borrow.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3124-array-prototype-borrow.js.json new file mode 100644 index 000000000..8e4e87848 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3124-array-prototype-borrow.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3124-array-prototype-borrow.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3125-regex-global-match.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3125-regex-global-match.ts.json new file mode 100644 index 000000000..25be256a9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3125-regex-global-match.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3125-regex-global-match.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3126-js-number-radix/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3126-js-number-radix/main.ts.json new file mode 100644 index 000000000..f7a691c26 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3126-js-number-radix/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/3126-js-number-radix/format.js", + "/tests/corpus/3126-js-number-radix/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3127-spawn-runtime-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3127-spawn-runtime-options.ts.json new file mode 100644 index 000000000..e9f4adf37 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3127-spawn-runtime-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3127-spawn-runtime-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3128-regex-last-index.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3128-regex-last-index.ts.json new file mode 100644 index 000000000..9803ebbc4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3128-regex-last-index.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3128-regex-last-index.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3129-js-token-union/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3129-js-token-union/main.ts.json new file mode 100644 index 000000000..68d57b698 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3129-js-token-union/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/3129-js-token-union/lexer.js", + "/tests/corpus/3129-js-token-union/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3130-child-generic-streams.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3130-child-generic-streams.ts.json new file mode 100644 index 000000000..4ee812686 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3130-child-generic-streams.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3130-child-generic-streams.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3131-child-rest-listeners.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3131-child-rest-listeners.js.json new file mode 100644 index 000000000..00fa91dd3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3131-child-rest-listeners.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3131-child-rest-listeners.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3132-child-generic-stream-completion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3132-child-generic-stream-completion.ts.json new file mode 100644 index 000000000..52cff8740 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3132-child-generic-stream-completion.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3132-child-generic-stream-completion.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3133-text-decoder-streaming.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3133-text-decoder-streaming.ts.json new file mode 100644 index 000000000..4dcd34d32 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3133-text-decoder-streaming.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3133-text-decoder-streaming.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3134-fs-vectors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3134-fs-vectors.ts.json new file mode 100644 index 000000000..d7fef964f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3134-fs-vectors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3134-fs-vectors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3135-fs-file-handle-controls.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3135-fs-file-handle-controls.ts.json new file mode 100644 index 000000000..f4cc8db32 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3135-fs-file-handle-controls.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3135-fs-file-handle-controls.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3136-fs-file-handle-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3136-fs-file-handle-options.ts.json new file mode 100644 index 000000000..a5487c899 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3136-fs-file-handle-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3136-fs-file-handle-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3137-fs-vector-callbacks.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3137-fs-vector-callbacks.cjs.json new file mode 100644 index 000000000..a01109392 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3137-fs-vector-callbacks.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3137-fs-vector-callbacks.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3138-array-large-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3138-array-large-storage.ts.json new file mode 100644 index 000000000..eb9aa808a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3138-array-large-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3138-array-large-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3139-regex-native-deep-alternatives.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3139-regex-native-deep-alternatives.ts.json new file mode 100644 index 000000000..842f5d2cb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3139-regex-native-deep-alternatives.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3139-regex-native-deep-alternatives.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3140-array-dense-access.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3140-array-dense-access.ts.json new file mode 100644 index 000000000..44f44f7fd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3140-array-dense-access.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3140-array-dense-access.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3141-map-string-key-hash.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3141-map-string-key-hash.ts.json new file mode 100644 index 000000000..587a5aa74 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3141-map-string-key-hash.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3141-map-string-key-hash.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3150-integer-remainder.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3150-integer-remainder.ts.json new file mode 100644 index 000000000..a1b3d4536 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3150-integer-remainder.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3150-integer-remainder.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3151-array-push-writes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3151-array-push-writes.ts.json new file mode 100644 index 000000000..2a94b96dd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3151-array-push-writes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3151-array-push-writes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3170-number-conversion-fast-paths.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3170-number-conversion-fast-paths.ts.json new file mode 100644 index 000000000..e6f35424d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3170-number-conversion-fast-paths.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3170-number-conversion-fast-paths.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3171-method-census-data-writes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3171-method-census-data-writes.ts.json new file mode 100644 index 000000000..4b03a8356 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/3171-method-census-data-writes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/3171-method-census-data-writes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/400-fib.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/400-fib.ts.json new file mode 100644 index 000000000..eecf60351 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/400-fib.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/400-fib.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/401-mutual-recursion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/401-mutual-recursion.ts.json new file mode 100644 index 000000000..5e9fbf119 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/401-mutual-recursion.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/401-mutual-recursion.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/402-string-functions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/402-string-functions.ts.json new file mode 100644 index 000000000..7b25cde68 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/402-string-functions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/402-string-functions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/403-void-and-params.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/403-void-and-params.ts.json new file mode 100644 index 000000000..814b5900e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/403-void-and-params.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/403-void-and-params.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4030-runtime-object-truthiness.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4030-runtime-object-truthiness.ts.json new file mode 100644 index 000000000..986c148a3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4030-runtime-object-truthiness.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4030-runtime-object-truthiness.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4031-event-emitter-long-tuples.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4031-event-emitter-long-tuples.ts.json new file mode 100644 index 000000000..9cbd0b27c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4031-event-emitter-long-tuples.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4031-event-emitter-long-tuples.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4032-inline-rc-fast-paths.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4032-inline-rc-fast-paths.ts.json new file mode 100644 index 000000000..1a93e0454 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4032-inline-rc-fast-paths.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4032-inline-rc-fast-paths.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/404-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/404-rc-stress.ts.json new file mode 100644 index 000000000..a56b620a8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/404-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/404-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4040-adapted-function-identity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4040-adapted-function-identity.ts.json new file mode 100644 index 000000000..b5f536bb2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4040-adapted-function-identity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4040-adapted-function-identity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4041-adapted-function-properties.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4041-adapted-function-properties.ts.json new file mode 100644 index 000000000..aab0ecced --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4041-adapted-function-properties.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4041-adapted-function-properties.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4042-object-is-union-subclass.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4042-object-is-union-subclass.ts.json new file mode 100644 index 000000000..550d5128b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4042-object-is-union-subclass.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4042-object-is-union-subclass.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4043-nonnull-missing-element.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4043-nonnull-missing-element.ts.json new file mode 100644 index 000000000..fca693702 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4043-nonnull-missing-element.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4043-nonnull-missing-element.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4044-adapted-callback-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4044-adapted-callback-modules/main.ts.json new file mode 100644 index 000000000..d33fab499 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4044-adapted-callback-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/4044-adapted-callback-modules/registry.ts", + "/tests/corpus/4044-adapted-callback-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4045-optional-element-projections.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4045-optional-element-projections.ts.json new file mode 100644 index 000000000..54f26c2f4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4045-optional-element-projections.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4045-optional-element-projections.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4046-captured-parameter-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4046-captured-parameter-values.ts.json new file mode 100644 index 000000000..48b6fa070 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4046-captured-parameter-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4046-captured-parameter-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4047-captured-parameter-rebinding.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4047-captured-parameter-rebinding.ts.json new file mode 100644 index 000000000..3b894f01b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4047-captured-parameter-rebinding.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4047-captured-parameter-rebinding.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/405-params-optional.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/405-params-optional.ts.json new file mode 100644 index 000000000..f50842cbe --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/405-params-optional.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/405-params-optional.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/406-params-defaults.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/406-params-defaults.ts.json new file mode 100644 index 000000000..8132b9c57 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/406-params-defaults.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/406-params-defaults.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4060-cycle-shared-instance/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4060-cycle-shared-instance/main.ts.json new file mode 100644 index 000000000..61a5b8ea7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4060-cycle-shared-instance/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/4060-cycle-shared-instance/report.ts", + "/tests/corpus/4060-cycle-shared-instance/inventory.ts", + "/tests/corpus/4060-cycle-shared-instance/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4060-stack-union-reads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4060-stack-union-reads.ts.json new file mode 100644 index 000000000..47867cb36 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4060-stack-union-reads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4060-stack-union-reads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4061-cycle-evaluation-order/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4061-cycle-evaluation-order/main.ts.json new file mode 100644 index 000000000..095cc0332 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4061-cycle-evaluation-order/main.ts.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/4061-cycle-evaluation-order/south.ts", + "/tests/corpus/4061-cycle-evaluation-order/east.ts", + "/tests/corpus/4061-cycle-evaluation-order/north.ts", + "/tests/corpus/4061-cycle-evaluation-order/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4061-nullable-ref-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4061-nullable-ref-fields.ts.json new file mode 100644 index 000000000..45208de4a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4061-nullable-ref-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4061-nullable-ref-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4062-cycle-tdz-read/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4062-cycle-tdz-read/main.ts.json new file mode 100644 index 000000000..1a64d5df4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4062-cycle-tdz-read/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/4062-cycle-tdz-read/probe.ts", + "/tests/corpus/4062-cycle-tdz-read/limits.ts", + "/tests/corpus/4062-cycle-tdz-read/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4063-cycle-hoisted-calls/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4063-cycle-hoisted-calls/main.ts.json new file mode 100644 index 000000000..ddb979d32 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4063-cycle-hoisted-calls/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/4063-cycle-hoisted-calls/odd.ts", + "/tests/corpus/4063-cycle-hoisted-calls/even.ts", + "/tests/corpus/4063-cycle-hoisted-calls/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4064-cycle-classes-after-init/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4064-cycle-classes-after-init/main.ts.json new file mode 100644 index 000000000..b7a6a0439 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4064-cycle-classes-after-init/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/4064-cycle-classes-after-init/item.ts", + "/tests/corpus/4064-cycle-classes-after-init/shelf.ts", + "/tests/corpus/4064-cycle-classes-after-init/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4065-cycle-init-throws/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4065-cycle-init-throws/main.ts.json new file mode 100644 index 000000000..1ebf8dea4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4065-cycle-init-throws/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/4065-cycle-init-throws/rules.ts", + "/tests/corpus/4065-cycle-init-throws/ledger.ts", + "/tests/corpus/4065-cycle-init-throws/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4066-cycle-top-level-tdz/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4066-cycle-top-level-tdz/main.ts.json new file mode 100644 index 000000000..007dfcdab --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4066-cycle-top-level-tdz/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/4066-cycle-top-level-tdz/margin.ts", + "/tests/corpus/4066-cycle-top-level-tdz/frame.ts", + "/tests/corpus/4066-cycle-top-level-tdz/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4067-dynamic-import-cycle-tdz/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4067-dynamic-import-cycle-tdz/main.ts.json new file mode 100644 index 000000000..e8a12bd73 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4067-dynamic-import-cycle-tdz/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4067-dynamic-import-cycle-tdz/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/407-params-rest.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/407-params-rest.ts.json new file mode 100644 index 000000000..74a2ac131 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/407-params-rest.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/407-params-rest.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/408-params-ctors-inheritance.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/408-params-ctors-inheritance.ts.json new file mode 100644 index 000000000..eeaba130d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/408-params-ctors-inheritance.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/408-params-ctors-inheritance.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4080-optional-read-presence-tests.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4080-optional-read-presence-tests.ts.json new file mode 100644 index 000000000..c41e768e6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4080-optional-read-presence-tests.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4080-optional-read-presence-tests.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4080-string-index-bounds.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4080-string-index-bounds.ts.json new file mode 100644 index 000000000..8cb132b15 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4080-string-index-bounds.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4080-string-index-bounds.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4081-hoisted-function-tdz.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4081-hoisted-function-tdz.ts.json new file mode 100644 index 000000000..0f14c628f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4081-hoisted-function-tdz.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4081-hoisted-function-tdz.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4081-string-index-unproven.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4081-string-index-unproven.ts.json new file mode 100644 index 000000000..f122831d7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4081-string-index-unproven.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4081-string-index-unproven.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4082-hoisted-function-tdz-uncaught.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4082-hoisted-function-tdz-uncaught.ts.json new file mode 100644 index 000000000..d28e4d961 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4082-hoisted-function-tdz-uncaught.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4082-hoisted-function-tdz-uncaught.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4083-dynamic-import-failure/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4083-dynamic-import-failure/main.ts.json new file mode 100644 index 000000000..3532cafbe --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4083-dynamic-import-failure/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/4083-dynamic-import-failure/errors.ts", + "/tests/corpus/4083-dynamic-import-failure/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4084-record-optional-field-copies.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4084-record-optional-field-copies.ts.json new file mode 100644 index 000000000..8abcf5a77 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4084-record-optional-field-copies.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4084-record-optional-field-copies.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4085-generator-loop-close.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4085-generator-loop-close.ts.json new file mode 100644 index 000000000..8f7edbef5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4085-generator-loop-close.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4085-generator-loop-close.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4086-optional-capture-defaults.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4086-optional-capture-defaults.ts.json new file mode 100644 index 000000000..2099e078b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4086-optional-capture-defaults.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4086-optional-capture-defaults.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4088-class-static-tdz.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4088-class-static-tdz.ts.json new file mode 100644 index 000000000..ae5ff5df0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4088-class-static-tdz.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4088-class-static-tdz.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4089-class-wrapper-tdz.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4089-class-wrapper-tdz.js.json new file mode 100644 index 000000000..27c69c429 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4089-class-wrapper-tdz.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4089-class-wrapper-tdz.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/409-params-async-generics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/409-params-async-generics.ts.json new file mode 100644 index 000000000..e94b3439f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/409-params-async-generics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/409-params-async-generics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4090-computed-key-tdz.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4090-computed-key-tdz.js.json new file mode 100644 index 000000000..5e3f6990f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4090-computed-key-tdz.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4090-computed-key-tdz.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4091-class-evaluation-deferred.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4091-class-evaluation-deferred.ts.json new file mode 100644 index 000000000..e7df0e246 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4091-class-evaluation-deferred.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4091-class-evaluation-deferred.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/410-params-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/410-params-rc-stress.ts.json new file mode 100644 index 000000000..6475749cd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/410-params-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/410-params-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4140-array-callback-split-visit.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4140-array-callback-split-visit.ts.json new file mode 100644 index 000000000..5385c6380 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4140-array-callback-split-visit.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4140-array-callback-split-visit.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4141-array-callback-ambient-receiver/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4141-array-callback-ambient-receiver/main.ts.json new file mode 100644 index 000000000..06c679a62 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4141-array-callback-ambient-receiver/main.ts.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/4141-array-callback-ambient-receiver/peek.mjs", + "/tests/corpus/4141-array-callback-ambient-receiver/mapper.ts", + "/tests/corpus/4141-array-callback-ambient-receiver/holder.mjs", + "/tests/corpus/4141-array-callback-ambient-receiver/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4142-array-callback-factories.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4142-array-callback-factories.ts.json new file mode 100644 index 000000000..7e3d81573 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4142-array-callback-factories.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4142-array-callback-factories.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4143-union-refinement-intersection-arms.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4143-union-refinement-intersection-arms.ts.json new file mode 100644 index 000000000..32a6398e5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4143-union-refinement-intersection-arms.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4143-union-refinement-intersection-arms.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/420-dead-strip-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/420-dead-strip-modules/main.ts.json new file mode 100644 index 000000000..8266e5212 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/420-dead-strip-modules/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/420-dead-strip-modules/side.ts", + "/tests/corpus/420-dead-strip-modules/lib.ts", + "/tests/corpus/420-dead-strip-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4290-acyclic-immutable-trees.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4290-acyclic-immutable-trees.ts.json new file mode 100644 index 000000000..9589c9866 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4290-acyclic-immutable-trees.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4290-acyclic-immutable-trees.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4291-acyclic-constructor-escapes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4291-acyclic-constructor-escapes.ts.json new file mode 100644 index 000000000..16e1a4180 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4291-acyclic-constructor-escapes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4291-acyclic-constructor-escapes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4292-acyclic-readonly-bypass.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4292-acyclic-readonly-bypass.ts.json new file mode 100644 index 000000000..37811b953 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4292-acyclic-readonly-bypass.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4292-acyclic-readonly-bypass.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4293-acyclic-dynamic-writes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4293-acyclic-dynamic-writes.ts.json new file mode 100644 index 000000000..7991cd587 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4293-acyclic-dynamic-writes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4293-acyclic-dynamic-writes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4294-console-line-sizes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4294-console-line-sizes.ts.json new file mode 100644 index 000000000..8ee13c90d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4294-console-line-sizes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4294-console-line-sizes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4295-console-template-parts.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4295-console-template-parts.ts.json new file mode 100644 index 000000000..0754b848c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4295-console-template-parts.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4295-console-template-parts.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4296-console-glued-long-parts.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4296-console-glued-long-parts.ts.json new file mode 100644 index 000000000..85213b998 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4296-console-glued-long-parts.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4296-console-glued-long-parts.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4410-inline-object-allocation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4410-inline-object-allocation.ts.json new file mode 100644 index 000000000..3cb4be811 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4410-inline-object-allocation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4410-inline-object-allocation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4411-nullable-ref-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4411-nullable-ref-values.ts.json new file mode 100644 index 000000000..ee1778138 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4411-nullable-ref-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4411-nullable-ref-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4412-nullable-record-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4412-nullable-record-values.ts.json new file mode 100644 index 000000000..eb5958bd8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4412-nullable-record-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4412-nullable-record-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4413-cycle-old-late-death.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4413-cycle-old-late-death.ts.json new file mode 100644 index 000000000..aa37cd62a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4413-cycle-old-late-death.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4413-cycle-old-late-death.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4413-nullable-null-and-undefined.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4413-nullable-null-and-undefined.ts.json new file mode 100644 index 000000000..aafb5d40b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4413-nullable-null-and-undefined.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4413-nullable-null-and-undefined.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4414-cycle-old-weak-keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4414-cycle-old-weak-keys.ts.json new file mode 100644 index 000000000..ddcae530a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4414-cycle-old-weak-keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4414-cycle-old-weak-keys.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4414-nullable-string-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4414-nullable-string-values.ts.json new file mode 100644 index 000000000..cb40d6d12 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4414-nullable-string-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4414-nullable-string-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4415-identity-borrowed-operands.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4415-identity-borrowed-operands.ts.json new file mode 100644 index 000000000..5b4d2a465 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4415-identity-borrowed-operands.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4415-identity-borrowed-operands.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4415-nullable-container-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4415-nullable-container-values.ts.json new file mode 100644 index 000000000..c2c44e4e4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4415-nullable-container-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4415-nullable-container-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4431-exception-pending-contexts.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4431-exception-pending-contexts.ts.json new file mode 100644 index 000000000..7272ece72 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4431-exception-pending-contexts.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4431-exception-pending-contexts.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4432-checked-downcast-failures.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4432-checked-downcast-failures.ts.json new file mode 100644 index 000000000..fe5548f25 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4432-checked-downcast-failures.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4432-checked-downcast-failures.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4451-int32-field-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4451-int32-field-storage.ts.json new file mode 100644 index 000000000..188f7bd3d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4451-int32-field-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4451-int32-field-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4452-int32-field-dynamic-writes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4452-int32-field-dynamic-writes.ts.json new file mode 100644 index 000000000..3023c1d00 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4452-int32-field-dynamic-writes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4452-int32-field-dynamic-writes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4453-int32-closed-locals.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4453-int32-closed-locals.ts.json new file mode 100644 index 000000000..541f76eb4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4453-int32-closed-locals.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4453-int32-closed-locals.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4471-unassigned-field-reads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4471-unassigned-field-reads.ts.json new file mode 100644 index 000000000..adaa6a2dd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4471-unassigned-field-reads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4471-unassigned-field-reads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4476-string-ascii-header-fact.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4476-string-ascii-header-fact.ts.json new file mode 100644 index 000000000..99aef3ca0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4476-string-ascii-header-fact.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4476-string-ascii-header-fact.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4477-buffer-write-ascii-runs.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4477-buffer-write-ascii-runs.ts.json new file mode 100644 index 000000000..a3066da63 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4477-buffer-write-ascii-runs.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4477-buffer-write-ascii-runs.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4478-string-large-index-reads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4478-string-large-index-reads.ts.json new file mode 100644 index 000000000..df7abc088 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4478-string-large-index-reads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4478-string-large-index-reads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4481-array-optional-push.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4481-array-optional-push.ts.json new file mode 100644 index 000000000..4d93629a3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4481-array-optional-push.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4481-array-optional-push.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4482-instanceof-static-class-optional.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4482-instanceof-static-class-optional.ts.json new file mode 100644 index 000000000..b05d260bf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4482-instanceof-static-class-optional.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4482-instanceof-static-class-optional.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4483-array-splice-statement.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4483-array-splice-statement.ts.json new file mode 100644 index 000000000..51435eedc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4483-array-splice-statement.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4483-array-splice-statement.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4484-array-length-reset.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4484-array-length-reset.ts.json new file mode 100644 index 000000000..c65d70c43 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4484-array-length-reset.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4484-array-length-reset.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4485-array-splice-optional-item.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4485-array-splice-optional-item.ts.json new file mode 100644 index 000000000..a424abdd5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4485-array-splice-optional-item.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4485-array-splice-optional-item.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4486-array-field-element-borrows.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4486-array-field-element-borrows.ts.json new file mode 100644 index 000000000..29ebc6f22 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4486-array-field-element-borrows.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4486-array-field-element-borrows.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4487-array-literal-optional-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4487-array-literal-optional-values.ts.json new file mode 100644 index 000000000..71f27b9aa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4487-array-literal-optional-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4487-array-literal-optional-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4520-optional-guard-narrowing.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4520-optional-guard-narrowing.ts.json new file mode 100644 index 000000000..98507eade --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4520-optional-guard-narrowing.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4520-optional-guard-narrowing.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4521-array-callback-element-presence.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4521-array-callback-element-presence.ts.json new file mode 100644 index 000000000..ab769261e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4521-array-callback-element-presence.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4521-array-callback-element-presence.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4522-captured-parameter-lifetimes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4522-captured-parameter-lifetimes.ts.json new file mode 100644 index 000000000..e2c4147ad --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4522-captured-parameter-lifetimes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4522-captured-parameter-lifetimes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4523-array-pop-removal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4523-array-pop-removal.ts.json new file mode 100644 index 000000000..b14d7cd2d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4523-array-pop-removal.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4523-array-pop-removal.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4524-array-callback-supertype-params.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4524-array-callback-supertype-params.ts.json new file mode 100644 index 000000000..df8bd99f2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4524-array-callback-supertype-params.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4524-array-callback-supertype-params.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4541-nullable-wrap-borrows.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4541-nullable-wrap-borrows.ts.json new file mode 100644 index 000000000..cc3b61f91 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4541-nullable-wrap-borrows.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4541-nullable-wrap-borrows.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4542-preserving-call-borrows.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4542-preserving-call-borrows.ts.json new file mode 100644 index 000000000..817d183f8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4542-preserving-call-borrows.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4542-preserving-call-borrows.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4543-walk-borrowed-locals.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4543-walk-borrowed-locals.ts.json new file mode 100644 index 000000000..753294d20 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4543-walk-borrowed-locals.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4543-walk-borrowed-locals.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4544-checked-cast-aliases.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4544-checked-cast-aliases.ts.json new file mode 100644 index 000000000..78d3b3ad5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4544-checked-cast-aliases.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4544-checked-cast-aliases.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4545-borrowed-returns.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4545-borrowed-returns.ts.json new file mode 100644 index 000000000..b5fb5b0d3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4545-borrowed-returns.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4545-borrowed-returns.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4546-rebound-borrowed-params.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4546-rebound-borrowed-params.ts.json new file mode 100644 index 000000000..71d0494ab --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4546-rebound-borrowed-params.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4546-rebound-borrowed-params.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4560-field-store-borrowed-receivers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4560-field-store-borrowed-receivers.ts.json new file mode 100644 index 000000000..b5b295d6a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4560-field-store-borrowed-receivers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4560-field-store-borrowed-receivers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4561-virtual-borrowed-parameters.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4561-virtual-borrowed-parameters.ts.json new file mode 100644 index 000000000..f9a99d17b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4561-virtual-borrowed-parameters.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4561-virtual-borrowed-parameters.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4562-string-self-concat-move.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4562-string-self-concat-move.ts.json new file mode 100644 index 000000000..15e6fbbdc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4562-string-self-concat-move.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4562-string-self-concat-move.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4563-array-read-projection-receivers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4563-array-read-projection-receivers.ts.json new file mode 100644 index 000000000..45fcf92bb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4563-array-read-projection-receivers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4563-array-read-projection-receivers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4564-literal-choice-strings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4564-literal-choice-strings.ts.json new file mode 100644 index 000000000..0c8bb900b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4564-literal-choice-strings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4564-literal-choice-strings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4568-for-of-hole-elements.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4568-for-of-hole-elements.ts.json new file mode 100644 index 000000000..6a5ac320d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4568-for-of-hole-elements.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4568-for-of-hole-elements.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4569-shorthand-missing-elements.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4569-shorthand-missing-elements.ts.json new file mode 100644 index 000000000..a6eb81649 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4569-shorthand-missing-elements.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4569-shorthand-missing-elements.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4570-map-lookup-default-record.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4570-map-lookup-default-record.ts.json new file mode 100644 index 000000000..8360f1d48 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4570-map-lookup-default-record.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4570-map-lookup-default-record.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4591-weak-keys-union-records.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4591-weak-keys-union-records.ts.json new file mode 100644 index 000000000..aa85da828 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4591-weak-keys-union-records.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4591-weak-keys-union-records.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4592-cycle-const-from-import/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4592-cycle-const-from-import/main.ts.json new file mode 100644 index 000000000..fe66721f5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4592-cycle-const-from-import/main.ts.json @@ -0,0 +1,10 @@ +{ + "order": [ + "/tests/corpus/4592-cycle-const-from-import/report.ts", + "/tests/corpus/4592-cycle-const-from-import/stock.ts", + "/tests/corpus/4592-cycle-const-from-import/markup.ts", + "/tests/corpus/4592-cycle-const-from-import/pricing.ts", + "/tests/corpus/4592-cycle-const-from-import/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4593-weak-keys-empty-objects.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4593-weak-keys-empty-objects.ts.json new file mode 100644 index 000000000..e509686cb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4593-weak-keys-empty-objects.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4593-weak-keys-empty-objects.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4594-union-class-field-mixed-types.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4594-union-class-field-mixed-types.ts.json new file mode 100644 index 000000000..1ef7860da --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4594-union-class-field-mixed-types.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4594-union-class-field-mixed-types.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4595-union-class-field-optional-receiver.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4595-union-class-field-optional-receiver.ts.json new file mode 100644 index 000000000..43fca0e3f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4595-union-class-field-optional-receiver.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4595-union-class-field-optional-receiver.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4596-error-subclass-int-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4596-error-subclass-int-fields.ts.json new file mode 100644 index 000000000..d4328260f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4596-error-subclass-int-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4596-error-subclass-int-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4596-tdz-nullable-forward-capture.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4596-tdz-nullable-forward-capture.ts.json new file mode 100644 index 000000000..505642808 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4596-tdz-nullable-forward-capture.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4596-tdz-nullable-forward-capture.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4597-callback-field-method-name.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4597-callback-field-method-name.ts.json new file mode 100644 index 000000000..2c090d888 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4597-callback-field-method-name.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4597-callback-field-method-name.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4598-live-array-ref-element-access.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4598-live-array-ref-element-access.ts.json new file mode 100644 index 000000000..4082c5c86 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4598-live-array-ref-element-access.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4598-live-array-ref-element-access.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4598-map-set-clear-reuse.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4598-map-set-clear-reuse.ts.json new file mode 100644 index 000000000..97af3d898 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4598-map-set-clear-reuse.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4598-map-set-clear-reuse.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4598-os-available-parallelism.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4598-os-available-parallelism.ts.json new file mode 100644 index 000000000..1224ad181 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4598-os-available-parallelism.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4598-os-available-parallelism.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4601-cycle-holders.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4601-cycle-holders.ts.json new file mode 100644 index 000000000..ebc1d0f13 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4601-cycle-holders.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4601-cycle-holders.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4602-constructor-escape-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4602-constructor-escape-order.ts.json new file mode 100644 index 000000000..736dedbc3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4602-constructor-escape-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4602-constructor-escape-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4610-array-ext-dyn-refresh.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4610-array-ext-dyn-refresh.ts.json new file mode 100644 index 000000000..12e5a2a2f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4610-array-ext-dyn-refresh.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4610-array-ext-dyn-refresh.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4620-optional-chain-borrowed-receivers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4620-optional-chain-borrowed-receivers.ts.json new file mode 100644 index 000000000..b0845e259 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4620-optional-chain-borrowed-receivers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4620-optional-chain-borrowed-receivers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4621-edge-preserving-callees/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4621-edge-preserving-callees/main.ts.json new file mode 100644 index 000000000..7e5ae4724 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4621-edge-preserving-callees/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/4621-edge-preserving-callees/compare.ts", + "/tests/corpus/4621-edge-preserving-callees/items.ts", + "/tests/corpus/4621-edge-preserving-callees/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4650-stale-property-narrowing.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4650-stale-property-narrowing.ts.json new file mode 100644 index 000000000..fafda9afe --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4650-stale-property-narrowing.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4650-stale-property-narrowing.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4651-map-string-get-entry.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4651-map-string-get-entry.ts.json new file mode 100644 index 000000000..15b76b814 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4651-map-string-get-entry.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4651-map-string-get-entry.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4652-stale-closure-binding-narrowing.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4652-stale-closure-binding-narrowing.ts.json new file mode 100644 index 000000000..ba2d009ac --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4652-stale-closure-binding-narrowing.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4652-stale-closure-binding-narrowing.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4660-typed-rest-spread-forwarding.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4660-typed-rest-spread-forwarding.ts.json new file mode 100644 index 000000000..4631ddde8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4660-typed-rest-spread-forwarding.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4660-typed-rest-spread-forwarding.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4671-scoped-array-read-borrows.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4671-scoped-array-read-borrows.ts.json new file mode 100644 index 000000000..cc5e0ce51 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4671-scoped-array-read-borrows.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4671-scoped-array-read-borrows.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4690-cycle-bypass-long-lived.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4690-cycle-bypass-long-lived.ts.json new file mode 100644 index 000000000..bbef09020 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4690-cycle-bypass-long-lived.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4690-cycle-bypass-long-lived.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/500-array-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/500-array-basics.ts.json new file mode 100644 index 000000000..0c45b45e6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/500-array-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/500-array-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/501-array-push-pop.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/501-array-push-pop.ts.json new file mode 100644 index 000000000..8c0e2728b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/501-array-push-pop.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/501-array-push-pop.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/502-array-for-of.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/502-array-for-of.ts.json new file mode 100644 index 000000000..b9b2f01c7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/502-array-for-of.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/502-array-for-of.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/503-array-functions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/503-array-functions.ts.json new file mode 100644 index 000000000..dcd9cbc63 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/503-array-functions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/503-array-functions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/504-array-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/504-array-rc-stress.ts.json new file mode 100644 index 000000000..911fcfdcd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/504-array-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/504-array-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/510-array-map-filter-foreach.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/510-array-map-filter-foreach.ts.json new file mode 100644 index 000000000..300c2c1ea --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/510-array-map-filter-foreach.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/510-array-map-filter-foreach.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/511-array-indexof-includes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/511-array-indexof-includes.ts.json new file mode 100644 index 000000000..70c75e4fd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/511-array-indexof-includes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/511-array-indexof-includes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/512-array-join-chains.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/512-array-join-chains.ts.json new file mode 100644 index 000000000..dac9cc2c6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/512-array-join-chains.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/512-array-join-chains.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/513-array-methods-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/513-array-methods-rc-stress.ts.json new file mode 100644 index 000000000..3d5b409c4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/513-array-methods-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/513-array-methods-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/514-array-find-some-every.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/514-array-find-some-every.ts.json new file mode 100644 index 000000000..6ff94eaae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/514-array-find-some-every.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/514-array-find-some-every.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/515-array-flatmap.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/515-array-flatmap.ts.json new file mode 100644 index 000000000..48fa219af --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/515-array-flatmap.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/515-array-flatmap.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/516-array-reduce.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/516-array-reduce.ts.json new file mode 100644 index 000000000..22d70be5b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/516-array-reduce.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/516-array-reduce.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/517-array-hof-index-args.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/517-array-hof-index-args.ts.json new file mode 100644 index 000000000..25b0c1ea0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/517-array-hof-index-args.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/517-array-hof-index-args.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/518-array-sort.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/518-array-sort.ts.json new file mode 100644 index 000000000..092ccafad --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/518-array-sort.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/518-array-sort.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/518-promise-void-union-callbacks.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/518-promise-void-union-callbacks.ts.json new file mode 100644 index 000000000..df5197f68 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/518-promise-void-union-callbacks.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/518-promise-void-union-callbacks.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/519-array-from-length.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/519-array-from-length.ts.json new file mode 100644 index 000000000..bbacceb67 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/519-array-from-length.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/519-array-from-length.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/519-promise-union-await-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/519-promise-union-await-values.ts.json new file mode 100644 index 000000000..d13f1f345 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/519-promise-union-await-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/519-promise-union-await-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/520-map-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/520-map-basics.ts.json new file mode 100644 index 000000000..710884050 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/520-map-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/520-map-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/521-map-number-keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/521-map-number-keys.ts.json new file mode 100644 index 000000000..2cbfd6fd8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/521-map-number-keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/521-map-number-keys.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/522-map-foreach.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/522-map-foreach.ts.json new file mode 100644 index 000000000..585cd6320 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/522-map-foreach.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/522-map-foreach.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/523-map-ref-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/523-map-ref-values.ts.json new file mode 100644 index 000000000..fa321c18f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/523-map-ref-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/523-map-ref-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/524-map-cycles.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/524-map-cycles.ts.json new file mode 100644 index 000000000..7382bdd6d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/524-map-cycles.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/524-map-cycles.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/525-map-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/525-map-rc-stress.ts.json new file mode 100644 index 000000000..c7b15987b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/525-map-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/525-map-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/526-set-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/526-set-basics.ts.json new file mode 100644 index 000000000..d3c51431c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/526-set-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/526-set-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/527-set-foreach.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/527-set-foreach.ts.json new file mode 100644 index 000000000..be5772be8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/527-set-foreach.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/527-set-foreach.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/528-set-seeded.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/528-set-seeded.ts.json new file mode 100644 index 000000000..2539186f7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/528-set-seeded.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/528-set-seeded.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/529-map-seeded.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/529-map-seeded.ts.json new file mode 100644 index 000000000..e595acc0e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/529-map-seeded.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/529-map-seeded.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/530-record-arrays.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/530-record-arrays.ts.json new file mode 100644 index 000000000..7ec8e48e4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/530-record-arrays.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/530-record-arrays.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/531-record-array-hofs.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/531-record-array-hofs.ts.json new file mode 100644 index 000000000..a752b9140 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/531-record-array-hofs.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/531-record-array-hofs.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/532-record-arrays-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/532-record-arrays-rc-stress.ts.json new file mode 100644 index 000000000..5b6ee7971 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/532-record-arrays-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/532-record-arrays-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/533-array-element-cycles.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/533-array-element-cycles.ts.json new file mode 100644 index 000000000..028a56954 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/533-array-element-cycles.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/533-array-element-cycles.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/534-record-width-subtyping.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/534-record-width-subtyping.ts.json new file mode 100644 index 000000000..6a939dd2e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/534-record-width-subtyping.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/534-record-width-subtyping.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/535-object-statics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/535-object-statics.ts.json new file mode 100644 index 000000000..85de0e4ba --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/535-object-statics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/535-object-statics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/536-map-seed-array.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/536-map-seed-array.ts.json new file mode 100644 index 000000000..70f41a0bd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/536-map-seed-array.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/536-map-seed-array.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/537-map-iter-drains.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/537-map-iter-drains.ts.json new file mode 100644 index 000000000..becf7afef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/537-map-iter-drains.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/537-map-iter-drains.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/538-map-set-for-of.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/538-map-set-for-of.ts.json new file mode 100644 index 000000000..30b540418 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/538-map-set-for-of.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/538-map-set-for-of.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/540-tuples-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/540-tuples-basics.ts.json new file mode 100644 index 000000000..c200ebfe8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/540-tuples-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/540-tuples-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/541-ref-array-json.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/541-ref-array-json.ts.json new file mode 100644 index 000000000..406b1fd7a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/541-ref-array-json.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/541-ref-array-json.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/542-union-element-arrays.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/542-union-element-arrays.ts.json new file mode 100644 index 000000000..2e1a03e29 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/542-union-element-arrays.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/542-union-element-arrays.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/600-closures-basic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/600-closures-basic.ts.json new file mode 100644 index 000000000..8eb07aa81 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/600-closures-basic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/600-closures-basic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/601-closures-loops.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/601-closures-loops.ts.json new file mode 100644 index 000000000..7f428adcf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/601-closures-loops.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/601-closures-loops.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/602-closures-identity-recursion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/602-closures-identity-recursion.ts.json new file mode 100644 index 000000000..b4e9581c9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/602-closures-identity-recursion.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/602-closures-identity-recursion.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/603-closures-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/603-closures-rc-stress.ts.json new file mode 100644 index 000000000..3cfc76297 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/603-closures-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/603-closures-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/604-closures-for-of.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/604-closures-for-of.ts.json new file mode 100644 index 000000000..b9b892c7e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/604-closures-for-of.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/604-closures-for-of.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/605-closures-forward-capture-tdz.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/605-closures-forward-capture-tdz.ts.json new file mode 100644 index 000000000..65094d3de --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/605-closures-forward-capture-tdz.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/605-closures-forward-capture-tdz.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/700-classes-basic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/700-classes-basic.ts.json new file mode 100644 index 000000000..5bca78b7c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/700-classes-basic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/700-classes-basic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/701-classes-composition.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/701-classes-composition.ts.json new file mode 100644 index 000000000..cef69a6d1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/701-classes-composition.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/701-classes-composition.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/702-classes-this-capture.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/702-classes-this-capture.ts.json new file mode 100644 index 000000000..6dc2411ca --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/702-classes-this-capture.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/702-classes-this-capture.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/703-classes-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/703-classes-rc-stress.ts.json new file mode 100644 index 000000000..3466d9412 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/703-classes-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/703-classes-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/710-inheritance-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/710-inheritance-basics.ts.json new file mode 100644 index 000000000..bdea1add7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/710-inheritance-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/710-inheritance-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/711-inheritance-dispatch.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/711-inheritance-dispatch.ts.json new file mode 100644 index 000000000..75db6556e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/711-inheritance-dispatch.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/711-inheritance-dispatch.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/712-inheritance-instanceof.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/712-inheritance-instanceof.ts.json new file mode 100644 index 000000000..d56b4d271 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/712-inheritance-instanceof.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/712-inheritance-instanceof.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/713-inheritance-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/713-inheritance-rc-stress.ts.json new file mode 100644 index 000000000..e06ca9f98 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/713-inheritance-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/713-inheritance-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/720-accessors-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/720-accessors-basics.ts.json new file mode 100644 index 000000000..df20d4d32 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/720-accessors-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/720-accessors-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/721-accessors-eval-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/721-accessors-eval-order.ts.json new file mode 100644 index 000000000..24ecac9b9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/721-accessors-eval-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/721-accessors-eval-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/722-accessors-inheritance.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/722-accessors-inheritance.ts.json new file mode 100644 index 000000000..81863e7ad --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/722-accessors-inheritance.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/722-accessors-inheritance.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/723-accessors-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/723-accessors-rc-stress.ts.json new file mode 100644 index 000000000..9f4f89414 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/723-accessors-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/723-accessors-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/750-cycle-closure-box.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/750-cycle-closure-box.ts.json new file mode 100644 index 000000000..df7eaf60a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/750-cycle-closure-box.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/750-cycle-closure-box.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/751-cycle-records-mutual.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/751-cycle-records-mutual.ts.json new file mode 100644 index 000000000..14b88d6f1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/751-cycle-records-mutual.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/751-cycle-records-mutual.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/752-cycle-classes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/752-cycle-classes.ts.json new file mode 100644 index 000000000..9953b2206 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/752-cycle-classes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/752-cycle-classes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/753-cycle-owned-arrays.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/753-cycle-owned-arrays.ts.json new file mode 100644 index 000000000..7aa51c1b1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/753-cycle-owned-arrays.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/753-cycle-owned-arrays.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/754-cycle-external-ref.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/754-cycle-external-ref.ts.json new file mode 100644 index 000000000..870bc48cc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/754-cycle-external-ref.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/754-cycle-external-ref.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/755-cycle-async-promise.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/755-cycle-async-promise.ts.json new file mode 100644 index 000000000..80a70a45b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/755-cycle-async-promise.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/755-cycle-async-promise.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/756-cycle-inheritance.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/756-cycle-inheritance.ts.json new file mode 100644 index 000000000..64cbe9ad2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/756-cycle-inheritance.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/756-cycle-inheritance.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/757-cycle-cross-generation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/757-cycle-cross-generation.ts.json new file mode 100644 index 000000000..0dfbc8f87 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/757-cycle-cross-generation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/757-cycle-cross-generation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/760-any-arithmetic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/760-any-arithmetic.ts.json new file mode 100644 index 000000000..aefa74eb0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/760-any-arithmetic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/760-any-arithmetic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/761-any-objects.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/761-any-objects.ts.json new file mode 100644 index 000000000..aa907b2ae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/761-any-objects.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/761-any-objects.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/762-any-boundary.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/762-any-boundary.ts.json new file mode 100644 index 000000000..978364f97 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/762-any-boundary.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/762-any-boundary.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/763-any-flow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/763-any-flow.ts.json new file mode 100644 index 000000000..21dfc68a0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/763-any-flow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/763-any-flow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/764-any-async.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/764-any-async.ts.json new file mode 100644 index 000000000..d30f824e9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/764-any-async.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/764-any-async.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/765-any-optional-chain.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/765-any-optional-chain.ts.json new file mode 100644 index 000000000..d75f3e64e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/765-any-optional-chain.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/765-any-optional-chain.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/766-any-union-boundary.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/766-any-union-boundary.ts.json new file mode 100644 index 000000000..611525143 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/766-any-union-boundary.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/766-any-union-boundary.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/767-string-literal-keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/767-string-literal-keys.ts.json new file mode 100644 index 000000000..8fbb1222a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/767-string-literal-keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/767-string-literal-keys.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/768-any-uninitialized.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/768-any-uninitialized.ts.json new file mode 100644 index 000000000..f96339f42 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/768-any-uninitialized.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/768-any-uninitialized.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/800-switch-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/800-switch-basics.ts.json new file mode 100644 index 000000000..915dc8fab --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/800-switch-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/800-switch-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/801-switch-lazy-tests.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/801-switch-lazy-tests.ts.json new file mode 100644 index 000000000..46e3531f9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/801-switch-lazy-tests.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/801-switch-lazy-tests.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/802-switch-loops.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/802-switch-loops.ts.json new file mode 100644 index 000000000..d92d25eb2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/802-switch-loops.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/802-switch-loops.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/803-switch-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/803-switch-rc-stress.ts.json new file mode 100644 index 000000000..d5715667b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/803-switch-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/803-switch-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/804-switch-braced-blocks.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/804-switch-braced-blocks.ts.json new file mode 100644 index 000000000..e1472c55a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/804-switch-braced-blocks.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/804-switch-braced-blocks.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/810-do-while.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/810-do-while.ts.json new file mode 100644 index 000000000..6e9bf75b4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/810-do-while.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/810-do-while.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/820-multi-decl.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/820-multi-decl.ts.json new file mode 100644 index 000000000..091d9a097 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/820-multi-decl.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/820-multi-decl.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/830-let-uninitialized.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/830-let-uninitialized.ts.json new file mode 100644 index 000000000..71f091bb0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/830-let-uninitialized.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/830-let-uninitialized.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/900-records-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/900-records-basics.ts.json new file mode 100644 index 000000000..a1678aa14 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/900-records-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/900-records-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/901-records-eval-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/901-records-eval-order.ts.json new file mode 100644 index 000000000..896ee67ad --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/901-records-eval-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/901-records-eval-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/902-records-functions-closures.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/902-records-functions-closures.ts.json new file mode 100644 index 000000000..0742d2c67 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/902-records-functions-closures.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/902-records-functions-closures.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/903-records-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/903-records-rc-stress.ts.json new file mode 100644 index 000000000..4d147a3f0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/903-records-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/903-records-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/904-records-optional-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/904-records-optional-fields.ts.json new file mode 100644 index 000000000..8abf49d1c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/904-records-optional-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/904-records-optional-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/905-records-optional-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/905-records-optional-rc-stress.ts.json new file mode 100644 index 000000000..0439cc65f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/905-records-optional-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/905-records-optional-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/906-records-utility-types.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/906-records-utility-types.ts.json new file mode 100644 index 000000000..9755b79d1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/906-records-utility-types.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/906-records-utility-types.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/907-records-utility-generics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/907-records-utility-generics.ts.json new file mode 100644 index 000000000..a4e30f9d3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/907-records-utility-generics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/907-records-utility-generics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/908-records-index-signatures.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/908-records-index-signatures.ts.json new file mode 100644 index 000000000..a520205ed --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/908-records-index-signatures.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/908-records-index-signatures.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/909-records-index-json.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/909-records-index-json.ts.json new file mode 100644 index 000000000..29643d747 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/909-records-index-json.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/909-records-index-json.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/910-records-index-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/910-records-index-rc-stress.ts.json new file mode 100644 index 000000000..d2e36a7e8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/910-records-index-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/910-records-index-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/911-records-index-dot-access.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/911-records-index-dot-access.ts.json new file mode 100644 index 000000000..1c8b2af19 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/911-records-index-dot-access.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/911-records-index-dot-access.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/912-unknown-slots.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/912-unknown-slots.ts.json new file mode 100644 index 000000000..9685188a1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/912-unknown-slots.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/912-unknown-slots.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/913-records-index-iteration.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/913-records-index-iteration.ts.json new file mode 100644 index 000000000..e6ad29dd4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/913-records-index-iteration.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/913-records-index-iteration.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/914-records-from-entries.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/914-records-from-entries.ts.json new file mode 100644 index 000000000..e32b4a0a6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/914-records-from-entries.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/914-records-from-entries.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/915-unknown-tostring-eq.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/915-unknown-tostring-eq.ts.json new file mode 100644 index 000000000..050e41a8d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/915-unknown-tostring-eq.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/915-unknown-tostring-eq.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/916-unknown-bytes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/916-unknown-bytes.ts.json new file mode 100644 index 000000000..89b3a24c5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/916-unknown-bytes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/916-unknown-bytes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/917-record-array-index-dot.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/917-record-array-index-dot.ts.json new file mode 100644 index 000000000..3092b6922 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/917-record-array-index-dot.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/917-record-array-index-dot.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/950-modules-basic/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/950-modules-basic/main.ts.json new file mode 100644 index 000000000..55064c5c4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/950-modules-basic/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/950-modules-basic/util.ts", + "/tests/corpus/950-modules-basic/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/951-modules-diamond/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/951-modules-diamond/main.ts.json new file mode 100644 index 000000000..c09bb4f8b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/951-modules-diamond/main.ts.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/951-modules-diamond/shared.ts", + "/tests/corpus/951-modules-diamond/a.ts", + "/tests/corpus/951-modules-diamond/b.ts", + "/tests/corpus/951-modules-diamond/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/952-modules-cross/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/952-modules-cross/main.ts.json new file mode 100644 index 000000000..2cdab35e0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/952-modules-cross/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/952-modules-cross/shapes.ts", + "/tests/corpus/952-modules-cross/ops.ts", + "/tests/corpus/952-modules-cross/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/953-modules-default/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/953-modules-default/main.ts.json new file mode 100644 index 000000000..e6a19b569 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/953-modules-default/main.ts.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/953-modules-default/colors.ts", + "/tests/corpus/953-modules-default/side.ts", + "/tests/corpus/953-modules-default/answer.ts", + "/tests/corpus/953-modules-default/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/954-modules-reexport/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/954-modules-reexport/main.ts.json new file mode 100644 index 000000000..b17cf8e47 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/954-modules-reexport/main.ts.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/954-modules-reexport/base.ts", + "/tests/corpus/954-modules-reexport/hub.ts", + "/tests/corpus/954-modules-reexport/star.ts", + "/tests/corpus/954-modules-reexport/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/957-builtins-namespace.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/957-builtins-namespace.ts.json new file mode 100644 index 000000000..e43b30916 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/957-builtins-namespace.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/957-builtins-namespace.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/960-generics-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/960-generics-basics.ts.json new file mode 100644 index 000000000..6173c507b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/960-generics-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/960-generics-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/961-generics-recursion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/961-generics-recursion.ts.json new file mode 100644 index 000000000..424c3e27f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/961-generics-recursion.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/961-generics-recursion.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/962-generics-closures.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/962-generics-closures.ts.json new file mode 100644 index 000000000..4115af14d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/962-generics-closures.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/962-generics-closures.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/963-generics-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/963-generics-modules/main.ts.json new file mode 100644 index 000000000..40f1865d8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/963-generics-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/963-generics-modules/util.ts", + "/tests/corpus/963-generics-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/964-generics-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/964-generics-rc-stress.ts.json new file mode 100644 index 000000000..a2265ad89 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/964-generics-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/964-generics-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/965-generics-async.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/965-generics-async.ts.json new file mode 100644 index 000000000..2182b3032 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/965-generics-async.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/965-generics-async.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/965-unions-retag.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/965-unions-retag.ts.json new file mode 100644 index 000000000..556de3feb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/965-unions-retag.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/965-unions-retag.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/966-unions-retag-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/966-unions-retag-rc-stress.ts.json new file mode 100644 index 000000000..ee9e0c128 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/966-unions-retag-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/966-unions-retag-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/967-record-field-widening.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/967-record-field-widening.ts.json new file mode 100644 index 000000000..f208f938f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/967-record-field-widening.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/967-record-field-widening.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/968-jsval-lift.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/968-jsval-lift.ts.json new file mode 100644 index 000000000..6d8385734 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/968-jsval-lift.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/968-jsval-lift.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/969-unions-arm-matrix.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/969-unions-arm-matrix.ts.json new file mode 100644 index 000000000..bec1aa2a5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/969-unions-arm-matrix.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/969-unions-arm-matrix.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/970-unions-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/970-unions-basics.ts.json new file mode 100644 index 000000000..8231513b3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/970-unions-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/970-unions-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/971-unions-switch.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/971-unions-switch.ts.json new file mode 100644 index 000000000..362e46f46 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/971-unions-switch.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/971-unions-switch.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/972-unions-nested.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/972-unions-nested.ts.json new file mode 100644 index 000000000..654c47662 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/972-unions-nested.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/972-unions-nested.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/973-unions-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/973-unions-rc-stress.ts.json new file mode 100644 index 000000000..70394dc25 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/973-unions-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/973-unions-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/974-unions-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/974-unions-modules/main.ts.json new file mode 100644 index 000000000..8c297f028 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/974-unions-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/974-unions-modules/result.ts", + "/tests/corpus/974-unions-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/975-unions-undefined.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/975-unions-undefined.ts.json new file mode 100644 index 000000000..075c6e044 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/975-unions-undefined.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/975-unions-undefined.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/976-unions-null.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/976-unions-null.ts.json new file mode 100644 index 000000000..67e4c171a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/976-unions-null.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/976-unions-null.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/977-unions-unit-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/977-unions-unit-rc-stress.ts.json new file mode 100644 index 000000000..47c18c5db --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/977-unions-unit-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/977-unions-unit-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/978-unions-nullish.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/978-unions-nullish.ts.json new file mode 100644 index 000000000..679886922 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/978-unions-nullish.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/978-unions-nullish.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/979-unions-optional-chaining.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/979-unions-optional-chaining.ts.json new file mode 100644 index 000000000..27354bdf2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/979-unions-optional-chaining.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/979-unions-optional-chaining.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/980-exceptions-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/980-exceptions-basics.ts.json new file mode 100644 index 000000000..7cfee41cf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/980-exceptions-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/980-exceptions-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/981-exceptions-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/981-exceptions-values.ts.json new file mode 100644 index 000000000..9088c0fc7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/981-exceptions-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/981-exceptions-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/982-exceptions-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/982-exceptions-rc-stress.ts.json new file mode 100644 index 000000000..c7fc46825 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/982-exceptions-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/982-exceptions-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/983-exceptions-control-flow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/983-exceptions-control-flow.ts.json new file mode 100644 index 000000000..577a80eab --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/983-exceptions-control-flow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/983-exceptions-control-flow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/984-exceptions-finally.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/984-exceptions-finally.ts.json new file mode 100644 index 000000000..58b823803 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/984-exceptions-finally.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/984-exceptions-finally.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/985-exceptions-call-chains.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/985-exceptions-call-chains.ts.json new file mode 100644 index 000000000..44f8396e9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/985-exceptions-call-chains.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/985-exceptions-call-chains.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/986-exceptions-uncaught.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/986-exceptions-uncaught.ts.json new file mode 100644 index 000000000..55c89b11e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/986-exceptions-uncaught.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/986-exceptions-uncaught.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/987-exceptions-result-unions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/987-exceptions-result-unions.ts.json new file mode 100644 index 000000000..ed97462dd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/987-exceptions-result-unions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/987-exceptions-result-unions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/990-process-basics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/990-process-basics.ts.json new file mode 100644 index 000000000..5292af67e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/990-process-basics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/990-process-basics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/991-process-exit.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/991-process-exit.ts.json new file mode 100644 index 000000000..a608b149c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/991-process-exit.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/991-process-exit.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/992-fs-roundtrip.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/992-fs-roundtrip.ts.json new file mode 100644 index 000000000..90cf0d82d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/992-fs-roundtrip.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/992-fs-roundtrip.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/993-fs-readdir.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/993-fs-readdir.ts.json new file mode 100644 index 000000000..98f322885 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/993-fs-readdir.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/993-fs-readdir.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/994-fs-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/994-fs-errors.ts.json new file mode 100644 index 000000000..1d53dfaa7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/994-fs-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/994-fs-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/995-fs-uncaught.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/995-fs-uncaught.ts.json new file mode 100644 index 000000000..20a509d17 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/995-fs-uncaught.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/995-fs-uncaught.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/996-fs-rc-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/996-fs-rc-stress.ts.json new file mode 100644 index 000000000..db1c41f12 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/996-fs-rc-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/996-fs-rc-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/997-fs-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/997-fs-modules/main.ts.json new file mode 100644 index 000000000..7e8b7cf96 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/997-fs-modules/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/997-fs-modules/store.ts", + "/tests/corpus/997-fs-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/998-process-env.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/998-process-env.ts.json new file mode 100644 index 000000000..9e9662fe0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/998-process-env.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/998-process-env.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/abstract-property-dispatch.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/abstract-property-dispatch.ts.json new file mode 100644 index 000000000..8e06f0488 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/abstract-property-dispatch.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/abstract-property-dispatch.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/arguments-arrow-capture.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/arguments-arrow-capture.mjs.json new file mode 100644 index 000000000..08f36dc25 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/arguments-arrow-capture.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/arguments-arrow-capture.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/arguments-reexport/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/arguments-reexport/main.ts.json new file mode 100644 index 000000000..9cf10295f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/arguments-reexport/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/arguments-reexport/core.js", + "/tests/corpus/arguments-reexport/barrel.js", + "/tests/corpus/arguments-reexport/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-exits.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-exits.ts.json new file mode 100644 index 000000000..766da6446 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-exits.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-argument-lifetimes-exits.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-mutation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-mutation.ts.json new file mode 100644 index 000000000..015c5a41a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-mutation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-argument-lifetimes-mutation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-strings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-strings.ts.json new file mode 100644 index 000000000..f1036cd94 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-strings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-argument-lifetimes-strings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-values.ts.json new file mode 100644 index 000000000..322cfe10e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-argument-lifetimes-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-argument-lifetimes-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-buffer-conversions.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-buffer-conversions.js.json new file mode 100644 index 000000000..edd5e8a3c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-buffer-conversions.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-buffer-conversions.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-buffer-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-buffer-storage.ts.json new file mode 100644 index 000000000..b6c13e6dc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-buffer-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-buffer-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-checked-callback-results.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-checked-callback-results.mjs.json new file mode 100644 index 000000000..caa97bdae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-checked-callback-results.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-checked-callback-results.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-checked-constructor.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-checked-constructor.js.json new file mode 100644 index 000000000..e77222618 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-checked-constructor.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-checked-constructor.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-concat-widening.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-concat-widening.ts.json new file mode 100644 index 000000000..abf3a084d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-concat-widening.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-concat-widening.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-fill-unit-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-fill-unit-values.ts.json new file mode 100644 index 000000000..d18d5c2fd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-fill-unit-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-fill-unit-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-from-checked.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-from-checked.js.json new file mode 100644 index 000000000..7aa9a99b6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-from-checked.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-from-checked.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-from-value.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-from-value.mjs.json new file mode 100644 index 000000000..cc4f1d34f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-from-value.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-from-value.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-isarray-value/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-isarray-value/main.js.json new file mode 100644 index 000000000..c7fb0d3ef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-isarray-value/main.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-isarray-value/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-numeric-own-keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-numeric-own-keys.ts.json new file mode 100644 index 000000000..9e76ee74a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-numeric-own-keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-numeric-own-keys.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-optional-number-write-index.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-optional-number-write-index.ts.json new file mode 100644 index 000000000..d03f1046c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-optional-number-write-index.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-optional-number-write-index.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-primitive-ordering.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-primitive-ordering.ts.json new file mode 100644 index 000000000..f62ef473a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-primitive-ordering.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-primitive-ordering.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-read-helper-effects.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-read-helper-effects.ts.json new file mode 100644 index 000000000..c50879b6f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-read-helper-effects.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-read-helper-effects.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-refined-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-refined-storage.ts.json new file mode 100644 index 000000000..5d269673c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-refined-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-refined-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-sort-runs.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-sort-runs.ts.json new file mode 100644 index 000000000..08d4b3fe5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-sort-runs.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-sort-runs.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-sort-runtime-comparator.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-sort-runtime-comparator.ts.json new file mode 100644 index 000000000..129e6bcb4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-sort-runtime-comparator.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-sort-runtime-comparator.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-sort-unknown-comparator.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-sort-unknown-comparator.ts.json new file mode 100644 index 000000000..f28d8c4ce --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-sort-unknown-comparator.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-sort-unknown-comparator.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-storage-transitions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-storage-transitions.ts.json new file mode 100644 index 000000000..6b646c9d8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-storage-transitions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-storage-transitions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-truncate-reuse.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-truncate-reuse.ts.json new file mode 100644 index 000000000..5b5af9c3f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/array-truncate-reuse.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/array-truncate-reuse.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/async-backend-factory.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/async-backend-factory.mjs.json new file mode 100644 index 000000000..4cb031580 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/async-backend-factory.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/async-backend-factory.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/async-local-typed-results.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/async-local-typed-results.ts.json new file mode 100644 index 000000000..463dcab89 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/async-local-typed-results.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/async-local-typed-results.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/atomics-integer-operations.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/atomics-integer-operations.ts.json new file mode 100644 index 000000000..3fb6f7116 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/atomics-integer-operations.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/atomics-integer-operations.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/bigint-checked-casts.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/bigint-checked-casts.ts.json new file mode 100644 index 000000000..d4010be90 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/bigint-checked-casts.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/bigint-checked-casts.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/bigint-checked-storage.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/bigint-checked-storage.js.json new file mode 100644 index 000000000..76690f06a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/bigint-checked-storage.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/bigint-checked-storage.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/bigint-union-conversion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/bigint-union-conversion.ts.json new file mode 100644 index 000000000..8c5cde7f9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/bigint-union-conversion.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/bigint-union-conversion.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/boxed-error-rethrows.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/boxed-error-rethrows.mjs.json new file mode 100644 index 000000000..d772a8606 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/boxed-error-rethrows.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/boxed-error-rethrows.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/buffer-codec-boundaries.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/buffer-codec-boundaries.ts.json new file mode 100644 index 000000000..de9030c3e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/buffer-codec-boundaries.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/buffer-codec-boundaries.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/buffer-primitive-predicate.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/buffer-primitive-predicate.ts.json new file mode 100644 index 000000000..dfb3c19b6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/buffer-primitive-predicate.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/buffer-primitive-predicate.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/builtin-prototype-method-values.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/builtin-prototype-method-values.mjs.json new file mode 100644 index 000000000..13c13e788 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/builtin-prototype-method-values.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/builtin-prototype-method-values.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/byte-loop-bounds.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/byte-loop-bounds.ts.json new file mode 100644 index 000000000..1b779fdc7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/byte-loop-bounds.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/byte-loop-bounds.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/byte-number-pipeline.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/byte-number-pipeline.ts.json new file mode 100644 index 000000000..6a2160a6e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/byte-number-pipeline.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/byte-number-pipeline.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/byte-record-windows.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/byte-record-windows.ts.json new file mode 100644 index 000000000..0cb8feebc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/byte-record-windows.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/byte-record-windows.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-argument-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-argument-order.ts.json new file mode 100644 index 000000000..1fa7382cc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-argument-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/call-lifetimes-argument-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-control-flow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-control-flow.ts.json new file mode 100644 index 000000000..6adc36e49 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-control-flow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/call-lifetimes-control-flow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-owned-boundaries.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-owned-boundaries.ts.json new file mode 100644 index 000000000..d75a39369 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-owned-boundaries.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/call-lifetimes-owned-boundaries.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-projections.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-projections.ts.json new file mode 100644 index 000000000..d4d9420a4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-projections.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/call-lifetimes-projections.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-union-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-union-values.ts.json new file mode 100644 index 000000000..965f126c9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-union-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/call-lifetimes-union-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-virtual-optionals.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-virtual-optionals.ts.json new file mode 100644 index 000000000..528b75448 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/call-lifetimes-virtual-optionals.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/call-lifetimes-virtual-optionals.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-module-members.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-module-members.mjs.json new file mode 100644 index 000000000..8cfc856ce --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-module-members.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/callable-module-members.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-properties.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-properties.mjs.json new file mode 100644 index 000000000..451e08165 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-properties.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/callable-properties.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-property-cycles.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-property-cycles.js.json new file mode 100644 index 000000000..2a4c55db5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-property-cycles.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/callable-property-cycles.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-reexport/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-reexport/main.ts.json new file mode 100644 index 000000000..47b4e9c5c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/callable-reexport/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/callable-reexport/core.js", + "/tests/corpus/callable-reexport/barrel.js", + "/tests/corpus/callable-reexport/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/captured-class-refinement.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/captured-class-refinement.ts.json new file mode 100644 index 000000000..b0f950504 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/captured-class-refinement.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/captured-class-refinement.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/catch-capture.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/catch-capture.ts.json new file mode 100644 index 000000000..9673cacbc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/catch-capture.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/catch-capture.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/caught-class-identity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/caught-class-identity.ts.json new file mode 100644 index 000000000..e1fdc5809 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/caught-class-identity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/caught-class-identity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/caught-standalone-class.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/caught-standalone-class.ts.json new file mode 100644 index 000000000..e12041fe0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/caught-standalone-class.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/caught-standalone-class.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/caught-system-error-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/caught-system-error-fields.ts.json new file mode 100644 index 000000000..03067d2a0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/caught-system-error-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/caught-system-error-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-addition.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-addition.js.json new file mode 100644 index 000000000..9f8791d4a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-addition.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-addition.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-any-addition.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-any-addition.ts.json new file mode 100644 index 000000000..f5eb3d491 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-any-addition.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-any-addition.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-array-assignment.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-array-assignment.ts.json new file mode 100644 index 000000000..b6cbd8ddf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-array-assignment.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-array-assignment.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-array-flat/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-array-flat/main.ts.json new file mode 100644 index 000000000..e4a210f81 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-array-flat/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/checked-array-flat/operations.mjs", + "/tests/corpus/checked-array-flat/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-bitwise/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-bitwise/main.js.json new file mode 100644 index 000000000..a1c38cc25 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-bitwise/main.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-bitwise/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-builder-cycles.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-builder-cycles.js.json new file mode 100644 index 000000000..6aaf5b2ef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-builder-cycles.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-builder-cycles.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-byte-storage/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-byte-storage/main.ts.json new file mode 100644 index 000000000..036bcb60e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-byte-storage/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/checked-byte-storage/values.js", + "/tests/corpus/checked-byte-storage/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-callback-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-callback-options.ts.json new file mode 100644 index 000000000..5142bfb86 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-callback-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-callback-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-class-descriptors.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-class-descriptors.mjs.json new file mode 100644 index 000000000..108ac5605 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-class-descriptors.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-class-descriptors.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-class-factory.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-class-factory.mjs.json new file mode 100644 index 000000000..896112695 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-class-factory.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-class-factory.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-collection-iterators.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-collection-iterators.ts.json new file mode 100644 index 000000000..0ed58dcac --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-collection-iterators.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-collection-iterators.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-collection-symbol-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-collection-symbol-methods.ts.json new file mode 100644 index 000000000..8b8a03f1b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-collection-symbol-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-collection-symbol-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-dispatch-input-lifetimes.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-dispatch-input-lifetimes.js.json new file mode 100644 index 000000000..4b460b807 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-dispatch-input-lifetimes.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-dispatch-input-lifetimes.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-increment/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-increment/main.js.json new file mode 100644 index 000000000..2a4aeadd8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-increment/main.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-increment/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-inherited-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-inherited-fields.ts.json new file mode 100644 index 000000000..999ea9dd0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-inherited-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-inherited-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-iterator-consumption.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-iterator-consumption.js.json new file mode 100644 index 000000000..1d4c16685 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-iterator-consumption.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-iterator-consumption.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-numeric-arithmetic.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-numeric-arithmetic.js.json new file mode 100644 index 000000000..e46ab5c9b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-numeric-arithmetic.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-numeric-arithmetic.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-object-module-alias.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-object-module-alias.js.json new file mode 100644 index 000000000..5580db6d2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-object-module-alias.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-object-module-alias.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-optional-calls.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-optional-calls.mjs.json new file mode 100644 index 000000000..8222c21e8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-optional-calls.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-optional-calls.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-promise-recovery.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-promise-recovery.ts.json new file mode 100644 index 000000000..8e8cabff4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-promise-recovery.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-promise-recovery.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-proxy-callback/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-proxy-callback/main.ts.json new file mode 100644 index 000000000..11bf23e0b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-proxy-callback/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/checked-proxy-callback/operations.mjs", + "/tests/corpus/checked-proxy-callback/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-record-constructor.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-record-constructor.ts.json new file mode 100644 index 000000000..6c7353f71 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-record-constructor.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-record-constructor.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-renderer-defaults.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-renderer-defaults.js.json new file mode 100644 index 000000000..edba94b8c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-renderer-defaults.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-renderer-defaults.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-rest-function-adapters.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-rest-function-adapters.js.json new file mode 100644 index 000000000..cb266d222 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-rest-function-adapters.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-rest-function-adapters.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-storage-transitions.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-storage-transitions.js.json new file mode 100644 index 000000000..0fa5d764f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-storage-transitions.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-storage-transitions.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-symbol-array.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-symbol-array.ts.json new file mode 100644 index 000000000..fc126b016 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-symbol-array.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-symbol-array.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-value-input-lifetimes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-value-input-lifetimes.ts.json new file mode 100644 index 000000000..84f4a0763 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/checked-value-input-lifetimes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/checked-value-input-lifetimes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-accessor-returned-function.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-accessor-returned-function.js.json new file mode 100644 index 000000000..fd7917fc0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-accessor-returned-function.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-accessor-returned-function.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-array-optional-return.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-array-optional-return.ts.json new file mode 100644 index 000000000..9602ea765 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-array-optional-return.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-array-optional-return.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-bracket-method-calls.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-bracket-method-calls.js.json new file mode 100644 index 000000000..50bdf6523 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-bracket-method-calls.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-bracket-method-calls.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-brand-overload.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-brand-overload.js.json new file mode 100644 index 000000000..65c996a30 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-brand-overload.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-brand-overload.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-callback-replacement.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-callback-replacement.js.json new file mode 100644 index 000000000..11d3e9576 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-callback-replacement.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-callback-replacement.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-callback-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-callback-storage.ts.json new file mode 100644 index 000000000..2df556aaa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-callback-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-callback-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-checked-composites.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-checked-composites.ts.json new file mode 100644 index 000000000..dbd577f66 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-checked-composites.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-checked-composites.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-checked-upcast.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-checked-upcast.ts.json new file mode 100644 index 000000000..5d3eabf2e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-checked-upcast.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-checked-upcast.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-collection-insertion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-collection-insertion.ts.json new file mode 100644 index 000000000..ff0796d10 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-collection-insertion.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-collection-insertion.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-computed-presence.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-computed-presence.ts.json new file mode 100644 index 000000000..dd7a6bea7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-computed-presence.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-computed-presence.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-computed-symbols.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-computed-symbols.js.json new file mode 100644 index 000000000..e8d70d447 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-computed-symbols.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-computed-symbols.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-covariant-returns.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-covariant-returns.ts.json new file mode 100644 index 000000000..a33014452 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-covariant-returns.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-covariant-returns.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-curried-factory.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-curried-factory.mjs.json new file mode 100644 index 000000000..feccfc017 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-curried-factory.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-curried-factory.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-data-descriptors.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-data-descriptors.js.json new file mode 100644 index 000000000..490a502b8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-data-descriptors.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-data-descriptors.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-inherited-statics.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-inherited-statics.mjs.json new file mode 100644 index 000000000..c5f284879 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-inherited-statics.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-factory-inherited-statics.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-parameter-base.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-parameter-base.mjs.json new file mode 100644 index 000000000..8a6973f47 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-parameter-base.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-factory-parameter-base.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-record-base.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-record-base.mjs.json new file mode 100644 index 000000000..88511ef88 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-record-base.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-factory-record-base.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-recursive-statics.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-recursive-statics.mjs.json new file mode 100644 index 000000000..e13d1be0c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-recursive-statics.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-factory-recursive-statics.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-static-members.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-static-members.mjs.json new file mode 100644 index 000000000..2b437d7af --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-factory-static-members.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-factory-static-members.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-function-base/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-function-base/main.js.json new file mode 100644 index 000000000..ab714a88d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-function-base/main.js.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/class-function-base/base.js", + "/tests/corpus/class-function-base/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-instance-constructor.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-instance-constructor.js.json new file mode 100644 index 000000000..452dfc6d3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-instance-constructor.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-instance-constructor.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-interface-protocols.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-interface-protocols.ts.json new file mode 100644 index 000000000..ada2b3d3e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-interface-protocols.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-interface-protocols.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-interface-refinements.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-interface-refinements.ts.json new file mode 100644 index 000000000..0738ce402 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-interface-refinements.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-interface-refinements.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-json-checked.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-json-checked.ts.json new file mode 100644 index 000000000..72739198a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-json-checked.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-json-checked.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-local-function-base.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-local-function-base.mjs.json new file mode 100644 index 000000000..637dfd9d2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-local-function-base.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-local-function-base.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-method-spreads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-method-spreads.ts.json new file mode 100644 index 000000000..f84e29cbd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-method-spreads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-method-spreads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-narrowed-views.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-narrowed-views.ts.json new file mode 100644 index 000000000..067153585 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-narrowed-views.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-narrowed-views.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-property-call-values.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-property-call-values.mjs.json new file mode 100644 index 000000000..c3d0e6663 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-property-call-values.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-property-call-values.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-prototype-data.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-prototype-data.js.json new file mode 100644 index 000000000..d05b5ba8f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-prototype-data.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-prototype-data.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-prototype-descriptor-copy.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-prototype-descriptor-copy.mjs.json new file mode 100644 index 000000000..b5c967d93 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-prototype-descriptor-copy.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-prototype-descriptor-copy.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-specialized-computed-base.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-specialized-computed-base.mjs.json new file mode 100644 index 000000000..f4805bb36 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-specialized-computed-base.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-specialized-computed-base.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-static-data.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-static-data.js.json new file mode 100644 index 000000000..353b04cc4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-static-data.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-static-data.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-subclass-assertions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-subclass-assertions.ts.json new file mode 100644 index 000000000..583fa9373 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-subclass-assertions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-subclass-assertions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-super-surplus-spread.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-super-surplus-spread.mjs.json new file mode 100644 index 000000000..b4cd04338 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-super-surplus-spread.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-super-surplus-spread.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-symbol-accessors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-symbol-accessors.ts.json new file mode 100644 index 000000000..1b2b32c30 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-symbol-accessors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-symbol-accessors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-symbol-cache.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-symbol-cache.mjs.json new file mode 100644 index 000000000..0e17a2265 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-symbol-cache.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-symbol-cache.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-value-constructor-exceptions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-value-constructor-exceptions.ts.json new file mode 100644 index 000000000..d2f2a5d19 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/class-value-constructor-exceptions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/class-value-constructor-exceptions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/closure-nullable-union-return.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/closure-nullable-union-return.ts.json new file mode 100644 index 000000000..ef6449951 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/closure-nullable-union-return.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/closure-nullable-union-return.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/closure-union-locals.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/closure-union-locals.ts.json new file mode 100644 index 000000000..6fad110ef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/closure-union-locals.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/closure-union-locals.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-cycles.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-cycles.ts.json new file mode 100644 index 000000000..8c058ae10 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-cycles.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/collection-array-cycles.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-maps.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-maps.ts.json new file mode 100644 index 000000000..e7dd494e2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-maps.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/collection-array-maps.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-missing.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-missing.ts.json new file mode 100644 index 000000000..89199d59b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-missing.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/collection-array-missing.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-sets.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-sets.ts.json new file mode 100644 index 000000000..d3e57a3dd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-array-sets.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/collection-array-sets.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-copy-identities.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-copy-identities.ts.json new file mode 100644 index 000000000..a3bcf1dd6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-copy-identities.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/collection-copy-identities.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-data-unions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-data-unions.ts.json new file mode 100644 index 000000000..14f473f38 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-data-unions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/collection-data-unions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion-mappers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion-mappers.ts.json new file mode 100644 index 000000000..12f865e5e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion-mappers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/collection-ingestion-mappers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion-protocol/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion-protocol/main.ts.json new file mode 100644 index 000000000..e503f0d3e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion-protocol/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/collection-ingestion-protocol/source.js", + "/tests/corpus/collection-ingestion-protocol/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion-references.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion-references.ts.json new file mode 100644 index 000000000..d5b961324 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion-references.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/collection-ingestion-references.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion.ts.json new file mode 100644 index 000000000..cf3a5d214 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-ingestion.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/collection-ingestion.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-storage-copies.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-storage-copies.ts.json new file mode 100644 index 000000000..c4ad02d8b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-storage-copies.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/collection-storage-copies.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-value-keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-value-keys.ts.json new file mode 100644 index 000000000..1625b4831 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/collection-value-keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/collection-value-keys.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/compound-field-receivers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/compound-field-receivers.ts.json new file mode 100644 index 000000000..e20d71f75 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/compound-field-receivers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/compound-field-receivers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/compound-presence-guards.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/compound-presence-guards.ts.json new file mode 100644 index 000000000..3c0ee08a7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/compound-presence-guards.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/compound-presence-guards.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/conditional-tuple-destructuring.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/conditional-tuple-destructuring.ts.json new file mode 100644 index 000000000..910b57ba1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/conditional-tuple-destructuring.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/conditional-tuple-destructuring.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/console-imports.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/console-imports.cjs.json new file mode 100644 index 000000000..1334ee0b6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/console-imports.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/console-imports.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/console-native-value.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/console-native-value.js.json new file mode 100644 index 000000000..89d581c80 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/console-native-value.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/console-native-value.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/const-enum-module-cycle/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/const-enum-module-cycle/main.ts.json new file mode 100644 index 000000000..f503dd395 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/const-enum-module-cycle/main.ts.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/const-enum-module-cycle/flags.ts", + "/tests/corpus/const-enum-module-cycle/rules.ts", + "/tests/corpus/const-enum-module-cycle/limits.ts", + "/tests/corpus/const-enum-module-cycle/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/constant-callback-dispatch.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/constant-callback-dispatch.ts.json new file mode 100644 index 000000000..9c479bbe1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/constant-callback-dispatch.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/constant-callback-dispatch.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/constant-module-globals/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/constant-module-globals/main.ts.json new file mode 100644 index 000000000..d98782695 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/constant-module-globals/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/constant-module-globals/consts.ts", + "/tests/corpus/constant-module-globals/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/constant-number-remainders.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/constant-number-remainders.ts.json new file mode 100644 index 000000000..aa14d30e2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/constant-number-remainders.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/constant-number-remainders.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/contextual-array-union-write.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/contextual-array-union-write.ts.json new file mode 100644 index 000000000..93d086b5b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/contextual-array-union-write.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/contextual-array-union-write.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/contextual-return-layouts.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/contextual-return-layouts.ts.json new file mode 100644 index 000000000..c0158b24a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/contextual-return-layouts.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/contextual-return-layouts.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/counted-loop-numbers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/counted-loop-numbers.ts.json new file mode 100644 index 000000000..815ddfce1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/counted-loop-numbers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/counted-loop-numbers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/counted-loop-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/counted-loop-storage.ts.json new file mode 100644 index 000000000..df4d5a6e6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/counted-loop-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/counted-loop-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/crypto-hash-optional-input.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/crypto-hash-optional-input.ts.json new file mode 100644 index 000000000..4c23c130a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/crypto-hash-optional-input.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/crypto-hash-optional-input.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/cycle-generations-long-lived.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/cycle-generations-long-lived.ts.json new file mode 100644 index 000000000..bdb6cadbc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/cycle-generations-long-lived.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/cycle-generations-long-lived.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/cycle-growth-yield.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/cycle-growth-yield.ts.json new file mode 100644 index 000000000..2801d69d3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/cycle-growth-yield.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/cycle-growth-yield.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/date-checked-native.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/date-checked-native.js.json new file mode 100644 index 000000000..8d09be148 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/date-checked-native.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/date-checked-native.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/declared-index-spread.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/declared-index-spread.ts.json new file mode 100644 index 000000000..1e64b157e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/declared-index-spread.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/declared-index-spread.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/deep-reference-teardown.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/deep-reference-teardown.ts.json new file mode 100644 index 000000000..3142a05cb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/deep-reference-teardown.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/deep-reference-teardown.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/default-undefined-parameters.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/default-undefined-parameters.ts.json new file mode 100644 index 000000000..9d10a41ae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/default-undefined-parameters.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/default-undefined-parameters.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/deferred-field-updates.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/deferred-field-updates.ts.json new file mode 100644 index 000000000..d6a4d8659 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/deferred-field-updates.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/deferred-field-updates.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/deferred-registry-many.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/deferred-registry-many.ts.json new file mode 100644 index 000000000..3459568e3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/deferred-registry-many.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/deferred-registry-many.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/derived-numeric-updates.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/derived-numeric-updates.ts.json new file mode 100644 index 000000000..afaee8f9c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/derived-numeric-updates.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/derived-numeric-updates.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/destructure-call-assignment.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/destructure-call-assignment.js.json new file mode 100644 index 000000000..8a53c3c2a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/destructure-call-assignment.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/destructure-call-assignment.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/destructure-inferred-row-defaults.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/destructure-inferred-row-defaults.js.json new file mode 100644 index 000000000..33d7dd2f4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/destructure-inferred-row-defaults.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/destructure-inferred-row-defaults.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/destructure-union-arrays.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/destructure-union-arrays.ts.json new file mode 100644 index 000000000..f3c24ec5f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/destructure-union-arrays.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/destructure-union-arrays.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/dynamic-function-descriptors.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/dynamic-function-descriptors.js.json new file mode 100644 index 000000000..dce953272 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/dynamic-function-descriptors.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/dynamic-function-descriptors.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-cause-writes.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-cause-writes.js.json new file mode 100644 index 000000000..d32669f0b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-cause-writes.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/error-cause-writes.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-inherited-message.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-inherited-message.mjs.json new file mode 100644 index 000000000..9b874380e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-inherited-message.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/error-inherited-message.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-inherited-name.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-inherited-name.mjs.json new file mode 100644 index 000000000..50124c776 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-inherited-name.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/error-inherited-name.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-property-writes.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-property-writes.mjs.json new file mode 100644 index 000000000..891bc0904 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-property-writes.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/error-property-writes.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-prototype-tostring.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-prototype-tostring.js.json new file mode 100644 index 000000000..51b210774 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-prototype-tostring.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/error-prototype-tostring.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-stack-frames.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-stack-frames.ts.json new file mode 100644 index 000000000..689d27e42 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-stack-frames.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/error-stack-frames.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-stack-limit.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-stack-limit.ts.json new file mode 100644 index 000000000..832c2be66 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-stack-limit.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/error-stack-limit.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-tostring-overrides.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-tostring-overrides.ts.json new file mode 100644 index 000000000..f72ce1dba --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-tostring-overrides.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/error-tostring-overrides.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-values-inspect.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-values-inspect.ts.json new file mode 100644 index 000000000..abbc928ae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/error-values-inspect.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/error-values-inspect.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/exact-index-round-trip.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/exact-index-round-trip.ts.json new file mode 100644 index 000000000..5c73ca3b2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/exact-index-round-trip.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/exact-index-round-trip.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/expression-runtime-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/expression-runtime-values.ts.json new file mode 100644 index 000000000..53a027e8a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/expression-runtime-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/expression-runtime-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fiber-switch-stress.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fiber-switch-stress.ts.json new file mode 100644 index 000000000..c40059393 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fiber-switch-stress.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/fiber-switch-stress.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fiberless-async-ordering.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fiberless-async-ordering.ts.json new file mode 100644 index 000000000..8b8c9dfad --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fiberless-async-ordering.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/fiberless-async-ordering.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fiberless-async-unhandled.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fiberless-async-unhandled.ts.json new file mode 100644 index 000000000..89af63ed1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fiberless-async-unhandled.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/fiberless-async-unhandled.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/field-assignment-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/field-assignment-values.ts.json new file mode 100644 index 000000000..779e94ea0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/field-assignment-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/field-assignment-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/file-handle-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/file-handle-values.ts.json new file mode 100644 index 000000000..9d750286c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/file-handle-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/file-handle-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/file-read-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/file-read-storage.ts.json new file mode 100644 index 000000000..d76483304 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/file-read-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/file-read-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/file-url-percent-decoding.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/file-url-percent-decoding.ts.json new file mode 100644 index 000000000..d75c0b5f1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/file-url-percent-decoding.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/file-url-percent-decoding.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/final-field-borrows.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/final-field-borrows.ts.json new file mode 100644 index 000000000..63e4b8ba6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/final-field-borrows.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/final-field-borrows.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-multiple-bindings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-multiple-bindings.ts.json new file mode 100644 index 000000000..b36ca1a6e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-multiple-bindings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/for-multiple-bindings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-multiple-lexical-bindings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-multiple-lexical-bindings.ts.json new file mode 100644 index 000000000..0ee2078f4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-multiple-lexical-bindings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/for-multiple-lexical-bindings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-of-checked-iterator.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-of-checked-iterator.js.json new file mode 100644 index 000000000..5781669b3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-of-checked-iterator.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/for-of-checked-iterator.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-of-subclass-elements.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-of-subclass-elements.ts.json new file mode 100644 index 000000000..b9cd1be44 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/for-of-subclass-elements.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/for-of-subclass-elements.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/forward-generic-signatures.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/forward-generic-signatures.ts.json new file mode 100644 index 000000000..a4716e214 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/forward-generic-signatures.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/forward-generic-signatures.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fresh-array-union-layout.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fresh-array-union-layout.js.json new file mode 100644 index 000000000..a9a645c22 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fresh-array-union-layout.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/fresh-array-union-layout.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/frozen-checked-dictionaries.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/frozen-checked-dictionaries.mjs.json new file mode 100644 index 000000000..88314f686 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/frozen-checked-dictionaries.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/frozen-checked-dictionaries.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-native-realpath.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-native-realpath.ts.json new file mode 100644 index 000000000..b3df06eac --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-native-realpath.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/fs-native-realpath.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-read-encodings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-read-encodings.ts.json new file mode 100644 index 000000000..24584246d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-read-encodings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/fs-read-encodings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-remove-readonly.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-remove-readonly.ts.json new file mode 100644 index 000000000..d62e7e592 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-remove-readonly.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/fs-remove-readonly.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-write-string-bytes-union.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-write-string-bytes-union.ts.json new file mode 100644 index 000000000..9fea6d012 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/fs-write-string-bytes-union.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/fs-write-string-bytes-union.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-apply-value.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-apply-value.mjs.json new file mode 100644 index 000000000..3911eab16 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-apply-value.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/function-apply-value.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-constructor-global.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-constructor-global.mjs.json new file mode 100644 index 000000000..7c280af97 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-constructor-global.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/function-constructor-global.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-constructor-kinds/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-constructor-kinds/main.js.json new file mode 100644 index 000000000..feb5211ef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-constructor-kinds/main.js.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/function-constructor-kinds/consumer.js", + "/tests/corpus/function-constructor-kinds/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-custom-prototype.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-custom-prototype.js.json new file mode 100644 index 000000000..74412b3b7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-custom-prototype.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/function-custom-prototype.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-custom-to-string.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-custom-to-string.mjs.json new file mode 100644 index 000000000..a5cbedeab --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-custom-to-string.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/function-custom-to-string.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-object-assign.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-object-assign.js.json new file mode 100644 index 000000000..b16ef9774 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-object-assign.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/function-object-assign.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-own-prototype/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-own-prototype/main.js.json new file mode 100644 index 000000000..71a2be54c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/function-own-prototype/main.js.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/function-own-prototype/consumer.js", + "/tests/corpus/function-own-prototype/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-checked-protocol.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-checked-protocol.ts.json new file mode 100644 index 000000000..dad4397fa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-checked-protocol.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/generator-checked-protocol.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-checked-return.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-checked-return.js.json new file mode 100644 index 000000000..609854f51 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-checked-return.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/generator-checked-return.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-custom-delegation/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-custom-delegation/main.ts.json new file mode 100644 index 000000000..2a46a9d26 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-custom-delegation/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/generator-custom-delegation/iterators.js", + "/tests/corpus/generator-custom-delegation/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-default-return-pattern.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-default-return-pattern.ts.json new file mode 100644 index 000000000..f10826d97 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-default-return-pattern.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/generator-default-return-pattern.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-delegation-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-delegation-values.ts.json new file mode 100644 index 000000000..232a565c9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-delegation-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/generator-delegation-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-inferred-date.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-inferred-date.js.json new file mode 100644 index 000000000..f00176daf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-inferred-date.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/generator-inferred-date.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-mixed-checked-channels.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-mixed-checked-channels.ts.json new file mode 100644 index 000000000..79f4f2acb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-mixed-checked-channels.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/generator-mixed-checked-channels.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-untyped-consumer/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-untyped-consumer/main.ts.json new file mode 100644 index 000000000..a13f6fbe6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generator-untyped-consumer/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/generator-untyped-consumer/consumer.js", + "/tests/corpus/generator-untyped-consumer/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-base-specializations.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-base-specializations.ts.json new file mode 100644 index 000000000..7a0013870 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-base-specializations.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/generic-base-specializations.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-binding-ownership.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-binding-ownership.ts.json new file mode 100644 index 000000000..7293ee659 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-binding-ownership.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/generic-binding-ownership.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-class-js-functions/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-class-js-functions/main.ts.json new file mode 100644 index 000000000..3c613dd10 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-class-js-functions/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/generic-class-js-functions/functions.js", + "/tests/corpus/generic-class-js-functions/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-class-recovery.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-class-recovery.ts.json new file mode 100644 index 000000000..bb430760d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-class-recovery.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/generic-class-recovery.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-namespace-factories/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-namespace-factories/main.ts.json new file mode 100644 index 000000000..661230514 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-namespace-factories/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/generic-namespace-factories/pair.ts", + "/tests/corpus/generic-namespace-factories/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-nullable-collections.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-nullable-collections.ts.json new file mode 100644 index 000000000..e17910b5d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-nullable-collections.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/generic-nullable-collections.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-pattern-bindings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-pattern-bindings.ts.json new file mode 100644 index 000000000..cc056d934 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-pattern-bindings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/generic-pattern-bindings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-record-index.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-record-index.ts.json new file mode 100644 index 000000000..a05211715 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-record-index.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/generic-record-index.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-visitor-void.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-visitor-void.ts.json new file mode 100644 index 000000000..c3e637d42 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/generic-visitor-void.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/generic-visitor-void.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-error-subclasses.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-error-subclasses.ts.json new file mode 100644 index 000000000..b0f210d6e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-error-subclasses.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/global-error-subclasses.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-runtime-probes.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-runtime-probes.js.json new file mode 100644 index 000000000..ad9dfdeba --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-runtime-probes.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/global-runtime-probes.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-stored-probes.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-stored-probes.js.json new file mode 100644 index 000000000..a0a18a2c9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-stored-probes.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/global-stored-probes.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-string-cache/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-string-cache/main.js.json new file mode 100644 index 000000000..9f86f48c5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-string-cache/main.js.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/global-string-cache/remote.js", + "/tests/corpus/global-string-cache/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-symbol-cache/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-symbol-cache/main.js.json new file mode 100644 index 000000000..e8bdce0e4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/global-symbol-cache/main.js.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/global-symbol-cache/remote.js", + "/tests/corpus/global-symbol-cache/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/guarded-native-iterables.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/guarded-native-iterables.ts.json new file mode 100644 index 000000000..bf3fabb65 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/guarded-native-iterables.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/guarded-native-iterables.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/heap-input-aliases.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/heap-input-aliases.ts.json new file mode 100644 index 000000000..82e34e970 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/heap-input-aliases.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/heap-input-aliases.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/heap-input-collections.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/heap-input-collections.ts.json new file mode 100644 index 000000000..119afc702 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/heap-input-collections.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/heap-input-collections.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/in-array-runtime-index.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/in-array-runtime-index.ts.json new file mode 100644 index 000000000..d44997b9d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/in-array-runtime-index.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/in-array-runtime-index.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/indexed-assignment-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/indexed-assignment-values.js.json new file mode 100644 index 000000000..2d5b6d887 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/indexed-assignment-values.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/indexed-assignment-values.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/indexed-assignment-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/indexed-assignment-values.ts.json new file mode 100644 index 000000000..7b1325ccf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/indexed-assignment-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/indexed-assignment-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/indexed-element-field-reads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/indexed-element-field-reads.ts.json new file mode 100644 index 000000000..ea9879b39 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/indexed-element-field-reads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/indexed-element-field-reads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-array-assignment-values.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-array-assignment-values.mjs.json new file mode 100644 index 000000000..5f253f4e9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-array-assignment-values.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/inferred-array-assignment-values.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-class-default.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-class-default.mjs.json new file mode 100644 index 000000000..aa8d4319e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-class-default.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/inferred-class-default.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-compound-values.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-compound-values.mjs.json new file mode 100644 index 000000000..588fd8119 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-compound-values.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/inferred-compound-values.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-conditional-class.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-conditional-class.mjs.json new file mode 100644 index 000000000..aa3e8facb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-conditional-class.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/inferred-conditional-class.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-error-fields.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-error-fields.js.json new file mode 100644 index 000000000..f0c9a283a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-error-fields.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/inferred-error-fields.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-map-patterns.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-map-patterns.mjs.json new file mode 100644 index 000000000..db5d5cbde --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-map-patterns.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/inferred-map-patterns.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-method-override.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-method-override.js.json new file mode 100644 index 000000000..4c572cae9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-method-override.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/inferred-method-override.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-partial-destructuring.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-partial-destructuring.mjs.json new file mode 100644 index 000000000..c7522d4b6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-partial-destructuring.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/inferred-partial-destructuring.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-primitive-properties.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-primitive-properties.mjs.json new file mode 100644 index 000000000..59ed2f29e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-primitive-properties.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/inferred-primitive-properties.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-record-return.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-record-return.mjs.json new file mode 100644 index 000000000..9abca630c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-record-return.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/inferred-record-return.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-recursive-record.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-recursive-record.mjs.json new file mode 100644 index 000000000..33a2ea322 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-recursive-record.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/inferred-recursive-record.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-undefined-field.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-undefined-field.mjs.json new file mode 100644 index 000000000..021147cd4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/inferred-undefined-field.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/inferred-undefined-field.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/input-lifetime-intervals.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/input-lifetime-intervals.ts.json new file mode 100644 index 000000000..891f5407f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/input-lifetime-intervals.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/input-lifetime-intervals.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/input-lifetimes-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/input-lifetimes-modules/main.ts.json new file mode 100644 index 000000000..5a926f151 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/input-lifetimes-modules/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/input-lifetimes-modules/model.ts", + "/tests/corpus/input-lifetimes-modules/helpers.ts", + "/tests/corpus/input-lifetimes-modules/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/instanceof-class-record-union.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/instanceof-class-record-union.ts.json new file mode 100644 index 000000000..9faee1cdd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/instanceof-class-record-union.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/instanceof-class-record-union.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-flow-arithmetic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-flow-arithmetic.ts.json new file mode 100644 index 000000000..1b23ff66d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-flow-arithmetic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/integer-flow-arithmetic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-loop-forms.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-loop-forms.ts.json new file mode 100644 index 000000000..647425063 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-loop-forms.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/integer-loop-forms.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-view-control.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-view-control.ts.json new file mode 100644 index 000000000..147bc5a5d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-view-control.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/integer-view-control.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-view-numbers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-view-numbers.ts.json new file mode 100644 index 000000000..af4b09e88 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-view-numbers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/integer-view-numbers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-view-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-view-storage.ts.json new file mode 100644 index 000000000..6e770f71b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/integer-view-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/integer-view-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/intl-grapheme-conformance/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/intl-grapheme-conformance/main.ts.json new file mode 100644 index 000000000..d882331f5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/intl-grapheme-conformance/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/intl-grapheme-conformance/cases.ts", + "/tests/corpus/intl-grapheme-conformance/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/intl-grapheme.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/intl-grapheme.ts.json new file mode 100644 index 000000000..3a23005fc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/intl-grapheme.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/intl-grapheme.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/iterator-typed-returns.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/iterator-typed-returns.ts.json new file mode 100644 index 000000000..2380c0abe --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/iterator-typed-returns.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/iterator-typed-returns.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-abort-portable.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-abort-portable.js.json new file mode 100644 index 000000000..44c51f7cd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-abort-portable.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-abort-portable.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-array-constructor.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-array-constructor.js.json new file mode 100644 index 000000000..45e858953 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-array-constructor.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-array-constructor.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-array-default-buffer.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-array-default-buffer.js.json new file mode 100644 index 000000000..2c5186112 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-array-default-buffer.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-array-default-buffer.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-array-iterators.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-array-iterators.js.json new file mode 100644 index 000000000..37b3ca501 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-array-iterators.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-array-iterators.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-arrow-bind.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-arrow-bind.cjs.json new file mode 100644 index 000000000..30c8f65a4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-arrow-bind.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-arrow-bind.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-buffer-callback-brand.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-buffer-callback-brand.cjs.json new file mode 100644 index 000000000..d57636efa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-buffer-callback-brand.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-buffer-callback-brand.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-callable-proxy.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-callable-proxy.js.json new file mode 100644 index 000000000..d034c74c2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-callable-proxy.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-callable-proxy.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-chained-native-results.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-chained-native-results.mjs.json new file mode 100644 index 000000000..16857a0c6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-chained-native-results.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-chained-native-results.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-array-iterator.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-array-iterator.js.json new file mode 100644 index 000000000..9f629a6fc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-array-iterator.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-checked-array-iterator.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-array-reference.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-array-reference.js.json new file mode 100644 index 000000000..b89af4ab1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-array-reference.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-checked-array-reference.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-number-negation.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-number-negation.mjs.json new file mode 100644 index 000000000..3082468c8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-number-negation.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-checked-number-negation.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-sort-result.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-sort-result.js.json new file mode 100644 index 000000000..b700900ae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-checked-sort-result.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-checked-sort-result.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-child-error-listener.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-child-error-listener.cjs.json new file mode 100644 index 000000000..aa9bff1b3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-child-error-listener.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-child-error-listener.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-cjs-callable-snapshots/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-cjs-callable-snapshots/main.cjs.json new file mode 100644 index 000000000..2dc50bb69 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-cjs-callable-snapshots/main.cjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/js-cjs-callable-snapshots/factories.cjs", + "/tests/corpus/js-cjs-callable-snapshots/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-added-parameters.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-added-parameters.js.json new file mode 100644 index 000000000..bafd82cb5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-added-parameters.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-class-added-parameters.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-checked-overrides.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-checked-overrides.js.json new file mode 100644 index 000000000..8c72f825c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-checked-overrides.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-class-checked-overrides.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-computed-fields.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-computed-fields.js.json new file mode 100644 index 000000000..6aeeaa637 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-computed-fields.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-class-computed-fields.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-enumeration.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-enumeration.js.json new file mode 100644 index 000000000..fd66abd6e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-enumeration.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-class-enumeration.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-field-accessor-override.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-field-accessor-override.js.json new file mode 100644 index 000000000..2fe5ef9f4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-field-accessor-override.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-class-field-accessor-override.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-fluent-overrides.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-fluent-overrides.js.json new file mode 100644 index 000000000..5b62f4002 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-fluent-overrides.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-class-fluent-overrides.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-late-method-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-late-method-values.js.json new file mode 100644 index 000000000..6a67a1bee --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-late-method-values.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-class-late-method-values.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-member-dispatch.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-member-dispatch.js.json new file mode 100644 index 000000000..1dd0c4d1a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-member-dispatch.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-class-member-dispatch.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-return-shapes.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-return-shapes.js.json new file mode 100644 index 000000000..b5d29ec23 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-return-shapes.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-class-return-shapes.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-shadowed-methods.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-shadowed-methods.js.json new file mode 100644 index 000000000..36f55db79 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-shadowed-methods.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-class-shadowed-methods.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-stored-method-receiver.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-stored-method-receiver.js.json new file mode 100644 index 000000000..56f39c289 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-stored-method-receiver.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-class-stored-method-receiver.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-subclass-properties.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-subclass-properties.js.json new file mode 100644 index 000000000..9cf049fae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-subclass-properties.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-class-subclass-properties.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-symbol-spread.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-symbol-spread.cjs.json new file mode 100644 index 000000000..c7d7aa13c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-class-symbol-spread.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-class-symbol-spread.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-computed-prototype-additions.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-computed-prototype-additions.js.json new file mode 100644 index 000000000..ba1ef5e61 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-computed-prototype-additions.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-computed-prototype-additions.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-constructor-returned-callable.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-constructor-returned-callable.js.json new file mode 100644 index 000000000..80b0de556 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-constructor-returned-callable.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-constructor-returned-callable.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-constructor-spread.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-constructor-spread.js.json new file mode 100644 index 000000000..301cd1b02 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-constructor-spread.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-constructor-spread.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-dataview-dispatch.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-dataview-dispatch.js.json new file mode 100644 index 000000000..854fa417d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-dataview-dispatch.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-dataview-dispatch.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-declared-fields.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-declared-fields.cjs.json new file mode 100644 index 000000000..db275f1cc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-declared-fields.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-declared-fields.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-default-listener-arguments.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-default-listener-arguments.cjs.json new file mode 100644 index 000000000..ebea88d75 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-default-listener-arguments.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-default-listener-arguments.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-default-options/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-default-options/main.ts.json new file mode 100644 index 000000000..1eaae026e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-default-options/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/js-default-options/options.js", + "/tests/corpus/js-default-options/index.js", + "/tests/corpus/js-default-options/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-deferred-field-initializers.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-deferred-field-initializers.js.json new file mode 100644 index 000000000..ca10ae99f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-deferred-field-initializers.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-deferred-field-initializers.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-deferred-registry-effects.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-deferred-registry-effects.js.json new file mode 100644 index 000000000..d213f8aa5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-deferred-registry-effects.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-deferred-registry-effects.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-derived-constructor-hoisting.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-derived-constructor-hoisting.js.json new file mode 100644 index 000000000..53e7b417b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-derived-constructor-hoisting.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-derived-constructor-hoisting.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-dormant-array-write.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-dormant-array-write.js.json new file mode 100644 index 000000000..2c0dbde0c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-dormant-array-write.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-dormant-array-write.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-dormant-overrides.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-dormant-overrides.js.json new file mode 100644 index 000000000..de5e7fc77 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-dormant-overrides.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-dormant-overrides.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-expando-records.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-expando-records.js.json new file mode 100644 index 000000000..c9ee58a45 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-expando-records.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-expando-records.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-implicit-call-results.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-implicit-call-results.js.json new file mode 100644 index 000000000..87e732cbb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-implicit-call-results.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-implicit-call-results.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inferred-callback-exports/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inferred-callback-exports/main.js.json new file mode 100644 index 000000000..843e86855 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inferred-callback-exports/main.js.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/js-inferred-callback-exports/internal.js", + "/tests/corpus/js-inferred-callback-exports/facade.js", + "/tests/corpus/js-inferred-callback-exports/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inferred-class-array-return.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inferred-class-array-return.js.json new file mode 100644 index 000000000..b5531ea90 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inferred-class-array-return.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-inferred-class-array-return.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inferred-object-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inferred-object-values.js.json new file mode 100644 index 000000000..479f199d8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inferred-object-values.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-inferred-object-values.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inherited-field-storage.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inherited-field-storage.js.json new file mode 100644 index 000000000..62e9befe9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inherited-field-storage.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-inherited-field-storage.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inherited-parameter-abi.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inherited-parameter-abi.js.json new file mode 100644 index 000000000..f8a406b29 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-inherited-parameter-abi.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-inherited-parameter-abi.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-iterable-spread.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-iterable-spread.js.json new file mode 100644 index 000000000..ffa4ed182 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-iterable-spread.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-iterable-spread.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-loose-dynamic-primitives.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-loose-dynamic-primitives.js.json new file mode 100644 index 000000000..d05936697 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-loose-dynamic-primitives.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-loose-dynamic-primitives.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-map-object-seeds.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-map-object-seeds.js.json new file mode 100644 index 000000000..402bfdf54 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-map-object-seeds.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-map-object-seeds.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-member-increment.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-member-increment.js.json new file mode 100644 index 000000000..808e078e5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-member-increment.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-member-increment.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-module-function-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-module-function-values.js.json new file mode 100644 index 000000000..90dc3e79c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-module-function-values.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-module-function-values.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-mutable-null-members.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-mutable-null-members.js.json new file mode 100644 index 000000000..7a3016571 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-mutable-null-members.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-mutable-null-members.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-nested-native-descriptors.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-nested-native-descriptors.js.json new file mode 100644 index 000000000..0efcb8b13 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-nested-native-descriptors.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-nested-native-descriptors.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-normalize-dispatch.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-normalize-dispatch.js.json new file mode 100644 index 000000000..7d77d8349 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-normalize-dispatch.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-normalize-dispatch.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-nullish-inherited-fields.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-nullish-inherited-fields.mjs.json new file mode 100644 index 000000000..f7f4cd975 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-nullish-inherited-fields.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-nullish-inherited-fields.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-object-receiver-storage.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-object-receiver-storage.js.json new file mode 100644 index 000000000..183a27a40 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-object-receiver-storage.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-object-receiver-storage.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-object-returning-constructors.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-object-returning-constructors.mjs.json new file mode 100644 index 000000000..dcdebdd81 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-object-returning-constructors.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-object-returning-constructors.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-object-shared-arrays.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-object-shared-arrays.js.json new file mode 100644 index 000000000..b9109f079 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-object-shared-arrays.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-object-shared-arrays.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-omitted-typed-arguments.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-omitted-typed-arguments.js.json new file mode 100644 index 000000000..db1389d74 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-omitted-typed-arguments.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-omitted-typed-arguments.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-open-binding-writes.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-open-binding-writes.js.json new file mode 100644 index 000000000..6a5d62e3a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-open-binding-writes.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-open-binding-writes.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-optional-class-fields.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-optional-class-fields.js.json new file mode 100644 index 000000000..3aee77187 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-optional-class-fields.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-optional-class-fields.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-optional-member-call.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-optional-member-call.js.json new file mode 100644 index 000000000..eb71e76cb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-optional-member-call.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-optional-member-call.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-primitive-union-addition.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-primitive-union-addition.js.json new file mode 100644 index 000000000..13f4f8148 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-primitive-union-addition.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-primitive-union-addition.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-all-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-all-values.js.json new file mode 100644 index 000000000..d0bd2b8ca --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-all-values.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-promise-all-values.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-catch-handler.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-catch-handler.js.json new file mode 100644 index 000000000..92fd7b4c0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-catch-handler.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-promise-catch-handler.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-finally-order.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-finally-order.js.json new file mode 100644 index 000000000..4e34fc414 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-finally-order.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-promise-finally-order.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-pending-reactions.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-pending-reactions.js.json new file mode 100644 index 000000000..69a749812 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-promise-pending-reactions.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-promise-pending-reactions.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-prototype-host-boundary.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-prototype-host-boundary.js.json new file mode 100644 index 000000000..16335e718 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-prototype-host-boundary.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-prototype-host-boundary.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-reflect-receivers.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-reflect-receivers.js.json new file mode 100644 index 000000000..d87e07dc7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-reflect-receivers.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-reflect-receivers.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-regex-record-captures.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-regex-record-captures.js.json new file mode 100644 index 000000000..b6b4eef0c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-regex-record-captures.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-regex-record-captures.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-scalar-iterables.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-scalar-iterables.js.json new file mode 100644 index 000000000..e6fa14119 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-scalar-iterables.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-scalar-iterables.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-shared-method-dispatch.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-shared-method-dispatch.js.json new file mode 100644 index 000000000..3a295c410 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-shared-method-dispatch.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-shared-method-dispatch.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-specialized-field-method.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-specialized-field-method.js.json new file mode 100644 index 000000000..3620a79ca --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-specialized-field-method.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-specialized-field-method.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-static-accessors.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-static-accessors.js.json new file mode 100644 index 000000000..5b879fddf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-static-accessors.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-static-accessors.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-static-method-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-static-method-values.js.json new file mode 100644 index 000000000..4a838482f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-static-method-values.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-static-method-values.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-static-registries.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-static-registries.cjs.json new file mode 100644 index 000000000..8e4bc0f17 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-static-registries.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-static-registries.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-super-accessor-initialization.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-super-accessor-initialization.js.json new file mode 100644 index 000000000..200623ba2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-super-accessor-initialization.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-super-accessor-initialization.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-uninitialized-native-fields.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-uninitialized-native-fields.js.json new file mode 100644 index 000000000..9905c4869 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/js-uninitialized-native-fields.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/js-uninitialized-native-fields.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-guarded-map-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-guarded-map-values.ts.json new file mode 100644 index 000000000..29446fe0e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-guarded-map-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/json-guarded-map-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-output-bulk.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-output-bulk.ts.json new file mode 100644 index 000000000..daab77846 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-output-bulk.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/json-output-bulk.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-runtime-options.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-runtime-options.mjs.json new file mode 100644 index 000000000..655b68ad1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-runtime-options.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/json-runtime-options.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-stringify-value.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-stringify-value.js.json new file mode 100644 index 000000000..ae32c2f40 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-stringify-value.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/json-stringify-value.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-typed-parse-direct.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-typed-parse-direct.ts.json new file mode 100644 index 000000000..393350499 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/json-typed-parse-direct.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/json-typed-parse-direct.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/literal-switch-dispatch.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/literal-switch-dispatch.ts.json new file mode 100644 index 000000000..fd23ecb49 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/literal-switch-dispatch.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/literal-switch-dispatch.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/live-reference-shared-converters.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/live-reference-shared-converters.ts.json new file mode 100644 index 000000000..fa1345df2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/live-reference-shared-converters.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/live-reference-shared-converters.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/llvm-read-receiver-lifetime.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/llvm-read-receiver-lifetime.ts.json new file mode 100644 index 000000000..f0d28947e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/llvm-read-receiver-lifetime.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/llvm-read-receiver-lifetime.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-call-spreads.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-call-spreads.js.json new file mode 100644 index 000000000..d9e5deafe --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-call-spreads.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/local-class-call-spreads.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-declaration.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-declaration.ts.json new file mode 100644 index 000000000..c9e78a5da --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-declaration.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/local-class-declaration.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-evaluation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-evaluation.ts.json new file mode 100644 index 000000000..aec931c54 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-evaluation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/local-class-evaluation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-inheritance.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-inheritance.ts.json new file mode 100644 index 000000000..0fab14e3e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-inheritance.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/local-class-inheritance.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-lifetimes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-lifetimes.ts.json new file mode 100644 index 000000000..5e33d7d42 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-lifetimes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/local-class-lifetimes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-namespace/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-namespace/main.js.json new file mode 100644 index 000000000..152ec04f3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-namespace/main.js.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/local-class-namespace/base.js", + "/tests/corpus/local-class-namespace/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-prototype-data.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-prototype-data.js.json new file mode 100644 index 000000000..000be7205 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-prototype-data.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/local-class-prototype-data.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-specialization.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-specialization.js.json new file mode 100644 index 000000000..93ea8a1a0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-specialization.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/local-class-specialization.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-unknown.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-unknown.ts.json new file mode 100644 index 000000000..417773b76 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-unknown.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/local-class-unknown.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-values.ts.json new file mode 100644 index 000000000..359d5a822 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-class-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/local-class-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-union-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-union-storage.ts.json new file mode 100644 index 000000000..538f1d261 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/local-union-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/local-union-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/locale-compare-root-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/locale-compare-root-order.ts.json new file mode 100644 index 000000000..da02c0e7d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/locale-compare-root-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/locale-compare-root-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/logical-assignment-dynamic.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/logical-assignment-dynamic.js.json new file mode 100644 index 000000000..d97c9643d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/logical-assignment-dynamic.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/logical-assignment-dynamic.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/logical-assignment-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/logical-assignment-values.ts.json new file mode 100644 index 000000000..935a3f5c9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/logical-assignment-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/logical-assignment-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/logical-runtime-optional-record.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/logical-runtime-optional-record.ts.json new file mode 100644 index 000000000..c19e3695c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/logical-runtime-optional-record.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/logical-runtime-optional-record.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/loop-reference-lifetimes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/loop-reference-lifetimes.ts.json new file mode 100644 index 000000000..3876bb065 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/loop-reference-lifetimes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/loop-reference-lifetimes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-checked-boundary/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-checked-boundary/main.ts.json new file mode 100644 index 000000000..e3b1bfa3a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-checked-boundary/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/map-checked-boundary/consumer.js", + "/tests/corpus/map-checked-boundary/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-checked-seed.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-checked-seed.js.json new file mode 100644 index 000000000..995a660f7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-checked-seed.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/map-checked-seed.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-number-keys-dense.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-number-keys-dense.ts.json new file mode 100644 index 000000000..8b8b9bb8e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-number-keys-dense.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/map-number-keys-dense.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-read-lifetimes-exits.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-read-lifetimes-exits.ts.json new file mode 100644 index 000000000..1134b13e1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-read-lifetimes-exits.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/map-read-lifetimes-exits.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-read-lifetimes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-read-lifetimes.ts.json new file mode 100644 index 000000000..d77590607 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-read-lifetimes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/map-read-lifetimes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-seeds-and-spreads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-seeds-and-spreads.ts.json new file mode 100644 index 000000000..4c7eb78b6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-seeds-and-spreads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/map-seeds-and-spreads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-typed-array-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-typed-array-values.ts.json new file mode 100644 index 000000000..5dc6309a6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/map-typed-array-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/map-typed-array-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/math-function-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/math-function-values.js.json new file mode 100644 index 000000000..5fb27b413 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/math-function-values.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/math-function-values.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/missing-read-lambda-results.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/missing-read-lambda-results.ts.json new file mode 100644 index 000000000..bbba75c92 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/missing-read-lambda-results.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/missing-read-lambda-results.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/missing-read-narrowed-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/missing-read-narrowed-storage.ts.json new file mode 100644 index 000000000..169714773 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/missing-read-narrowed-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/missing-read-narrowed-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/missing-read-number-conversions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/missing-read-number-conversions.ts.json new file mode 100644 index 000000000..a51857f5f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/missing-read-number-conversions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/missing-read-number-conversions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/module-byte-loops.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/module-byte-loops.ts.json new file mode 100644 index 000000000..01a28129d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/module-byte-loops.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/module-byte-loops.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/module-fallback-functions/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/module-fallback-functions/main.js.json new file mode 100644 index 000000000..1a053439a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/module-fallback-functions/main.js.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/module-fallback-functions/platform.js", + "/tests/corpus/module-fallback-functions/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/narrowed-nullish-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/narrowed-nullish-values.ts.json new file mode 100644 index 000000000..f7aabe2b7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/narrowed-nullish-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/narrowed-nullish-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-borrowed-find-last.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-borrowed-find-last.js.json new file mode 100644 index 000000000..3009ffe48 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-borrowed-find-last.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-borrowed-find-last.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-borrowed-slice.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-borrowed-slice.js.json new file mode 100644 index 000000000..db96db3d9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-borrowed-slice.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-borrowed-slice.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-copying-methods.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-copying-methods.js.json new file mode 100644 index 000000000..a3f2d6948 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-copying-methods.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-copying-methods.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-fill-copywithin.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-fill-copywithin.js.json new file mode 100644 index 000000000..bd86c5e2d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-fill-copywithin.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-fill-copywithin.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-frozen-noops.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-frozen-noops.js.json new file mode 100644 index 000000000..6073d34a6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-frozen-noops.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-frozen-noops.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-index-boundaries.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-index-boundaries.js.json new file mode 100644 index 000000000..0bc03fc48 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-index-boundaries.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-index-boundaries.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-integrity.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-integrity.js.json new file mode 100644 index 000000000..a6d82c348 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-integrity.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-integrity.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-length.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-length.js.json new file mode 100644 index 000000000..c63111740 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-length.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-length.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-named-properties.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-named-properties.js.json new file mode 100644 index 000000000..b467aee54 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-named-properties.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-named-properties.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-prototype/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-prototype/main.js.json new file mode 100644 index 000000000..007cbf41d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-prototype/main.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-prototype/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-read-lifetimes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-read-lifetimes.ts.json new file mode 100644 index 000000000..bdf48124e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-read-lifetimes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-read-lifetimes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-reduce-find-last.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-reduce-find-last.js.json new file mode 100644 index 000000000..6250aaa74 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-reduce-find-last.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-reduce-find-last.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-search-from-index.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-search-from-index.js.json new file mode 100644 index 000000000..c36773b56 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-search-from-index.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-search-from-index.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-splice-coercion.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-splice-coercion.js.json new file mode 100644 index 000000000..32ced3893 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-splice-coercion.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-splice-coercion.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-splice-flat.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-splice-flat.js.json new file mode 100644 index 000000000..ba4bfb0b3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-array-splice-flat.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-array-splice-flat.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-buffer-coercion.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-buffer-coercion.js.json new file mode 100644 index 000000000..e242b3f50 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-buffer-coercion.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-buffer-coercion.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-callback-dispatch.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-callback-dispatch.ts.json new file mode 100644 index 000000000..77d23cdd1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-callback-dispatch.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-callback-dispatch.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-array-boundaries.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-array-boundaries.ts.json new file mode 100644 index 000000000..c5ce88bdb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-array-boundaries.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-class-array-boundaries.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-cache.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-cache.js.json new file mode 100644 index 000000000..e80b850e2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-cache.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-class-cache.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-properties.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-properties.cjs.json new file mode 100644 index 000000000..3febc565b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-properties.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-class-properties.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-property-cycles.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-property-cycles.cjs.json new file mode 100644 index 000000000..e6084a983 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-property-cycles.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-class-property-cycles.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-property-order.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-property-order.cjs.json new file mode 100644 index 000000000..79fd73b6c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-property-order.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-class-property-order.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-type-predicates.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-type-predicates.ts.json new file mode 100644 index 000000000..a48ca3309 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-class-type-predicates.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-class-type-predicates.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-factory-records.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-factory-records.js.json new file mode 100644 index 000000000..5fd113982 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-factory-records.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-factory-records.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-method-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-method-values.js.json new file mode 100644 index 000000000..3ddd4a59f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-method-values.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-method-values.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-method-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-method-values.ts.json new file mode 100644 index 000000000..603cf9d02 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-method-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-method-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-descriptors.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-descriptors.js.json new file mode 100644 index 000000000..efdb82183 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-descriptors.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-object-descriptors.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-for-in-minimal.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-for-in-minimal.js.json new file mode 100644 index 000000000..5f0a1a083 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-for-in-minimal.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-object-for-in-minimal.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-property-attributes.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-property-attributes.js.json new file mode 100644 index 000000000..0946ed05f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-property-attributes.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-object-property-attributes.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-prototype.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-prototype.js.json new file mode 100644 index 000000000..dcf958210 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-object-prototype.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-object-prototype.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-property-names.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-property-names.ts.json new file mode 100644 index 000000000..6b0e2aead --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-property-names.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-property-names.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-proxy-env.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-proxy-env.js.json new file mode 100644 index 000000000..db5f96df1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-proxy-env.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-proxy-env.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-arena-reuse.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-arena-reuse.ts.json new file mode 100644 index 000000000..26491efd4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-arena-reuse.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-arena-reuse.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-bounded-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-bounded-errors.ts.json new file mode 100644 index 000000000..431bcba60 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-bounded-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-bounded-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-buffer-consumers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-buffer-consumers.ts.json new file mode 100644 index 000000000..a20a574bd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-buffer-consumers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-buffer-consumers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-cancel-hot.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-cancel-hot.ts.json new file mode 100644 index 000000000..c1d5cddb0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-cancel-hot.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-cancel-hot.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-class-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-class-fields.ts.json new file mode 100644 index 000000000..a7245aa60 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-class-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-class-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-clone-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-clone-errors.ts.json new file mode 100644 index 000000000..fa498a6f3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-clone-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-clone-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-commonjs.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-commonjs.cjs.json new file mode 100644 index 000000000..70d20c2b2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-commonjs.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-commonjs.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-delayed-messages.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-delayed-messages.ts.json new file mode 100644 index 000000000..6c5a16c9a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-delayed-messages.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-delayed-messages.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-environment.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-environment.ts.json new file mode 100644 index 000000000..09c440c31 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-environment.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-environment.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-error.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-error.ts.json new file mode 100644 index 000000000..5127b6320 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-error.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-error.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-exception-state.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-exception-state.ts.json new file mode 100644 index 000000000..ffa988a3b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-exception-state.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-exception-state.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-exit-listeners.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-exit-listeners.ts.json new file mode 100644 index 000000000..bbbeeda28 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-exit-listeners.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-exit-listeners.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-io.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-io.ts.json new file mode 100644 index 000000000..6b4fdfd54 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-io.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-io.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-loop-cancellation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-loop-cancellation.ts.json new file mode 100644 index 000000000..fe5c8ba37 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-loop-cancellation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-loop-cancellation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-message-graphs.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-message-graphs.ts.json new file mode 100644 index 000000000..90602d115 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-message-graphs.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-message-graphs.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-messages.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-messages.ts.json new file mode 100644 index 000000000..4540f8b7b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-messages.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-messages.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-poll-exceptions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-poll-exceptions.ts.json new file mode 100644 index 000000000..8c7ebbdec --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-poll-exceptions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-poll-exceptions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-port-lifetime.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-port-lifetime.ts.json new file mode 100644 index 000000000..71d94c1ff --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-port-lifetime.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-port-lifetime.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-process-exit.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-process-exit.ts.json new file mode 100644 index 000000000..b81c52744 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-process-exit.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-process-exit.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-publish-classes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-publish-classes.ts.json new file mode 100644 index 000000000..0dd3f4117 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-publish-classes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-publish-classes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-publish-refusals.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-publish-refusals.ts.json new file mode 100644 index 000000000..1762ac222 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-publish-refusals.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-publish-refusals.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-published-graphs.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-published-graphs.ts.json new file mode 100644 index 000000000..15e0bf16d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-published-graphs.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-published-graphs.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-references.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-references.ts.json new file mode 100644 index 000000000..2ca872c8d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-references.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-references.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-roots/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-roots/main.ts.json new file mode 100644 index 000000000..e6bf552ba --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-roots/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-roots/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-shared-views.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-shared-views.ts.json new file mode 100644 index 000000000..3868b36cd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-shared-views.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-shared-views.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-stack-overflow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-stack-overflow.ts.json new file mode 100644 index 000000000..a1584aa2e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-stack-overflow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-stack-overflow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-exception-state.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-exception-state.ts.json new file mode 100644 index 000000000..e5200b82d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-exception-state.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-terminate-exception-state.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-loop.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-loop.ts.json new file mode 100644 index 000000000..2962cf46a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-loop.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-terminate-loop.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-recursion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-recursion.ts.json new file mode 100644 index 000000000..1d6f64763 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-recursion.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-terminate-recursion.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-suspended.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-suspended.ts.json new file mode 100644 index 000000000..59e30d9b1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-suspended.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-terminate-suspended.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-tested-loops.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-tested-loops.ts.json new file mode 100644 index 000000000..9adffe8b7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-tested-loops.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-terminate-tested-loops.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-wait.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-wait.ts.json new file mode 100644 index 000000000..d9300fcae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-terminate-wait.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-terminate-wait.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-typed-arrays.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-typed-arrays.ts.json new file mode 100644 index 000000000..589f256ae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/native-worker-typed-arrays.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/native-worker-typed-arrays.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nested-map-cycles.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nested-map-cycles.ts.json new file mode 100644 index 000000000..266842f07 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nested-map-cycles.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/nested-map-cycles.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nested-map-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nested-map-values.ts.json new file mode 100644 index 000000000..6d38fffae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nested-map-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/nested-map-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/never-returning-calls.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/never-returning-calls.ts.json new file mode 100644 index 000000000..3bb9cbb8d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/never-returning-calls.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/never-returning-calls.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/next-tick-commonjs-entry.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/next-tick-commonjs-entry.cjs.json new file mode 100644 index 000000000..ee45a0128 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/next-tick-commonjs-entry.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/next-tick-commonjs-entry.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-buffer-encoding-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-buffer-encoding-errors.ts.json new file mode 100644 index 000000000..0e3c799c7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-buffer-encoding-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-buffer-encoding-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-buffer-encoding.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-buffer-encoding.ts.json new file mode 100644 index 000000000..906805289 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-buffer-encoding.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-buffer-encoding.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-kdf-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-kdf-errors.ts.json new file mode 100644 index 000000000..8aad02eb5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-kdf-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-crypto-kdf-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-kdf-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-kdf-options.ts.json new file mode 100644 index 000000000..0c75fe601 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-kdf-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-crypto-kdf-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-kdf.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-kdf.ts.json new file mode 100644 index 000000000..bf25b3a01 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-kdf.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-crypto-kdf.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-sha2.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-sha2.ts.json new file mode 100644 index 000000000..d7b2101e5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-crypto-sha2.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-crypto-sha2.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-deep-equality-properties.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-deep-equality-properties.js.json new file mode 100644 index 000000000..9c472ac2b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-deep-equality-properties.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-deep-equality-properties.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-deep-equality.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-deep-equality.cjs.json new file mode 100644 index 000000000..32e650a46 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-deep-equality.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-deep-equality.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-deep-equality.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-deep-equality.ts.json new file mode 100644 index 000000000..d4ecc99a6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-deep-equality.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-deep-equality.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-files-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-files-errors.ts.json new file mode 100644 index 000000000..e143ce9a6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-files-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-env-files-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-files.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-files.ts.json new file mode 100644 index 000000000..d48904e5c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-files.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-env-files.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-imports.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-imports.cjs.json new file mode 100644 index 000000000..1ccfa575e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-imports.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-env-imports.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-parse-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-parse-errors.ts.json new file mode 100644 index 000000000..65cc717fa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-parse-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-env-parse-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-parse.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-parse.ts.json new file mode 100644 index 000000000..62d961a7d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-env-parse.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-env-parse.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-esm-metadata/main.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-esm-metadata/main.mjs.json new file mode 100644 index 000000000..a23e0c770 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-esm-metadata/main.mjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/node24-esm-metadata/child with ü.mjs", + "/tests/corpus/node24-esm-metadata/main.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-file-url-buffer.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-file-url-buffer.ts.json new file mode 100644 index 000000000..ce35db3e2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-file-url-buffer.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-file-url-buffer.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-file-url-errors.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-file-url-errors.js.json new file mode 100644 index 000000000..382deceed --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-file-url-errors.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-file-url-errors.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-file-url-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-file-url-options.ts.json new file mode 100644 index 000000000..a7937ff85 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-file-url-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-file-url-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-callbacks.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-callbacks.cjs.json new file mode 100644 index 000000000..5ff6eebef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-callbacks.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-links-callbacks.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-errors.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-errors.cjs.json new file mode 100644 index 000000000..e6fc18c66 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-errors.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-links-errors.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-options.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-options.cjs.json new file mode 100644 index 000000000..a0d1b5d58 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-options.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-links-options.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-promise-errors.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-promise-errors.cjs.json new file mode 100644 index 000000000..9a539053d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-promise-errors.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-links-promise-errors.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-promises.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-promises.ts.json new file mode 100644 index 000000000..4226e098a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links-promises.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-links-promises.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links.ts.json new file mode 100644 index 000000000..af45f9362 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-links.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-links.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs-callbacks.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs-callbacks.cjs.json new file mode 100644 index 000000000..a622b9007 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs-callbacks.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-statfs-callbacks.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs-errors.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs-errors.cjs.json new file mode 100644 index 000000000..9a43ec97a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs-errors.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-statfs-errors.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs-options.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs-options.cjs.json new file mode 100644 index 000000000..f54df1ae2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs-options.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-statfs-options.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs.ts.json new file mode 100644 index 000000000..18ad156aa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-statfs.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-statfs.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-callbacks.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-callbacks.cjs.json new file mode 100644 index 000000000..fb0e6ae21 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-callbacks.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-timestamps-callbacks.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-errors.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-errors.cjs.json new file mode 100644 index 000000000..91b0321f7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-errors.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-timestamps-errors.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-promises.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-promises.ts.json new file mode 100644 index 000000000..2762f2c66 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-promises.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-timestamps-promises.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-symlinks.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-symlinks.ts.json new file mode 100644 index 000000000..a6edabac4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps-symlinks.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-timestamps-symlinks.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps.ts.json new file mode 100644 index 000000000..b6d1f7efc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-fs-timestamps.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-fs-timestamps.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-no-error-assertions-coercion.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-no-error-assertions-coercion.js.json new file mode 100644 index 000000000..dc27ad5bc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-no-error-assertions-coercion.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-no-error-assertions-coercion.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-no-error-assertions.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-no-error-assertions.cjs.json new file mode 100644 index 000000000..df6f0880a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-no-error-assertions.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-no-error-assertions.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-no-error-assertions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-no-error-assertions.ts.json new file mode 100644 index 000000000..74632412b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-no-error-assertions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-no-error-assertions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-parseargs.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-parseargs.js.json new file mode 100644 index 000000000..c9b15b93a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-parseargs.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-parseargs.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-string-decoder.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-string-decoder.ts.json new file mode 100644 index 000000000..fb4857192 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-string-decoder.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-string-decoder.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text-environment.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text-environment.js.json new file mode 100644 index 000000000..8d558a183 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text-environment.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-style-text-environment.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text-validation.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text-validation.js.json new file mode 100644 index 000000000..e5898989a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text-validation.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-style-text-validation.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text.cjs.json new file mode 100644 index 000000000..e44e58d7e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-style-text.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text.ts.json new file mode 100644 index 000000000..96cec76b6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-style-text.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-style-text.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-system-error-validation.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-system-error-validation.js.json new file mode 100644 index 000000000..e87832e13 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-system-error-validation.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-system-error-validation.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-system-errors.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-system-errors.cjs.json new file mode 100644 index 000000000..55cfbd2c7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-system-errors.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-system-errors.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-system-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-system-errors.ts.json new file mode 100644 index 000000000..5b669d5dc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-system-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-system-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-codec-properties.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-codec-properties.ts.json new file mode 100644 index 000000000..1b59778ff --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-codec-properties.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-text-codec-properties.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-encode-into.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-encode-into.ts.json new file mode 100644 index 000000000..5502006ba --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-encode-into.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-text-encode-into.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities-coercion.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities-coercion.js.json new file mode 100644 index 000000000..708235a44 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities-coercion.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-text-utilities-coercion.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities-validation.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities-validation.js.json new file mode 100644 index 000000000..24e248e43 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities-validation.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-text-utilities-validation.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities.cjs.json new file mode 100644 index 000000000..9ec9a552d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-text-utilities.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities.ts.json new file mode 100644 index 000000000..4682f3b13 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-text-utilities.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-text-utilities.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-authority-coercion.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-authority-coercion.js.json new file mode 100644 index 000000000..83263bd76 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-authority-coercion.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-url-authority-coercion.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-authority.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-authority.ts.json new file mode 100644 index 000000000..7eb6190a7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-authority.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-url-authority.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-factories.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-factories.ts.json new file mode 100644 index 000000000..9473c2cf5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-factories.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-url-factories.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-factory-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-factory-errors.ts.json new file mode 100644 index 000000000..9b79b602f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-factory-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-url-factory-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-mutation-coercion.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-mutation-coercion.js.json new file mode 100644 index 000000000..b7a39ec9c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-mutation-coercion.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-url-mutation-coercion.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-mutation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-mutation.ts.json new file mode 100644 index 000000000..c977f7c4d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-url-mutation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-url-mutation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-util-types.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-util-types.cjs.json new file mode 100644 index 000000000..e16a26600 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-util-types.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-util-types.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-util-types.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-util-types.js.json new file mode 100644 index 000000000..c834091ef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-util-types.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-util-types.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-util-types.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-util-types.ts.json new file mode 100644 index 000000000..2f7c600ac --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/node24-util-types.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/node24-util-types.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/non-null-class-iteration.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/non-null-class-iteration.ts.json new file mode 100644 index 000000000..a248543c6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/non-null-class-iteration.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/non-null-class-iteration.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nonnull-element-arguments.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nonnull-element-arguments.ts.json new file mode 100644 index 000000000..1609a7a72 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nonnull-element-arguments.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/nonnull-element-arguments.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nonnull-forwarded-class-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nonnull-forwarded-class-values.ts.json new file mode 100644 index 000000000..639efe0ed --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nonnull-forwarded-class-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/nonnull-forwarded-class-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullable-object-extension.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullable-object-extension.mjs.json new file mode 100644 index 000000000..a1ca9a69a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullable-object-extension.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/nullable-object-extension.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullish-asserted-class-arms.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullish-asserted-class-arms.ts.json new file mode 100644 index 000000000..839f4d3a1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullish-asserted-class-arms.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/nullish-asserted-class-arms.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullish-assignment-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullish-assignment-values.ts.json new file mode 100644 index 000000000..00b9d6c99 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullish-assignment-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/nullish-assignment-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullish-long-chain.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullish-long-chain.ts.json new file mode 100644 index 000000000..c738e49fa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/nullish-long-chain.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/nullish-long-chain.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/number-parse-statics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/number-parse-statics.ts.json new file mode 100644 index 000000000..7ac9d0a07 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/number-parse-statics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/number-parse-statics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/number-predicates-unknown.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/number-predicates-unknown.ts.json new file mode 100644 index 000000000..3fa8cde91 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/number-predicates-unknown.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/number-predicates-unknown.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/numeric-call-specialization.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/numeric-call-specialization.ts.json new file mode 100644 index 000000000..e1237667d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/numeric-call-specialization.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/numeric-call-specialization.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-enumeration-array-reads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-enumeration-array-reads.ts.json new file mode 100644 index 000000000..16fd7b09e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-enumeration-array-reads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/object-enumeration-array-reads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-from-checked-entries.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-from-checked-entries.js.json new file mode 100644 index 000000000..8d7a0345e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-from-checked-entries.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/object-from-checked-entries.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-inherited-to-string.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-inherited-to-string.js.json new file mode 100644 index 000000000..9b85e7dfd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-inherited-to-string.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/object-inherited-to-string.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-key-indexes.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-key-indexes.js.json new file mode 100644 index 000000000..e407bad82 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-key-indexes.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/object-key-indexes.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-prototype-identity.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-prototype-identity.mjs.json new file mode 100644 index 000000000..0d3f0e832 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-prototype-identity.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/object-prototype-identity.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-reexport/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-reexport/main.js.json new file mode 100644 index 000000000..bb6bbf39a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-reexport/main.js.json @@ -0,0 +1,9 @@ +{ + "order": [ + "/tests/corpus/object-reexport/core.js", + "/tests/corpus/object-reexport/barrel.js", + "/tests/corpus/object-reexport/consumer.js", + "/tests/corpus/object-reexport/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-spread-computed.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-spread-computed.ts.json new file mode 100644 index 000000000..d68584774 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/object-spread-computed.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/object-spread-computed.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/opentui-byte-queue.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/opentui-byte-queue.js.json new file mode 100644 index 000000000..9d7b79d86 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/opentui-byte-queue.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/opentui-byte-queue.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-callback-arity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-callback-arity.ts.json new file mode 100644 index 000000000..b4835c728 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-callback-arity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/optional-callback-arity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-class-flows.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-class-flows.ts.json new file mode 100644 index 000000000..1539f7a72 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-class-flows.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/optional-class-flows.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-element-defaults.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-element-defaults.ts.json new file mode 100644 index 000000000..42dd0e8c8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-element-defaults.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/optional-element-defaults.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-flag-comparisons.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-flag-comparisons.ts.json new file mode 100644 index 000000000..5ecdc5211 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-flag-comparisons.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/optional-flag-comparisons.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-native-callables.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-native-callables.js.json new file mode 100644 index 000000000..5819029d1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-native-callables.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/optional-native-callables.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-node-list-iteration.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-node-list-iteration.ts.json new file mode 100644 index 000000000..8382c18f4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-node-list-iteration.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/optional-node-list-iteration.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-string-index/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-string-index/main.ts.json new file mode 100644 index 000000000..a63a5a793 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/optional-string-index/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/optional-string-index/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/path-to-file-url-options.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/path-to-file-url-options.ts.json new file mode 100644 index 000000000..43583a142 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/path-to-file-url-options.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/path-to-file-url-options.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/performance-presence.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/performance-presence.ts.json new file mode 100644 index 000000000..2466a1769 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/performance-presence.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/performance-presence.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/primitive-and-function-descriptors.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/primitive-and-function-descriptors.js.json new file mode 100644 index 000000000..325cf8799 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/primitive-and-function-descriptors.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/primitive-and-function-descriptors.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/primitive-union-string.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/primitive-union-string.ts.json new file mode 100644 index 000000000..c2b4aa865 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/primitive-union-string.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/primitive-union-string.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-builtin-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-builtin-values.js.json new file mode 100644 index 000000000..5d131450c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-builtin-values.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/process-builtin-values.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-env-computed-keys.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-env-computed-keys.js.json new file mode 100644 index 000000000..da139735b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-env-computed-keys.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/process-env-computed-keys.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-hrtime.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-hrtime.js.json new file mode 100644 index 000000000..ee0e66e70 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-hrtime.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/process-hrtime.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-named-signals.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-named-signals.cjs.json new file mode 100644 index 000000000..05e21bbc0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-named-signals.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/process-named-signals.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-handler-throws.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-handler-throws.cjs.json new file mode 100644 index 000000000..1c9dabaf3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-handler-throws.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/process-uncaught-handler-throws.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-loop.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-loop.cjs.json new file mode 100644 index 000000000..08337c419 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-loop.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/process-uncaught-loop.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-module.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-module.mjs.json new file mode 100644 index 000000000..2d0de5856 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-module.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/process-uncaught-module.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-monitor.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-monitor.cjs.json new file mode 100644 index 000000000..26339ca69 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-monitor.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/process-uncaught-monitor.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-rejection.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-rejection.cjs.json new file mode 100644 index 000000000..2d7958ab8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-rejection.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/process-uncaught-rejection.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-sync.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-sync.cjs.json new file mode 100644 index 000000000..834c610d6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-uncaught-sync.cjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/process-uncaught-sync.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-version-pin.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-version-pin.ts.json new file mode 100644 index 000000000..4c5da85ed --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-version-pin.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/process-version-pin.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-versions-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-versions-storage.ts.json new file mode 100644 index 000000000..71352d6e3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/process-versions-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/process-versions-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/projected-collection-lifetimes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/projected-collection-lifetimes.ts.json new file mode 100644 index 000000000..0ab9d8401 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/projected-collection-lifetimes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/projected-collection-lifetimes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/promise-checked-rejections.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/promise-checked-rejections.ts.json new file mode 100644 index 000000000..959c1d0a4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/promise-checked-rejections.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/promise-checked-rejections.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/promise-resolve-void.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/promise-resolve-void.ts.json new file mode 100644 index 000000000..85eb00f43 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/promise-resolve-void.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/promise-resolve-void.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/prototype-method-overrides.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/prototype-method-overrides.mjs.json new file mode 100644 index 000000000..9143be869 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/prototype-method-overrides.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/prototype-method-overrides.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/prototype-named-data-records.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/prototype-named-data-records.ts.json new file mode 100644 index 000000000..78afd2b47 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/prototype-named-data-records.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/prototype-named-data-records.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-field-presence.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-field-presence.ts.json new file mode 100644 index 000000000..1a4f2876d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-field-presence.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/record-field-presence.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-key-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-key-order.ts.json new file mode 100644 index 000000000..e07028a10 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-key-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/record-key-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-optional-json-presence.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-optional-json-presence.ts.json new file mode 100644 index 000000000..8f5cf90d9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-optional-json-presence.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/record-optional-json-presence.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-presence-copies.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-presence-copies.ts.json new file mode 100644 index 000000000..9d7639833 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-presence-copies.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/record-presence-copies.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-presence-delete-json.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-presence-delete-json.ts.json new file mode 100644 index 000000000..74216c473 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-presence-delete-json.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/record-presence-delete-json.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-unchecked-read-presence.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-unchecked-read-presence.ts.json new file mode 100644 index 000000000..9d9329e5c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-unchecked-read-presence.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/record-unchecked-read-presence.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-unknown-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-unknown-values.ts.json new file mode 100644 index 000000000..883713622 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/record-unknown-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/record-unknown-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/reflect-own-keys.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/reflect-own-keys.mjs.json new file mode 100644 index 000000000..9b0ab6111 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/reflect-own-keys.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/reflect-own-keys.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/reflect-record-union-keys.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/reflect-record-union-keys.mjs.json new file mode 100644 index 000000000..ce558e30b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/reflect-record-union-keys.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/reflect-record-union-keys.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/reflect-typed-record-keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/reflect-typed-record-keys.ts.json new file mode 100644 index 000000000..d23476e2a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/reflect-typed-record-keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/reflect-typed-record-keys.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-callback-replacements.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-callback-replacements.ts.json new file mode 100644 index 000000000..899411a30 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-callback-replacements.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/regex-callback-replacements.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-callback-values.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-callback-values.js.json new file mode 100644 index 000000000..db3e1ac21 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-callback-values.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/regex-callback-values.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-checked-casts.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-checked-casts.ts.json new file mode 100644 index 000000000..86d733e5e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-checked-casts.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/regex-checked-casts.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-checked-storage.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-checked-storage.js.json new file mode 100644 index 000000000..6b8d95daf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-checked-storage.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/regex-checked-storage.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-exec-long-subject.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-exec-long-subject.ts.json new file mode 100644 index 000000000..15227f17a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-exec-long-subject.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/regex-exec-long-subject.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-input-lifetimes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-input-lifetimes.ts.json new file mode 100644 index 000000000..d7fac3801 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-input-lifetimes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/regex-input-lifetimes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-native-matcher.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-native-matcher.ts.json new file mode 100644 index 000000000..93f4b395e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-native-matcher.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/regex-native-matcher.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-optional-captures.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-optional-captures.ts.json new file mode 100644 index 000000000..c635a847c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-optional-captures.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/regex-optional-captures.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-optional-templates.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-optional-templates.ts.json new file mode 100644 index 000000000..c0160796b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-optional-templates.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/regex-optional-templates.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-split-captures.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-split-captures.ts.json new file mode 100644 index 000000000..3f27d328c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-split-captures.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/regex-split-captures.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-text-paths.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-text-paths.ts.json new file mode 100644 index 000000000..f38282e2c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regex-text-paths.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/regex-text-paths.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regexp-constructor-repeat.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regexp-constructor-repeat.ts.json new file mode 100644 index 000000000..bec7060cc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regexp-constructor-repeat.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/regexp-constructor-repeat.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regexp-optional-constructor.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regexp-optional-constructor.ts.json new file mode 100644 index 000000000..362821b92 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regexp-optional-constructor.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/regexp-optional-constructor.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regexp-string-coercion.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regexp-string-coercion.js.json new file mode 100644 index 000000000..5397e46cb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/regexp-string-coercion.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/regexp-string-coercion.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/renderer-export-dictionaries.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/renderer-export-dictionaries.js.json new file mode 100644 index 000000000..6b1d309fa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/renderer-export-dictionaries.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/renderer-export-dictionaries.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/renderer-null-state.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/renderer-null-state.js.json new file mode 100644 index 000000000..9022c7214 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/renderer-null-state.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/renderer-null-state.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/renderer-specializations.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/renderer-specializations.js.json new file mode 100644 index 000000000..94d0cf5f3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/renderer-specializations.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/renderer-specializations.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/repeat-and-typed-read-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/repeat-and-typed-read-errors.ts.json new file mode 100644 index 000000000..70b4f5e57 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/repeat-and-typed-read-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/repeat-and-typed-read-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/rest-optional-array-arguments.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/rest-optional-array-arguments.ts.json new file mode 100644 index 000000000..1c8943ce8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/rest-optional-array-arguments.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/rest-optional-array-arguments.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/rest-optional-elements.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/rest-optional-elements.ts.json new file mode 100644 index 000000000..2d52df75e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/rest-optional-elements.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/rest-optional-elements.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/return-void-through-finally.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/return-void-through-finally.ts.json new file mode 100644 index 000000000..6f9e4befa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/return-void-through-finally.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/return-void-through-finally.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/runtime-optional-string-flows.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/runtime-optional-string-flows.ts.json new file mode 100644 index 000000000..f4b51b0e8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/runtime-optional-string-flows.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/runtime-optional-string-flows.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/scalar-string-slices.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/scalar-string-slices.ts.json new file mode 100644 index 000000000..2b2d5db81 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/scalar-string-slices.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/scalar-string-slices.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-checked-methods.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-checked-methods.js.json new file mode 100644 index 000000000..5aaa9dfa3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-checked-methods.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/set-checked-methods.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-checked-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-checked-storage.ts.json new file mode 100644 index 000000000..da2b819ed --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-checked-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/set-checked-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-iterator-seed-references.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-iterator-seed-references.ts.json new file mode 100644 index 000000000..dff679ff4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-iterator-seed-references.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/set-iterator-seed-references.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-iterator-seeds.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-iterator-seeds.ts.json new file mode 100644 index 000000000..d2ac7272e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-iterator-seeds.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/set-iterator-seeds.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-optional-seeds.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-optional-seeds.ts.json new file mode 100644 index 000000000..2249a0e89 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/set-optional-seeds.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/set-optional-seeds.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/small-collection-transitions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/small-collection-transitions.ts.json new file mode 100644 index 000000000..95dda620d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/small-collection-transitions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/small-collection-transitions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-depth-async-bodies.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-depth-async-bodies.ts.json new file mode 100644 index 000000000..b55ad1385 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-depth-async-bodies.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/stack-depth-async-bodies.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-async.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-async.ts.json new file mode 100644 index 000000000..989a58243 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-async.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/stack-overflow-async.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-caught.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-caught.ts.json new file mode 100644 index 000000000..ba1f02057 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-caught.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/stack-overflow-caught.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-finally.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-finally.ts.json new file mode 100644 index 000000000..c53ffb780 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-finally.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/stack-overflow-finally.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-shapes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-shapes.ts.json new file mode 100644 index 000000000..5bbc03bd5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-shapes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/stack-overflow-shapes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-uncaught.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-uncaught.ts.json new file mode 100644 index 000000000..0a0896cd3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stack-overflow-uncaught.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/stack-overflow-uncaught.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/static-field-updates/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/static-field-updates/main.ts.json new file mode 100644 index 000000000..a46fbb8ac --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/static-field-updates/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/static-field-updates/counter.ts", + "/tests/corpus/static-field-updates/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/static-method-receivers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/static-method-receivers.ts.json new file mode 100644 index 000000000..c89dc0135 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/static-method-receivers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/static-method-receivers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stdio-values.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stdio-values.mjs.json new file mode 100644 index 000000000..23a3b502f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stdio-values.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/stdio-values.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stdio-write-errors.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stdio-write-errors.mjs.json new file mode 100644 index 000000000..c38027883 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stdio-write-errors.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/stdio-write-errors.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stdio-write-overrides.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stdio-write-overrides.mjs.json new file mode 100644 index 000000000..b8d15dacc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stdio-write-overrides.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/stdio-write-overrides.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stored-native-builtins.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stored-native-builtins.js.json new file mode 100644 index 000000000..7d466c274 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stored-native-builtins.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/stored-native-builtins.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stored-object-helpers.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stored-object-helpers.js.json new file mode 100644 index 000000000..ce5058dfe --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/stored-object-helpers.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/stored-object-helpers.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-code-points.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-code-points.ts.json new file mode 100644 index 000000000..21ad5d447 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-code-points.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/string-code-points.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-concat-number-parts.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-concat-number-parts.ts.json new file mode 100644 index 000000000..363cb935e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-concat-number-parts.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/string-concat-number-parts.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-construction-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-construction-order.ts.json new file mode 100644 index 000000000..2efb955ec --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-construction-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/string-construction-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-boundaries.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-boundaries.ts.json new file mode 100644 index 000000000..5759cb261 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-boundaries.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/string-lifetimes-boundaries.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-evaluation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-evaluation.ts.json new file mode 100644 index 000000000..d61877d62 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-evaluation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/string-lifetimes-evaluation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-iteration.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-iteration.ts.json new file mode 100644 index 000000000..2cdc4a5cd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-iteration.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/string-lifetimes-iteration.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-operations.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-operations.ts.json new file mode 100644 index 000000000..0bb6a1388 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-lifetimes-operations.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/string-lifetimes-operations.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-normalize.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-normalize.ts.json new file mode 100644 index 000000000..c1f286108 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-normalize.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/string-normalize.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-pattern-replacement.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-pattern-replacement.ts.json new file mode 100644 index 000000000..c695f7c69 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-pattern-replacement.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/string-pattern-replacement.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-split-checked-separator.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-split-checked-separator.mjs.json new file mode 100644 index 000000000..8c42b4852 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-split-checked-separator.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/string-split-checked-separator.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-split-traversal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-split-traversal.ts.json new file mode 100644 index 000000000..c600d9a88 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-split-traversal.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/string-split-traversal.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/structural-class-properties.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/structural-class-properties.ts.json new file mode 100644 index 000000000..45fe22ff4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/structural-class-properties.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/structural-class-properties.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/structured-text-boundaries.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/structured-text-boundaries.js.json new file mode 100644 index 000000000..1b44b2af0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/structured-text-boundaries.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/structured-text-boundaries.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/structured-text-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/structured-text-storage.ts.json new file mode 100644 index 000000000..878f45f2d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/structured-text-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/structured-text-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/switch-integer-dispatch.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/switch-integer-dispatch.ts.json new file mode 100644 index 000000000..c3fdbd6de --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/switch-integer-dispatch.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/switch-integer-dispatch.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-checked-boundary/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-checked-boundary/main.ts.json new file mode 100644 index 000000000..0023377d3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-checked-boundary/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/symbol-checked-boundary/consumer.js", + "/tests/corpus/symbol-checked-boundary/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-class-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-class-fields.ts.json new file mode 100644 index 000000000..b9bd40c91 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-class-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/symbol-class-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-class-fields/main.cjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-class-fields/main.cjs.json new file mode 100644 index 000000000..0897642fe --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-class-fields/main.cjs.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/symbol-class-fields/counter.cjs", + "/tests/corpus/symbol-class-fields/main.cjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-class-methods/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-class-methods/main.ts.json new file mode 100644 index 000000000..c0e33f967 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-class-methods/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/symbol-class-methods/keys.ts", + "/tests/corpus/symbol-class-methods/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-fields-deferred-factory.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-fields-deferred-factory.ts.json new file mode 100644 index 000000000..7709dc3ae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-fields-deferred-factory.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/symbol-fields-deferred-factory.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-fields-inferred.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-fields-inferred.js.json new file mode 100644 index 000000000..acd88e600 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-fields-inferred.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/symbol-fields-inferred.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-object-properties/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-object-properties/main.js.json new file mode 100644 index 000000000..5f32c02e6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/symbol-object-properties/main.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/symbol-object-properties/main.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/synchronous-callback-lifetimes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/synchronous-callback-lifetimes.ts.json new file mode 100644 index 000000000..69b014ade --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/synchronous-callback-lifetimes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/synchronous-callback-lifetimes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/terminal-stream-properties.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/terminal-stream-properties.ts.json new file mode 100644 index 000000000..327e4d240 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/terminal-stream-properties.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/terminal-stream-properties.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/text-codec-values/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/text-codec-values/main.ts.json new file mode 100644 index 000000000..6db9a1575 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/text-codec-values/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/corpus/text-codec-values/shared.ts", + "/tests/corpus/text-codec-values/user.ts", + "/tests/corpus/text-codec-values/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/text-codec-var.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/text-codec-var.ts.json new file mode 100644 index 000000000..2c4dde578 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/text-codec-var.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/text-codec-var.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/text-encode-into-boundaries.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/text-encode-into-boundaries.ts.json new file mode 100644 index 000000000..adf22bc96 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/text-encode-into-boundaries.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/text-encode-into-boundaries.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/timers-clear-many.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/timers-clear-many.ts.json new file mode 100644 index 000000000..92fa616c5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/timers-clear-many.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/timers-clear-many.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-and-string-search.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-and-string-search.ts.json new file mode 100644 index 000000000..523064c3e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-and-string-search.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/tuple-and-string-search.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-array-union.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-array-union.ts.json new file mode 100644 index 000000000..5079e9b84 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-array-union.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/tuple-array-union.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-callback-visitation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-callback-visitation.ts.json new file mode 100644 index 000000000..de99346c7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-callback-visitation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/tuple-callback-visitation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-forof-visitation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-forof-visitation.ts.json new file mode 100644 index 000000000..0983f3353 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/tuple-forof-visitation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/tuple-forof-visitation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-bulk-conversion.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-bulk-conversion.mjs.json new file mode 100644 index 000000000..7f377b8fa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-bulk-conversion.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-array-bulk-conversion.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-byte-io.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-byte-io.js.json new file mode 100644 index 000000000..72aa42c91 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-byte-io.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-array-byte-io.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-checked-index.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-checked-index.js.json new file mode 100644 index 000000000..110149d68 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-checked-index.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-array-checked-index.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-alias.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-alias.ts.json new file mode 100644 index 000000000..3895dc013 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-alias.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-array-constructor-alias.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-identity.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-identity.js.json new file mode 100644 index 000000000..c3437fbfc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-identity.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-array-constructor-identity.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-union.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-union.ts.json new file mode 100644 index 000000000..dd6fded1d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-union.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-array-constructor-union.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-values.mjs.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-values.mjs.json new file mode 100644 index 000000000..025b9eba8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-constructor-values.mjs.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-array-constructor-values.mjs" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-dynamic-methods.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-dynamic-methods.js.json new file mode 100644 index 000000000..266734b71 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-dynamic-methods.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-array-dynamic-methods.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-integer-widths.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-integer-widths.ts.json new file mode 100644 index 000000000..0824ccd20 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-integer-widths.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-array-integer-widths.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-nan-coded-reads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-nan-coded-reads.ts.json new file mode 100644 index 000000000..6715e6218 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-nan-coded-reads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-array-nan-coded-reads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-numeric-import.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-numeric-import.ts.json new file mode 100644 index 000000000..3c9c6b9a5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-numeric-import.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-array-numeric-import.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-present-reads.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-present-reads.ts.json new file mode 100644 index 000000000..283ce25c3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-present-reads.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-array-present-reads.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-reversed-storage.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-reversed-storage.ts.json new file mode 100644 index 000000000..26618d6e1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-reversed-storage.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-array-reversed-storage.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-unknown.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-unknown.ts.json new file mode 100644 index 000000000..920462bb7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-array-unknown.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-array-unknown.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-collection-iterator-references.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-collection-iterator-references.ts.json new file mode 100644 index 000000000..b46a047ed --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-collection-iterator-references.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-collection-iterator-references.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-collection-iterators.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-collection-iterators.ts.json new file mode 100644 index 000000000..84245ce8c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-collection-iterators.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-collection-iterators.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-collection-views/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-collection-views/main.ts.json new file mode 100644 index 000000000..c63d1e568 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-collection-views/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/corpus/typed-collection-views/use.mjs", + "/tests/corpus/typed-collection-views/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-index-arguments.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-index-arguments.ts.json new file mode 100644 index 000000000..26899b194 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-index-arguments.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-index-arguments.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-prototype-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-prototype-methods.ts.json new file mode 100644 index 000000000..53cf7dc7f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-prototype-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-prototype-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-rest-callables.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-rest-callables.ts.json new file mode 100644 index 000000000..6278a14b0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-rest-callables.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-rest-callables.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-rest-filtered-return.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-rest-filtered-return.ts.json new file mode 100644 index 000000000..8ef7bf2b2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typed-rest-filtered-return.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typed-rest-filtered-return.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typedarray-native-inputs.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typedarray-native-inputs.js.json new file mode 100644 index 000000000..799e8ceb2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typedarray-native-inputs.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typedarray-native-inputs.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typeof-checked-comparison.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typeof-checked-comparison.js.json new file mode 100644 index 000000000..61c29f893 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/typeof-checked-comparison.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/typeof-checked-comparison.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/uint8array-sort-domains.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/uint8array-sort-domains.ts.json new file mode 100644 index 000000000..9e18ee3d7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/uint8array-sort-domains.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/uint8array-sort-domains.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unicode-case-paths.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unicode-case-paths.ts.json new file mode 100644 index 000000000..43fb477ab --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unicode-case-paths.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/unicode-case-paths.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unicode-process-argv.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unicode-process-argv.ts.json new file mode 100644 index 000000000..5148bd58f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unicode-process-argv.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/unicode-process-argv.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-discriminant-width.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-discriminant-width.ts.json new file mode 100644 index 000000000..fb6d5a7df --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-discriminant-width.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/union-discriminant-width.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-literal-scalar-discriminants.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-literal-scalar-discriminants.ts.json new file mode 100644 index 000000000..27c8f4b29 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-literal-scalar-discriminants.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/union-literal-scalar-discriminants.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-literal-slot-conversion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-literal-slot-conversion.ts.json new file mode 100644 index 000000000..dfb1b8065 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-literal-slot-conversion.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/union-literal-slot-conversion.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-nested-layout-discriminant.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-nested-layout-discriminant.ts.json new file mode 100644 index 000000000..369fefb62 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-nested-layout-discriminant.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/union-nested-layout-discriminant.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-optional-semantic-identity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-optional-semantic-identity.ts.json new file mode 100644 index 000000000..d93c82010 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-optional-semantic-identity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/union-optional-semantic-identity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-record-clone.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-record-clone.ts.json new file mode 100644 index 000000000..37ebd2869 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-record-clone.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/union-record-clone.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-record-structural-copy.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-record-structural-copy.ts.json new file mode 100644 index 000000000..fcf345347 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-record-structural-copy.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/union-record-structural-copy.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-reference-comparison.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-reference-comparison.ts.json new file mode 100644 index 000000000..04b35be16 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/union-reference-comparison.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/union-reference-comparison.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-array-holes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-array-holes.ts.json new file mode 100644 index 000000000..d7330b05b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-array-holes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/unknown-array-holes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-collections.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-collections.ts.json new file mode 100644 index 000000000..9582aff09 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-collections.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/unknown-collections.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-object-enumeration.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-object-enumeration.ts.json new file mode 100644 index 000000000..1127a90bd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-object-enumeration.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/unknown-object-enumeration.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-record-views.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-record-views.ts.json new file mode 100644 index 000000000..053db198e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/unknown-record-views.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/unknown-record-views.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/url-runtime-base.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/url-runtime-base.ts.json new file mode 100644 index 000000000..5fdc67501 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/url-runtime-base.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/url-runtime-base.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/utf8-span-decoding.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/utf8-span-decoding.ts.json new file mode 100644 index 000000000..e9ba14626 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/utf8-span-decoding.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/utf8-span-decoding.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/util-parseargs-wrapped/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/util-parseargs-wrapped/main.ts.json new file mode 100644 index 000000000..2f28002dd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/util-parseargs-wrapped/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/util-parseargs-wrapped/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-map-array-buffer.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-map-array-buffer.ts.json new file mode 100644 index 000000000..284111943 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-map-array-buffer.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/weak-map-array-buffer.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-map-fresh-array.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-map-fresh-array.js.json new file mode 100644 index 000000000..d65b35fd3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-map-fresh-array.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/weak-map-fresh-array.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-map-native.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-map-native.js.json new file mode 100644 index 000000000..9a9c5b93d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-map-native.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/weak-map-native.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-native-class-identity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-native-class-identity.ts.json new file mode 100644 index 000000000..46aae471d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-native-class-identity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/weak-native-class-identity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-set-native.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-set-native.js.json new file mode 100644 index 000000000..92b7a1b91 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/weak-set-native.js.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/weak-set-native.js" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/worker-class-instance-clone.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/worker-class-instance-clone.ts.json new file mode 100644 index 000000000..fcb8efa0d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/worker-class-instance-clone.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/worker-class-instance-clone.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/accessors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/accessors.ts.json new file mode 100644 index 000000000..82a40722c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/accessors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/accessors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/any-unit-exit.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/any-unit-exit.ts.json new file mode 100644 index 000000000..39096619c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/any-unit-exit.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/any-unit-exit.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/any.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/any.ts.json new file mode 100644 index 000000000..61ffb679b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/any.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/any.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/arrow-bind.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/arrow-bind.ts.json new file mode 100644 index 000000000..7edad755d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/arrow-bind.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/arrow-bind.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/assert-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/assert-fences.ts.json new file mode 100644 index 000000000..2df3cee35 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/assert-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/assert-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/async-iterator-handles.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/async-iterator-handles.ts.json new file mode 100644 index 000000000..57d9e0674 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/async-iterator-handles.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/async-iterator-handles.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/bigint-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/bigint-fences.ts.json new file mode 100644 index 000000000..b078aeb50 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/bigint-fences.ts.json @@ -0,0 +1,16 @@ +{ + "order": [ + "/tests/diagnostics/bigint-fences.ts" + ], + "diags": [ + { + "code": "SC0001", + "message": "Expected 1 arguments, but got 2.", + "loc": { + "file": "/tests/diagnostics/bigint-fences.ts", + "start": 439, + "end": 455 + } + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/blocked-binding-cascade.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/blocked-binding-cascade.ts.json new file mode 100644 index 000000000..8ce83932b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/blocked-binding-cascade.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/blocked-binding-cascade.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/catch-bindings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/catch-bindings.ts.json new file mode 100644 index 000000000..f8a02fb3b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/catch-bindings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/catch-bindings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/checker-panic-infinity.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/checker-panic-infinity.ts.json new file mode 100644 index 000000000..a6e2e89b5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/checker-panic-infinity.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/checker-panic-infinity.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/checker-panic-tuple.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/checker-panic-tuple.ts.json new file mode 100644 index 000000000..4a57502d9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/checker-panic-tuple.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/checker-panic-tuple.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/child-process.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/child-process.ts.json new file mode 100644 index 000000000..04397b1ed --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/child-process.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/child-process.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-esm-lexer-require-reached/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-esm-lexer-require-reached/main.js.json new file mode 100644 index 000000000..730ca0580 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-esm-lexer-require-reached/main.js.json @@ -0,0 +1,19 @@ +{ + "order": [ + "/tests/diagnostics/cjs-esm-lexer-require-reached/table.cjs", + "/tests/diagnostics/cjs-esm-lexer-require-reached/mid.mjs", + "/tests/diagnostics/cjs-esm-lexer-require-reached/main.js" + ], + "diags": [ + { + "code": "SC1013", + "message": "a named import of a CommonJS export Node's lexer cannot detect, reached through require() of an ES module (Node throws its SyntaxError mid-evaluation at that require; import the CommonJS module's default and read members off it instead) is not supported yet", + "loc": { + "file": "/tests/diagnostics/cjs-esm-lexer-require-reached/mid.mjs", + "start": 9, + "end": 10 + }, + "milestone": "later" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-module-mutation/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-module-mutation/main.ts.json new file mode 100644 index 000000000..c89b5354d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-module-mutation/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/cjs-module-mutation/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-require-cycle/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-require-cycle/main.js.json new file mode 100644 index 000000000..a54923bcf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-require-cycle/main.js.json @@ -0,0 +1,20 @@ +{ + "order": [ + "/tests/diagnostics/cjs-require-cycle/b.js", + "/tests/diagnostics/cjs-require-cycle/a.js", + "/tests/diagnostics/cjs-require-cycle/main.js" + ], + "diags": [ + { + "code": "SC1016", + "message": "circular imports (/tests/diagnostics/cjs-require-cycle/a.js → /tests/diagnostics/cjs-require-cycle/b.js → /tests/diagnostics/cjs-require-cycle/a.js; the cycle closes through a require() edge) are not supported yet", + "loc": { + "file": "/tests/diagnostics/cjs-require-cycle/a.js", + "start": 0, + "end": 0 + }, + "milestone": "later", + "hint": "ES-module cycles of let/const/function bindings compile as-is; rewrite the named construct (a named import instead of a namespace, a const instead of a default-export expression or var, a class declared before the code that can reach it) or break the named edge" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-require-esm-type-link/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-require-esm-type-link/main.js.json new file mode 100644 index 000000000..d097017a1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-require-esm-type-link/main.js.json @@ -0,0 +1,19 @@ +{ + "order": [ + "/tests/diagnostics/cjs-require-esm-type-link/types.mts", + "/tests/diagnostics/cjs-require-esm-type-link/child.mts", + "/tests/diagnostics/cjs-require-esm-type-link/main.js" + ], + "diags": [ + { + "code": "SC1013", + "message": "a named import of an unavailable export in an ES module reached through require() (Node throws its SyntaxError mid-evaluation at that require; make the import match the module's runtime exports) is not supported yet", + "loc": { + "file": "/tests/diagnostics/cjs-require-esm-type-link/child.mts", + "start": 9, + "end": 14 + }, + "milestone": "later" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-require-tdz/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-require-tdz/main.js.json new file mode 100644 index 000000000..d15d404ae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cjs-require-tdz/main.js.json @@ -0,0 +1,17 @@ +{ + "order": [ + "/tests/diagnostics/cjs-require-tdz/main.js" + ], + "diags": [ + { + "code": "SC1013", + "message": "require() below code that can reach its binding 'greet' (Node initializes the binding AT the require and throws ReferenceError on any earlier access, which is not modeled — move the require above the code that can run first) is not supported yet", + "loc": { + "file": "/tests/diagnostics/cjs-require-tdz/main.js", + "start": 336, + "end": 367 + }, + "milestone": "later" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-decorators.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-decorators.ts.json new file mode 100644 index 000000000..25f0fb629 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-decorators.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/class-decorators.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-interface-refinements.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-interface-refinements.ts.json new file mode 100644 index 000000000..66b59b8c4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-interface-refinements.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/class-interface-refinements.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-prototype-reflection.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-prototype-reflection.ts.json new file mode 100644 index 000000000..67719659b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-prototype-reflection.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/class-prototype-reflection.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-values.ts.json new file mode 100644 index 000000000..09b4b15dd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/class-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/class-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/collection-iterator-helpers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/collection-iterator-helpers.ts.json new file mode 100644 index 000000000..396e6370c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/collection-iterator-helpers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/collection-iterator-helpers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/collection-views.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/collection-views.ts.json new file mode 100644 index 000000000..59a2c61c3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/collection-views.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/collection-views.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/component-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/component-fences.ts.json new file mode 100644 index 000000000..501b4ac87 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/component-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/component-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/comptime.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/comptime.ts.json new file mode 100644 index 000000000..4d32d30bc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/comptime.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/comptime.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/create-require.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/create-require.ts.json new file mode 100644 index 000000000..e18e02602 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/create-require.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/create-require.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-class-early/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-class-early/main.ts.json new file mode 100644 index 000000000..d5df56b4d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-class-early/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/diagnostics/cycle-class-early/dogs.ts", + "/tests/diagnostics/cycle-class-early/pets.ts", + "/tests/diagnostics/cycle-class-early/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-default-export/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-default-export/main.ts.json new file mode 100644 index 000000000..da64525d3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-default-export/main.ts.json @@ -0,0 +1,20 @@ +{ + "order": [ + "/tests/diagnostics/cycle-default-export/b.ts", + "/tests/diagnostics/cycle-default-export/a.ts", + "/tests/diagnostics/cycle-default-export/main.ts" + ], + "diags": [ + { + "code": "SC1016", + "message": "circular imports (/tests/diagnostics/cycle-default-export/a.ts → /tests/diagnostics/cycle-default-export/b.ts → /tests/diagnostics/cycle-default-export/a.ts; the default export expression at /tests/diagnostics/cycle-default-export/a.ts:2 has no initialization state inside the cycle) are not supported yet", + "loc": { + "file": "/tests/diagnostics/cycle-default-export/a.ts", + "start": 0, + "end": 0 + }, + "milestone": "later", + "hint": "ES-module cycles of let/const/function bindings compile as-is; rewrite the named construct (a named import instead of a namespace, a const instead of a default-export expression or var, a class declared before the code that can reach it) or break the named edge" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-namespace-import/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-namespace-import/main.ts.json new file mode 100644 index 000000000..ca21f7afa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-namespace-import/main.ts.json @@ -0,0 +1,20 @@ +{ + "order": [ + "/tests/diagnostics/cycle-namespace-import/b.ts", + "/tests/diagnostics/cycle-namespace-import/a.ts", + "/tests/diagnostics/cycle-namespace-import/main.ts" + ], + "diags": [ + { + "code": "SC1016", + "message": "circular imports (/tests/diagnostics/cycle-namespace-import/a.ts → /tests/diagnostics/cycle-namespace-import/b.ts → /tests/diagnostics/cycle-namespace-import/a.ts; the namespace import 'helpers' at /tests/diagnostics/cycle-namespace-import/a.ts:1 names a module of the cycle) are not supported yet", + "loc": { + "file": "/tests/diagnostics/cycle-namespace-import/a.ts", + "start": 0, + "end": 0 + }, + "milestone": "later", + "hint": "ES-module cycles of let/const/function bindings compile as-is; rewrite the named construct (a named import instead of a namespace, a const instead of a default-export expression or var, a class declared before the code that can reach it) or break the named edge" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-var-early/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-var-early/main.ts.json new file mode 100644 index 000000000..e64cb8d40 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/cycle-var-early/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/diagnostics/cycle-var-early/b.ts", + "/tests/diagnostics/cycle-var-early/a.ts", + "/tests/diagnostics/cycle-var-early/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dataview.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dataview.ts.json new file mode 100644 index 000000000..8cf4c3b83 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dataview.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/dataview.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/date-formatters.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/date-formatters.ts.json new file mode 100644 index 000000000..b0b3f8a93 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/date-formatters.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/date-formatters.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/date-union-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/date-union-fences.ts.json new file mode 100644 index 000000000..cf6ad7398 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/date-union-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/date-union-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deep-binary-nesting.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deep-binary-nesting.ts.json new file mode 100644 index 000000000..b73bf26e9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deep-binary-nesting.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/deep-binary-nesting.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deep-nesting-preflight.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deep-nesting-preflight.ts.json new file mode 100644 index 000000000..334ca4afd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deep-nesting-preflight.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/deep-nesting-preflight.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/default-export.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/default-export.ts.json new file mode 100644 index 000000000..7b0f01bc3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/default-export.ts.json @@ -0,0 +1,27 @@ +{ + "order": [ + "/tests/diagnostics/default-export.ts" + ], + "diags": [ + { + "code": "SC0001", + "message": "Export assignment cannot be used when targeting ECMAScript modules. Consider using 'export default' or another module format instead.", + "loc": { + "file": "/tests/diagnostics/default-export.ts", + "start": 439, + "end": 456 + } + }, + { + "code": "SC1012", + "message": "export = assignments are not supported yet", + "loc": { + "file": "/tests/diagnostics/default-export.ts", + "start": 439, + "end": 456 + }, + "milestone": "later", + "hint": "use named exports: export function f() {} / import { f } from \"./m\"" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deferred-class-binding/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deferred-class-binding/main.ts.json new file mode 100644 index 000000000..2b4c8f810 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deferred-class-binding/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/diagnostics/deferred-class-binding/crate.ts", + "/tests/diagnostics/deferred-class-binding/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deferred-class-receiver/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deferred-class-receiver/main.ts.json new file mode 100644 index 000000000..8550a8c55 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/deferred-class-receiver/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/diagnostics/deferred-class-receiver/shelf.ts", + "/tests/diagnostics/deferred-class-receiver/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/delete-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/delete-fences.ts.json new file mode 100644 index 000000000..a3d4c582c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/delete-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/delete-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/destructuring-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/destructuring-fences.ts.json new file mode 100644 index 000000000..2d8b7ba6d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/destructuring-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/destructuring-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-import-static.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-import-static.ts.json new file mode 100644 index 000000000..75a4b788d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-import-static.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/dynamic-import-static.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-import/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-import/main.ts.json new file mode 100644 index 000000000..38ed22f82 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-import/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/diagnostics/dynamic-import/helper.ts", + "/tests/diagnostics/dynamic-import/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-representable-types.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-representable-types.ts.json new file mode 100644 index 000000000..73312c518 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-representable-types.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/dynamic-representable-types.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-surface.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-surface.ts.json new file mode 100644 index 000000000..3977344c2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/dynamic-surface.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/dynamic-surface.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-internal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-internal.ts.json new file mode 100644 index 000000000..6753ebe42 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-internal.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/ee-computed-internal.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-listeners.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-listeners.ts.json new file mode 100644 index 000000000..e5e275d35 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-listeners.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/ee-computed-listeners.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-stream-internal.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-stream-internal.ts.json new file mode 100644 index 000000000..fc4a63408 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-stream-internal.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/ee-computed-stream-internal.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-unrestricted.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-unrestricted.ts.json new file mode 100644 index 000000000..5fddee91d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-computed-unrestricted.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/ee-computed-unrestricted.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-emit-override.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-emit-override.ts.json new file mode 100644 index 000000000..792103790 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ee-emit-override.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/ee-emit-override.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/enums.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/enums.ts.json new file mode 100644 index 000000000..2cf5008f7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/enums.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/enums.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/es2025-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/es2025-fences.ts.json new file mode 100644 index 000000000..0568e5f27 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/es2025-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/es2025-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/esm-syntax-commonjs/main.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/esm-syntax-commonjs/main.js.json new file mode 100644 index 000000000..18552996c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/esm-syntax-commonjs/main.js.json @@ -0,0 +1,18 @@ +{ + "order": [ + "/tests/diagnostics/esm-syntax-commonjs/main.js" + ], + "diags": [ + { + "code": "SC1013", + "message": "Node classifies this file as CommonJS, where this ES-module syntax marker is a SyntaxError", + "loc": { + "file": "/tests/diagnostics/esm-syntax-commonjs/main.js", + "start": 0, + "end": 10 + }, + "milestone": "later", + "hint": "use a .mjs/.mts extension or set the nearest package.json's \"type\" to \"module\"" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/exceptions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/exceptions.ts.json new file mode 100644 index 000000000..692ff0bd7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/exceptions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/exceptions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/fetch-static.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/fetch-static.ts.json new file mode 100644 index 000000000..679923135 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/fetch-static.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/fetch-static.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-narrow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-narrow.ts.json new file mode 100644 index 000000000..40d5e462a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-narrow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/filter-narrow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate-dyn.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate-dyn.ts.json new file mode 100644 index 000000000..160ae203d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate-dyn.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/filter-void-predicate-dyn.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate-dynamic.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate-dynamic.ts.json new file mode 100644 index 000000000..f7e2c219e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate-dynamic.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/filter-void-predicate-dynamic.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate-island.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate-island.ts.json new file mode 100644 index 000000000..0ef84e791 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate-island.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/filter-void-predicate-island.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate.ts.json new file mode 100644 index 000000000..22bc61e11 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/filter-void-predicate.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/filter-void-predicate.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/function-forms.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/function-forms.ts.json new file mode 100644 index 000000000..7ca950ac1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/function-forms.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/function-forms.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/function-limits.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/function-limits.ts.json new file mode 100644 index 000000000..eb0e72318 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/function-limits.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/function-limits.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generator-method-overrides.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generator-method-overrides.ts.json new file mode 100644 index 000000000..cd2568ffe --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generator-method-overrides.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/generator-method-overrides.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generic-methods.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generic-methods.ts.json new file mode 100644 index 000000000..19ed4bdcc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generic-methods.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/generic-methods.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generic-signature-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generic-signature-values.ts.json new file mode 100644 index 000000000..411add016 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generic-signature-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/generic-signature-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generic-value-bindings.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generic-value-bindings.ts.json new file mode 100644 index 000000000..e142d11b8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generic-value-bindings.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/generic-value-bindings.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generics.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generics.ts.json new file mode 100644 index 000000000..6bf8367cf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/generics.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/generics.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/http2-module.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/http2-module.ts.json new file mode 100644 index 000000000..8850fe2e6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/http2-module.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/http2-module.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/http2-response-trailers.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/http2-response-trailers.ts.json new file mode 100644 index 000000000..922aaebef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/http2-response-trailers.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/http2-response-trailers.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/identity-collection-keys.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/identity-collection-keys.ts.json new file mode 100644 index 000000000..da425348e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/identity-collection-keys.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/identity-collection-keys.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-defer-type/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-defer-type/main.ts.json new file mode 100644 index 000000000..c32f4ed1f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-defer-type/main.ts.json @@ -0,0 +1,61 @@ +{ + "order": [ + "/tests/diagnostics/import-defer-type/main.ts" + ], + "diags": [ + { + "code": "SC0001", + "message": "'from' expected.", + "loc": { + "file": "/tests/diagnostics/import-defer-type/main.ts", + "start": 223, + "end": 224 + } + }, + { + "code": "SC0001", + "message": "';' expected.", + "loc": { + "file": "/tests/diagnostics/import-defer-type/main.ts", + "start": 228, + "end": 231 + } + }, + { + "code": "SC0001", + "message": "Unexpected keyword or identifier.", + "loc": { + "file": "/tests/diagnostics/import-defer-type/main.ts", + "start": 232, + "end": 236 + } + }, + { + "code": "SC0001", + "message": "String literal expected.", + "loc": { + "file": "/tests/diagnostics/import-defer-type/main.ts", + "start": 223, + "end": 227 + } + }, + { + "code": "SC0001", + "message": "Cannot find name 'ns1'.", + "loc": { + "file": "/tests/diagnostics/import-defer-type/main.ts", + "start": 228, + "end": 231 + } + }, + { + "code": "SC0001", + "message": "Cannot find name 'from'.", + "loc": { + "file": "/tests/diagnostics/import-defer-type/main.ts", + "start": 232, + "end": 236 + } + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-defer/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-defer/main.ts.json new file mode 100644 index 000000000..05e29cfa0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-defer/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/import-defer/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-equals-require.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-equals-require.ts.json new file mode 100644 index 000000000..42f0c59d4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-equals-require.ts.json @@ -0,0 +1,26 @@ +{ + "order": [ + "/tests/diagnostics/import-equals-require.ts" + ], + "diags": [ + { + "code": "SC0001", + "message": "Import assignment cannot be used when targeting ECMAScript modules. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"', 'import d from \"mod\"', or another module format instead.", + "loc": { + "file": "/tests/diagnostics/import-equals-require.ts", + "start": 178, + "end": 204 + } + }, + { + "code": "SC1013", + "message": "import = require(...) assignments are not supported yet", + "loc": { + "file": "/tests/diagnostics/import-equals-require.ts", + "start": 178, + "end": 204 + }, + "milestone": "later" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-forms/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-forms/main.ts.json new file mode 100644 index 000000000..663d53c28 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-forms/main.ts.json @@ -0,0 +1,51 @@ +{ + "order": [ + "/tests/diagnostics/import-forms/helpers.ts", + "/tests/diagnostics/import-forms/legacy.cjs", + "/tests/diagnostics/import-forms/main.ts" + ], + "diags": [ + { + "code": "SC1012", + "message": "default exports/imports are not supported yet", + "loc": { + "file": "/tests/diagnostics/import-forms/main.ts", + "start": 517, + "end": 519 + }, + "milestone": "later", + "hint": "use named exports: export function f() {} / import { f } from \"./m\"" + }, + { + "code": "SC1013", + "message": "namespace imports of JSON modules are not supported yet", + "loc": { + "file": "/tests/diagnostics/import-forms/main.ts", + "start": 543, + "end": 551 + }, + "milestone": "later" + }, + { + "code": "SC1013", + "message": "namespace imports of CommonJS modules are not supported yet", + "loc": { + "file": "/tests/diagnostics/import-forms/main.ts", + "start": 578, + "end": 589 + }, + "milestone": "later" + }, + { + "code": "SC1014", + "message": "re-exports from packages or builtin modules are not supported yet", + "loc": { + "file": "/tests/diagnostics/import-forms/main.ts", + "start": 759, + "end": 794 + }, + "milestone": "later", + "hint": "export declarations directly: export function f() {}" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-bare.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-bare.ts.json new file mode 100644 index 000000000..b86225f70 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-bare.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/import-meta-bare.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-computed.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-computed.ts.json new file mode 100644 index 000000000..843ff24ee --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-computed.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/import-meta-computed.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-destructure.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-destructure.ts.json new file mode 100644 index 000000000..57465808b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-destructure.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/import-meta-destructure.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-rest.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-rest.ts.json new file mode 100644 index 000000000..86cbb6de6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-rest.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/import-meta-rest.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-write.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-write.ts.json new file mode 100644 index 000000000..57ded8cb4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/import-meta-write.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/import-meta-write.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/imports.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/imports.ts.json new file mode 100644 index 000000000..895900835 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/imports.ts.json @@ -0,0 +1,27 @@ +{ + "order": [ + "/tests/diagnostics/imports.ts" + ], + "diags": [ + { + "code": "SC0001", + "message": "Cannot find module 'some-package' or its corresponding type declarations.", + "loc": { + "file": "/tests/diagnostics/imports.ts", + "start": 26, + "end": 40 + } + }, + { + "code": "SC1010", + "message": "the 'some-package' package (nothing installed resolves it) is not supported yet", + "loc": { + "file": "/tests/diagnostics/imports.ts", + "start": 0, + "end": 41 + }, + "milestone": "M4", + "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/index-signature-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/index-signature-values.ts.json new file mode 100644 index 000000000..43aad271f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/index-signature-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/index-signature-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/inheritance.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/inheritance.ts.json new file mode 100644 index 000000000..7a0dedda0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/inheritance.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/inheritance.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/intersection-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/intersection-values.ts.json new file mode 100644 index 000000000..5051ac04b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/intersection-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/intersection-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/intl-segmenter.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/intl-segmenter.ts.json new file mode 100644 index 000000000..4f0b6e926 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/intl-segmenter.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/intl-segmenter.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/intl.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/intl.ts.json new file mode 100644 index 000000000..a66a212f7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/intl.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/intl.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/invalid-package-config/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/invalid-package-config/main.ts.json new file mode 100644 index 000000000..fd0a37ac9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/invalid-package-config/main.ts.json @@ -0,0 +1,18 @@ +{ + "order": [ + "/tests/diagnostics/invalid-package-config/main.ts" + ], + "diags": [ + { + "code": "SC1013", + "message": "Node cannot load this module because '/tests/diagnostics/invalid-package-config/package.json' is an invalid package configuration (ERR_INVALID_PACKAGE_CONFIG)", + "loc": { + "file": "/tests/diagnostics/invalid-package-config/main.ts", + "start": 0, + "end": 0 + }, + "milestone": "later", + "hint": "fix the nearest package.json so it contains valid JSON" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/island-boundary-slots.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/island-boundary-slots.ts.json new file mode 100644 index 000000000..0e57fa711 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/island-boundary-slots.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/island-boundary-slots.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/island.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/island.ts.json new file mode 100644 index 000000000..286864769 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/island.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/island.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/iterator-slot-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/iterator-slot-fences.ts.json new file mode 100644 index 000000000..ac9506692 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/iterator-slot-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/iterator-slot-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsdoc-import-require.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsdoc-import-require.js.json new file mode 100644 index 000000000..9c2873088 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/jsdoc-import-require.js.json @@ -0,0 +1,25 @@ +{ + "order": [ + "/tests/diagnostics/jsdoc-import-require.js" + ], + "diags": [ + { + "code": "SC0001", + "message": "'from' expected.", + "loc": { + "file": "/tests/diagnostics/jsdoc-import-require.js", + "start": 14, + "end": 15 + } + }, + { + "code": "SC0001", + "message": "String literal expected.", + "loc": { + "file": "/tests/diagnostics/jsdoc-import-require.js", + "start": 14, + "end": 33 + } + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-dyn.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-dyn.ts.json new file mode 100644 index 000000000..3552e354e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-dyn.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/json-dyn.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-module-comment/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-module-comment/main.ts.json new file mode 100644 index 000000000..31db9e52a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-module-comment/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/json-module-comment/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-modules/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-modules/main.ts.json new file mode 100644 index 000000000..fdb1fe470 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-modules/main.ts.json @@ -0,0 +1,18 @@ +{ + "order": [ + "/tests/diagnostics/json-modules/main.ts" + ], + "diags": [ + { + "code": "SC1012", + "message": "named imports from JSON modules are not supported yet", + "loc": { + "file": "/tests/diagnostics/json-modules/main.ts", + "start": 135, + "end": 146 + }, + "milestone": "later", + "hint": "use named exports: export function f() {} / import { f } from \"./m\"" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-shape/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-shape/main.ts.json new file mode 100644 index 000000000..b27dbdaea --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/json-shape/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/json-shape/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-boundaries.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-boundaries.ts.json new file mode 100644 index 000000000..c173b57c8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-class-boundaries.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/local-class-boundaries.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-require-binding-esm.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-require-binding-esm.js.json new file mode 100644 index 000000000..88598e096 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/local-require-binding-esm.js.json @@ -0,0 +1,17 @@ +{ + "order": [ + "/tests/diagnostics/local-require-binding-esm.js" + ], + "diags": [ + { + "code": "SC1013", + "message": "calls through a source binding named 'require' (this spelling is reserved for CommonJS/createRequire module edges — rename the binding) is not supported yet", + "loc": { + "file": "/tests/diagnostics/local-require-binding-esm.js", + "start": 80, + "end": 100 + }, + "milestone": "later" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/maps-surface.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/maps-surface.ts.json new file mode 100644 index 000000000..4f502ae6e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/maps-surface.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/maps-surface.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/maps.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/maps.ts.json new file mode 100644 index 000000000..e9320c35c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/maps.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/maps.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/merged-namespace-collect-probe.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/merged-namespace-collect-probe.ts.json new file mode 100644 index 000000000..89840f628 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/merged-namespace-collect-probe.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/merged-namespace-collect-probe.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/mixed-compare.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/mixed-compare.ts.json new file mode 100644 index 000000000..f5ca05638 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/mixed-compare.ts.json @@ -0,0 +1,25 @@ +{ + "order": [ + "/tests/diagnostics/mixed-compare.ts" + ], + "diags": [ + { + "code": "SC0001", + "message": "This comparison appears to be unintentional because the types 'true' and 'false' have no overlap.", + "loc": { + "file": "/tests/diagnostics/mixed-compare.ts", + "start": 70, + "end": 84 + } + }, + { + "code": "SC0001", + "message": "Operator '<' cannot be applied to types 'string' and 'number'.", + "loc": { + "file": "/tests/diagnostics/mixed-compare.ts", + "start": 122, + "end": 127 + } + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/mixins.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/mixins.ts.json new file mode 100644 index 000000000..cbbf43cdb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/mixins.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/mixins.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/module-out-of-scope.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/module-out-of-scope.ts.json new file mode 100644 index 000000000..76985356e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/module-out-of-scope.ts.json @@ -0,0 +1,127 @@ +{ + "order": [ + "/tests/diagnostics/module-out-of-scope.ts" + ], + "diags": [ + { + "code": "SC0001", + "message": "Cannot find name 'node:v8'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.", + "loc": { + "file": "/tests/diagnostics/module-out-of-scope.ts", + "start": 381, + "end": 390 + } + }, + { + "code": "SC0001", + "message": "Cannot find name 'domain'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.", + "loc": { + "file": "/tests/diagnostics/module-out-of-scope.ts", + "start": 415, + "end": 423 + } + }, + { + "code": "SC0001", + "message": "Cannot find name 'node:sqlite'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.", + "loc": { + "file": "/tests/diagnostics/module-out-of-scope.ts", + "start": 454, + "end": 467 + } + }, + { + "code": "SC0001", + "message": "Cannot find module '_http_common' or its corresponding type declarations.", + "loc": { + "file": "/tests/diagnostics/module-out-of-scope.ts", + "start": 496, + "end": 510 + } + }, + { + "code": "SC0001", + "message": "Cannot find name 'node:inspector'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.", + "loc": { + "file": "/tests/diagnostics/module-out-of-scope.ts", + "start": 533, + "end": 549 + } + }, + { + "code": "SC0001", + "message": "Cannot find name 'node:stream/web'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig.", + "loc": { + "file": "/tests/diagnostics/module-out-of-scope.ts", + "start": 582, + "end": 599 + } + }, + { + "code": "SC1010", + "message": "the 'node:v8' module (it observes V8 engine internals — heap statistics and snapshots, GC and CPU profiles, serialize/deserialize — and a compiled binary embeds no V8 engine to observe) is not supported yet", + "loc": { + "file": "/tests/diagnostics/module-out-of-scope.ts", + "start": 347, + "end": 391 + }, + "milestone": "M4", + "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" + }, + { + "code": "SC1010", + "message": "the 'domain' module (deprecated in Node and slated for removal; its implicit error interception hooks every async callback at engine level, which is not modeled) is not supported yet", + "loc": { + "file": "/tests/diagnostics/module-out-of-scope.ts", + "start": 392, + "end": 424 + }, + "milestone": "M4", + "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" + }, + { + "code": "SC1010", + "message": "the 'node:sqlite' module (it wraps the SQLite library bundled into the node executable, and scriptc binaries bundle no SQLite engine) is not supported yet", + "loc": { + "file": "/tests/diagnostics/module-out-of-scope.ts", + "start": 425, + "end": 468 + }, + "milestone": "M4", + "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" + }, + { + "code": "SC1010", + "message": "the '_http_common' module (a Node-internal module: it exposes Node's own implementation objects, which the scriptc runtime does not replicate) is not supported yet", + "loc": { + "file": "/tests/diagnostics/module-out-of-scope.ts", + "start": 469, + "end": 511 + }, + "milestone": "M4", + "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" + }, + { + "code": "SC1010", + "message": "the 'node:inspector' module (it drives the V8 inspector protocol — debugger, profiler, heap access — and a compiled binary embeds no V8 engine to inspect) is not supported yet", + "loc": { + "file": "/tests/diagnostics/module-out-of-scope.ts", + "start": 512, + "end": 550 + }, + "milestone": "M4", + "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" + }, + { + "code": "SC1010", + "message": "the 'node:stream/web' module is not supported yet", + "loc": { + "file": "/tests/diagnostics/module-out-of-scope.ts", + "start": 551, + "end": 600 + }, + "milestone": "M4", + "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/module-resolution-introspection.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/module-resolution-introspection.ts.json new file mode 100644 index 000000000..0503cddd1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/module-resolution-introspection.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/module-resolution-introspection.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/multiple-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/multiple-errors.ts.json new file mode 100644 index 000000000..8df152231 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/multiple-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/multiple-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/namespaces.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/namespaces.ts.json new file mode 100644 index 000000000..93d2d8ff2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/namespaces.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/namespaces.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/new-target-field-initializer.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/new-target-field-initializer.ts.json new file mode 100644 index 000000000..0043a1fcb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/new-target-field-initializer.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/new-target-field-initializer.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/no-error-assertion-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/no-error-assertion-fences.ts.json new file mode 100644 index 000000000..8f2646cb1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/no-error-assertion-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/no-error-assertion-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/node-fallback-fence.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/node-fallback-fence.ts.json new file mode 100644 index 000000000..3e246585f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/node-fallback-fence.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/node-fallback-fence.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/npm-imports/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/npm-imports/main.ts.json new file mode 100644 index 000000000..1f512c532 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/npm-imports/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/npm-imports/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ns-import-object/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ns-import-object/main.ts.json new file mode 100644 index 000000000..b6c0d8f8e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/ns-import-object/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/diagnostics/ns-import-object/lib.ts", + "/tests/diagnostics/ns-import-object/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/nullish-class-defaults.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/nullish-class-defaults.ts.json new file mode 100644 index 000000000..fc95d38fd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/nullish-class-defaults.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/nullish-class-defaults.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/object-create-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/object-create-fences.ts.json new file mode 100644 index 000000000..d1ca3e8be --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/object-create-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/object-create-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/optional-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/optional-fields.ts.json new file mode 100644 index 000000000..ebd0f79b5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/optional-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/optional-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/options-record.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/options-record.ts.json new file mode 100644 index 000000000..ce7d34063 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/options-record.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/options-record.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/outside-world.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/outside-world.ts.json new file mode 100644 index 000000000..d1d261aa6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/outside-world.ts.json @@ -0,0 +1,25 @@ +{ + "order": [ + "/tests/diagnostics/outside-world.ts" + ], + "diags": [ + { + "code": "SC0001", + "message": "Cannot find name 'document'. Do you need to change your target library? Try changing the 'lib' compiler option to include 'dom'.", + "loc": { + "file": "/tests/diagnostics/outside-world.ts", + "start": 622, + "end": 630 + } + }, + { + "code": "SC0001", + "message": "Cannot find name 'WebSocket'.", + "loc": { + "file": "/tests/diagnostics/outside-world.ts", + "start": 647, + "end": 656 + } + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/overload-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/overload-fences.ts.json new file mode 100644 index 000000000..1515ceeb9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/overload-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/overload-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/overloaded-function-values.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/overloaded-function-values.ts.json new file mode 100644 index 000000000..d514b7ff7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/overloaded-function-values.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/overloaded-function-values.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/pkg-import-fences/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/pkg-import-fences/main.ts.json new file mode 100644 index 000000000..b18eecd2d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/pkg-import-fences/main.ts.json @@ -0,0 +1,40 @@ +{ + "order": [ + "/tests/diagnostics/pkg-import-fences/main.ts" + ], + "diags": [ + { + "code": "SC1010", + "message": "the '#types' import (it resolves only to type declarations — there is no runtime implementation to compile) is not supported yet", + "loc": { + "file": "/tests/diagnostics/pkg-import-fences/main.ts", + "start": 449, + "end": 476 + }, + "milestone": "M4", + "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" + }, + { + "code": "SC1010", + "message": "the 'ambientonly' module (it exists only as an ambient 'declare module' type surface — there is no runtime module to import) is not supported yet", + "loc": { + "file": "/tests/diagnostics/pkg-import-fences/main.ts", + "start": 383, + "end": 415 + }, + "milestone": "M4", + "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" + }, + { + "code": "SC1010", + "message": "the 'patternXmod' module (it exists only as an ambient 'declare module' type surface — there is no runtime module to import) is not supported yet", + "loc": { + "file": "/tests/diagnostics/pkg-import-fences/main.ts", + "start": 416, + "end": 448 + }, + "milestone": "M4", + "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/private-members.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/private-members.ts.json new file mode 100644 index 000000000..2b856620a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/private-members.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/private-members.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/promise-all-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/promise-all-fences.ts.json new file mode 100644 index 000000000..a820e096e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/promise-all-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/promise-all-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/record-width.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/record-width.ts.json new file mode 100644 index 000000000..2361b34b9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/record-width.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/record-width.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/regex.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/regex.ts.json new file mode 100644 index 000000000..22fe7865a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/regex.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/regex.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/retained-generic-rest-order.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/retained-generic-rest-order.ts.json new file mode 100644 index 000000000..e892f4bea --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/retained-generic-rest-order.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/retained-generic-rest-order.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/runtime-optional-capture-chain.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/runtime-optional-capture-chain.ts.json new file mode 100644 index 000000000..a6ee18fc7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/runtime-optional-capture-chain.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/runtime-optional-capture-chain.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/runtime-optional-refined-union.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/runtime-optional-refined-union.ts.json new file mode 100644 index 000000000..a3166d900 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/runtime-optional-refined-union.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/runtime-optional-refined-union.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/self-returning-function.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/self-returning-function.ts.json new file mode 100644 index 000000000..b3a610c55 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/self-returning-function.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/self-returning-function.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/sets.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/sets.ts.json new file mode 100644 index 000000000..9a8a49029 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/sets.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/sets.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/spi-off/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/spi-off/main.ts.json new file mode 100644 index 000000000..dcf211587 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/spi-off/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/spi-off/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/spread-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/spread-fences.ts.json new file mode 100644 index 000000000..f10965b38 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/spread-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/spread-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/spread-runtime-optional.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/spread-runtime-optional.ts.json new file mode 100644 index 000000000..362804dfa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/spread-runtime-optional.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/spread-runtime-optional.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/statements.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/statements.ts.json new file mode 100644 index 000000000..af685f80b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/statements.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/statements.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/static-blocks.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/static-blocks.ts.json new file mode 100644 index 000000000..fdfeb0b34 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/static-blocks.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/static-blocks.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/stdlib-fence.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/stdlib-fence.ts.json new file mode 100644 index 000000000..cc41508ee --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/stdlib-fence.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/stdlib-fence.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/stdlib.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/stdlib.ts.json new file mode 100644 index 000000000..f01d0a367 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/stdlib.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/stdlib.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/text-codec-value.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/text-codec-value.ts.json new file mode 100644 index 000000000..de4f2ce0f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/text-codec-value.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/text-codec-value.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/text-decoder-label.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/text-decoder-label.ts.json new file mode 100644 index 000000000..52ba66478 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/text-decoder-label.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/text-decoder-label.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/top-level-await-commonjs/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/top-level-await-commonjs/main.ts.json new file mode 100644 index 000000000..a4b7ef4be --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/top-level-await-commonjs/main.ts.json @@ -0,0 +1,18 @@ +{ + "order": [ + "/tests/diagnostics/top-level-await-commonjs/main.ts" + ], + "diags": [ + { + "code": "SC1013", + "message": "Node classifies this file as CommonJS, where this ES-module syntax marker is a SyntaxError", + "loc": { + "file": "/tests/diagnostics/top-level-await-commonjs/main.ts", + "start": 15, + "end": 40 + }, + "milestone": "later", + "hint": "use a .mjs/.mts extension or set the nearest package.json's \"type\" to \"module\"" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/top-level-await-implicit-module-nested-require.js.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/top-level-await-implicit-module-nested-require.js.json new file mode 100644 index 000000000..011bf86fb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/top-level-await-implicit-module-nested-require.js.json @@ -0,0 +1,17 @@ +{ + "order": [ + "/tests/diagnostics/top-level-await-implicit-module-nested-require.js" + ], + "diags": [ + { + "code": "SC1013", + "message": "require() in an ES module (Node throws ReferenceError — use import) is not supported yet", + "loc": { + "file": "/tests/diagnostics/top-level-await-implicit-module-nested-require.js", + "start": 114, + "end": 134 + }, + "milestone": "later" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/top-level-await-module-leak/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/top-level-await-module-leak/main.ts.json new file mode 100644 index 000000000..0b8fedbab --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/top-level-await-module-leak/main.ts.json @@ -0,0 +1,18 @@ +{ + "order": [ + "/tests/diagnostics/top-level-await-module-leak/a.ts", + "/tests/diagnostics/top-level-await-module-leak/b.ts", + "/tests/diagnostics/top-level-await-module-leak/main.ts" + ], + "diags": [ + { + "code": "SC0001", + "message": "Cannot find name 'shared'.", + "loc": { + "file": "/tests/diagnostics/top-level-await-module-leak/b.ts", + "start": 37, + "end": 43 + } + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/tuples.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/tuples.ts.json new file mode 100644 index 000000000..4ea3860ce --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/tuples.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/tuples.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/unassigned-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/unassigned-fields.ts.json new file mode 100644 index 000000000..89b0a6599 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/unassigned-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/unassigned-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/union-clone-override-width.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/union-clone-override-width.ts.json new file mode 100644 index 000000000..0d30ae9e6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/union-clone-override-width.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/union-clone-override-width.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/unions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/unions.ts.json new file mode 100644 index 000000000..3f2f30a72 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/unions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/unions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/unrelated-class-assertion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/unrelated-class-assertion.ts.json new file mode 100644 index 000000000..6cf2950ca --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/unrelated-class-assertion.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/unrelated-class-assertion.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/url-mutation-object-plus.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/url-mutation-object-plus.ts.json new file mode 100644 index 000000000..bdba4b6fb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/url-mutation-object-plus.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/url-mutation-object-plus.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/url-mutation-operator.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/url-mutation-operator.ts.json new file mode 100644 index 000000000..6ab0a296d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/url-mutation-operator.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/url-mutation-operator.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/url-mutation-runtime-key.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/url-mutation-runtime-key.ts.json new file mode 100644 index 000000000..a941c0ab5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/url-mutation-runtime-key.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/url-mutation-runtime-key.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/utility-types.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/utility-types.ts.json new file mode 100644 index 000000000..1fa2f024a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/utility-types.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/utility-types.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/var-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/var-fences.ts.json new file mode 100644 index 000000000..a589d1d95 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/var-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/var-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/argv-env.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/argv-env.ts.json new file mode 100644 index 000000000..31782cde1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/argv-env.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/argv-env.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/child-execfile.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/child-execfile.ts.json new file mode 100644 index 000000000..bc506704e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/child-execfile.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/child-execfile.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/child-stdin-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/child-stdin-fences.ts.json new file mode 100644 index 000000000..cfa602a2e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/child-stdin-fences.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/child-stdin-fences.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/child-stdin.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/child-stdin.ts.json new file mode 100644 index 000000000..8db94809f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/child-stdin.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/child-stdin.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/crypto-kdf.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/crypto-kdf.ts.json new file mode 100644 index 000000000..1f3522f29 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/crypto-kdf.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/crypto-kdf.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/deep-equality.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/deep-equality.ts.json new file mode 100644 index 000000000..dcf32ffe1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/deep-equality.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/deep-equality.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/env-files.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/env-files.ts.json new file mode 100644 index 000000000..93b65f7c9 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/env-files.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/env-files.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fenced.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fenced.ts.json new file mode 100644 index 000000000..c72fd329d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fenced.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/fenced.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fetch-static.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fetch-static.ts.json new file mode 100644 index 000000000..26b288d2d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fetch-static.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/fetch-static.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/file-url-conversion.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/file-url-conversion.ts.json new file mode 100644 index 000000000..6042ad9d1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/file-url-conversion.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/file-url-conversion.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-links.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-links.ts.json new file mode 100644 index 000000000..b9f805eb4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-links.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/fs-links.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-statfs.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-statfs.ts.json new file mode 100644 index 000000000..6613d0dc5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-statfs.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/fs-statfs.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-timestamps.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-timestamps.ts.json new file mode 100644 index 000000000..f3af6a13c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/fs-timestamps.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/fs-timestamps.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/import-fences.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/import-fences.ts.json new file mode 100644 index 000000000..c2d6bcbf5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/import-fences.ts.json @@ -0,0 +1,18 @@ +{ + "order": [ + "/tests/fixtures/node-types/import-fences.ts" + ], + "diags": [ + { + "code": "SC1010", + "message": "the 'v8' module (it observes V8 engine internals — heap statistics and snapshots, GC and CPU profiles, serialize/deserialize — and a compiled binary embeds no V8 engine to observe) is not supported yet", + "loc": { + "file": "/tests/fixtures/node-types/import-fences.ts", + "start": 422, + "end": 461 + }, + "milestone": "M4", + "hint": "relative imports (./file, ../dir/file), package.json-mediated project imports (#alias via the imports field, self-name references via exports), installed npm packages (their code runs under --dynamic), and the built-in fs, fs/promises, path, os, url, crypto, zlib, child_process, net, http, tls, https, http2, dgram, dns, util, util/types, string_decoder, querystring, readline, events, stream, stream/promises, stream/consumers, buffer, assert, assert/strict, worker_threads, cluster, tty, async_hooks, timers, timers/promises, diagnostics_channel, perf_hooks, module, and console modules (bare or node:-prefixed) and node:test (node:-prefixed only, like in Node) are supported" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/no-error-assertions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/no-error-assertions.ts.json new file mode 100644 index 000000000..f0de5aa34 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/no-error-assertions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/no-error-assertions.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/path-os.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/path-os.ts.json new file mode 100644 index 000000000..ca97037d8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/path-os.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/path-os.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/stream-capture.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/stream-capture.ts.json new file mode 100644 index 000000000..9f22e4c02 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/stream-capture.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/stream-capture.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/style-text.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/style-text.ts.json new file mode 100644 index 000000000..ef4497914 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/style-text.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/style-text.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/system-errors.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/system-errors.ts.json new file mode 100644 index 000000000..e562371b4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/system-errors.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/system-errors.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/terminal-error-fields.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/terminal-error-fields.ts.json new file mode 100644 index 000000000..6ba18c2fc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/terminal-error-fields.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/terminal-error-fields.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/text-encoding.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/text-encoding.ts.json new file mode 100644 index 000000000..788167ca6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/text-encoding.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/text-encoding.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/text-utilities.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/text-utilities.ts.json new file mode 100644 index 000000000..ab0ac20d0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/text-utilities.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/text-utilities.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/url-factories.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/url-factories.ts.json new file mode 100644 index 000000000..8c9ba0fc5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/url-factories.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/url-factories.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/url-getters.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/url-getters.ts.json new file mode 100644 index 000000000..4a9d41d4d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/url-getters.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/url-getters.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/url-mutation.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/url-mutation.ts.json new file mode 100644 index 000000000..0b48d7766 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/url-mutation.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/url-mutation.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/util-types.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/util-types.ts.json new file mode 100644 index 000000000..ec7e40810 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/node-types/util-types.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/node-types/util-types.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2465-getter-table/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2465-getter-table/main.ts.json new file mode 100644 index 000000000..7cd57ff7c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2465-getter-table/main.ts.json @@ -0,0 +1,16 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/2465-getter-table/main.ts" + ], + "diags": [ + { + "code": "SC0001", + "message": "Module '\"gtable\"' has no exported member 'chunkGhost'.", + "loc": { + "file": "/tests/fixtures/npm/cases/2465-getter-table/main.ts", + "start": 506, + "end": 516 + } + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2466-getter-star/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2466-getter-star/main.ts.json new file mode 100644 index 000000000..47907c734 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2466-getter-star/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/2466-getter-star/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2467-star-barrel/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2467-star-barrel/main.ts.json new file mode 100644 index 000000000..03706eb9e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2467-star-barrel/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/2467-star-barrel/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2468-defineprop-exports/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2468-defineprop-exports/main.ts.json new file mode 100644 index 000000000..e802f3dc0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2468-defineprop-exports/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/2468-defineprop-exports/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2469-bundle-offender/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2469-bundle-offender/main.ts.json new file mode 100644 index 000000000..9e681e87f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2469-bundle-offender/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/2469-bundle-offender/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2556-toesm-external/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2556-toesm-external/main.ts.json new file mode 100644 index 000000000..0dc5d9cb3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2556-toesm-external/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/2556-toesm-external/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2557-toesm-drift/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2557-toesm-drift/main.ts.json new file mode 100644 index 000000000..46aee5c9f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/2557-toesm-drift/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/2557-toesm-drift/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/abandoned-handles/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/abandoned-handles/main.ts.json new file mode 100644 index 000000000..64fed86e8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/abandoned-handles/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/abandoned-handles/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/any-chaining/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/any-chaining/main.ts.json new file mode 100644 index 000000000..398c82c11 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/any-chaining/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/any-chaining/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/assert-shims/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/assert-shims/main.ts.json new file mode 100644 index 000000000..13c62ccc6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/assert-shims/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/assert-shims/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/buffer-shims/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/buffer-shims/main.ts.json new file mode 100644 index 000000000..fbf6cb5b6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/buffer-shims/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/buffer-shims/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/builtin-shims/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/builtin-shims/main.ts.json new file mode 100644 index 000000000..77dba2c4d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/builtin-shims/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/builtin-shims/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/bytes-exit/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/bytes-exit/main.ts.json new file mode 100644 index 000000000..8041e9bc6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/bytes-exit/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/bytes-exit/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/callbacks/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/callbacks/main.ts.json new file mode 100644 index 000000000..a786acd7f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/callbacks/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/callbacks/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chain/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chain/main.ts.json new file mode 100644 index 000000000..9641229b2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/chain/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/chain/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-esm-named/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-esm-named/main.ts.json new file mode 100644 index 000000000..3722d142d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-esm-named/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/cjs-esm-named/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-lexer-aligned/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-lexer-aligned/main.ts.json new file mode 100644 index 000000000..c782a059c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-lexer-aligned/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/cjs-lexer-aligned/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-lexer-invisible/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-lexer-invisible/main.ts.json new file mode 100644 index 000000000..c016d3949 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-lexer-invisible/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/cjs-lexer-invisible/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-named/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-named/main.ts.json new file mode 100644 index 000000000..da3e463a8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/cjs-named/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/cjs-named/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/class-construct/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/class-construct/main.ts.json new file mode 100644 index 000000000..ba842b990 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/class-construct/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/class-construct/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/create-require/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/create-require/main.ts.json new file mode 100644 index 000000000..a3a47f0a3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/create-require/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/create-require/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/crypto-shims/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/crypto-shims/main.ts.json new file mode 100644 index 000000000..4458315a6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/crypto-shims/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/crypto-shims/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dotfolder/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dotfolder/main.ts.json new file mode 100644 index 000000000..0e24011a4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dotfolder/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/dotfolder/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dual-entry/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dual-entry/main.ts.json new file mode 100644 index 000000000..bb2691fd3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dual-entry/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/dual-entry/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dual-package-kinds/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dual-package-kinds/main.ts.json new file mode 100644 index 000000000..7f08cbc15 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dual-package-kinds/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/dual-package-kinds/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dynamic-import-local/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dynamic-import-local/main.ts.json new file mode 100644 index 000000000..aca65fea5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dynamic-import-local/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/dynamic-import-local/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dynamic-import/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dynamic-import/main.ts.json new file mode 100644 index 000000000..81900c5d0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/dynamic-import/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/dynamic-import/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esbuild-require/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esbuild-require/main.ts.json new file mode 100644 index 000000000..21dfa8354 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esbuild-require/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/esbuild-require/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esm-entries/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esm-entries/main.ts.json new file mode 100644 index 000000000..a9495bc95 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esm-entries/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/esm-entries/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esm-missing-default/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esm-missing-default/main.ts.json new file mode 100644 index 000000000..2e343e564 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esm-missing-default/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/esm-missing-default/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esm-missing-export/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esm-missing-export/main.ts.json new file mode 100644 index 000000000..8aa5deb3e --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/esm-missing-export/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/esm-missing-export/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/fetch-destructure/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/fetch-destructure/main.ts.json new file mode 100644 index 000000000..038d96392 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/fetch-destructure/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/fetch-destructure/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/fs-shims/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/fs-shims/main.ts.json new file mode 100644 index 000000000..199c25cb1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/fs-shims/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/fs-shims/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hoisted-workspace/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hoisted-workspace/main.ts.json new file mode 100644 index 000000000..c42a45554 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/hoisted-workspace/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/hoisted-workspace/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/import-refusal/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/import-refusal/main.ts.json new file mode 100644 index 000000000..b155bd87d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/import-refusal/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/import-refusal/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-array-exits/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-array-exits/main.ts.json new file mode 100644 index 000000000..e0c6b83b2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-array-exits/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/island-array-exits/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-instanceof-regexp/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-instanceof-regexp/main.ts.json new file mode 100644 index 000000000..2d4da6e64 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-instanceof-regexp/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/island-instanceof-regexp/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-json-stringify/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-json-stringify/main.ts.json new file mode 100644 index 000000000..35b1c5b57 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-json-stringify/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/island-json-stringify/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-registry/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-registry/main.ts.json new file mode 100644 index 000000000..812d4c7b8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-registry/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/island-registry/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-timers/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-timers/main.ts.json new file mode 100644 index 000000000..b96ba58ab --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-timers/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/island-timers/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-web-plumbing/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-web-plumbing/main.ts.json new file mode 100644 index 000000000..1965753f7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/island-web-plumbing/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/island-web-plumbing/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/jsval-into-dyn/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/jsval-into-dyn/main.ts.json new file mode 100644 index 000000000..a186f4a9b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/jsval-into-dyn/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/jsval-into-dyn/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/jsval-iterate/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/jsval-iterate/main.ts.json new file mode 100644 index 000000000..6778db385 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/jsval-iterate/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/jsval-iterate/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/lazy-traps/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/lazy-traps/main.ts.json new file mode 100644 index 000000000..29b155818 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/lazy-traps/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/lazy-traps/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/misc-shims/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/misc-shims/main.ts.json new file mode 100644 index 000000000..bcd5567ad --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/misc-shims/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/misc-shims/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/namespace/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/namespace/main.ts.json new file mode 100644 index 000000000..076024a41 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/namespace/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/namespace/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-async-events/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-async-events/main.ts.json new file mode 100644 index 000000000..5df104b43 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-async-events/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-async-events/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-commonjs-metadata/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-commonjs-metadata/main.ts.json new file mode 100644 index 000000000..a8e1fab0d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-commonjs-metadata/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-commonjs-metadata/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-crypto-kdf/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-crypto-kdf/main.ts.json new file mode 100644 index 000000000..9683809b7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-crypto-kdf/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-crypto-kdf/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-deep-equality/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-deep-equality/main.ts.json new file mode 100644 index 000000000..0461af59b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-deep-equality/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-deep-equality/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-async/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-async/main.ts.json new file mode 100644 index 000000000..eb956a65f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-async/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-diagnostics-async/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-subscriber-throw/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-subscriber-throw/main.ts.json new file mode 100644 index 000000000..9f452ae9c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-subscriber-throw/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-diagnostics-subscriber-throw/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-tracing/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-tracing/main.ts.json new file mode 100644 index 000000000..2804696a2 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-tracing/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-diagnostics-tracing/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-transform-throw/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-transform-throw/main.ts.json new file mode 100644 index 000000000..b375c9cd0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-diagnostics-transform-throw/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-diagnostics-transform-throw/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-env/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-env/main.ts.json new file mode 100644 index 000000000..ae87133db --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-env/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-env/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-esm-metadata/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-esm-metadata/main.ts.json new file mode 100644 index 000000000..e199aed52 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-esm-metadata/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-esm-metadata/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-event-emitter/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-event-emitter/main.ts.json new file mode 100644 index 000000000..b72ec8a6f --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-event-emitter/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-event-emitter/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-file-url-conversion/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-file-url-conversion/main.ts.json new file mode 100644 index 000000000..56b05e3d4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-file-url-conversion/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-file-url-conversion/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-fs-descriptors/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-fs-descriptors/main.ts.json new file mode 100644 index 000000000..2a86802c6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-fs-descriptors/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-fs-descriptors/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-mime-errors/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-mime-errors/main.ts.json new file mode 100644 index 000000000..23c60cc46 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-mime-errors/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-mime-errors/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-mime/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-mime/main.ts.json new file mode 100644 index 000000000..4af0a61e8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-mime/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-mime/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-no-error-assertions/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-no-error-assertions/main.ts.json new file mode 100644 index 000000000..4edb7f8d6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-no-error-assertions/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-no-error-assertions/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-parseargs/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-parseargs/main.ts.json new file mode 100644 index 000000000..1e33f84da --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-parseargs/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-parseargs/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-promise-timers/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-promise-timers/main.ts.json new file mode 100644 index 000000000..faf649abd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-promise-timers/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-promise-timers/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-string-decoder/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-string-decoder/main.ts.json new file mode 100644 index 000000000..a94e984e3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-string-decoder/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-string-decoder/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-style-text/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-style-text/main.ts.json new file mode 100644 index 000000000..ebe59658a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-style-text/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-style-text/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-system-errors/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-system-errors/main.ts.json new file mode 100644 index 000000000..ab918f70b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-system-errors/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-system-errors/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-text-encoding/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-text-encoding/main.ts.json new file mode 100644 index 000000000..ee6fd7a16 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-text-encoding/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-text-encoding/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-text-utilities/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-text-utilities/main.ts.json new file mode 100644 index 000000000..e0529d7f3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-text-utilities/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-text-utilities/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-timers-unref/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-timers-unref/main.ts.json new file mode 100644 index 000000000..e4b10829a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-timers-unref/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-timers-unref/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-url-authority/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-url-authority/main.ts.json new file mode 100644 index 000000000..3a3bf98cc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-url-authority/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-url-authority/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-url-factories/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-url-factories/main.ts.json new file mode 100644 index 000000000..610194605 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-url-factories/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-url-factories/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-url-mutation/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-url-mutation/main.ts.json new file mode 100644 index 000000000..5be1f6055 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-url-mutation/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-url-mutation/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-util-adapters/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-util-adapters/main.ts.json new file mode 100644 index 000000000..68cf7a817 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-util-adapters/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-util-adapters/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-util-types/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-util-types/main.ts.json new file mode 100644 index 000000000..4e4317dde --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-util-types/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-util-types/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-encoding/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-encoding/main.ts.json new file mode 100644 index 000000000..12784c403 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-encoding/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-web-stream-encoding/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-errors/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-errors/main.ts.json new file mode 100644 index 000000000..7feddcfb4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-errors/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-web-stream-errors/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-lifecycle/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-lifecycle/main.ts.json new file mode 100644 index 000000000..79651fa66 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-lifecycle/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-web-stream-lifecycle/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-pipe-abort/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-pipe-abort/main.ts.json new file mode 100644 index 000000000..d7cd13f3a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-pipe-abort/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-web-stream-pipe-abort/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-pipe-errors/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-pipe-errors/main.ts.json new file mode 100644 index 000000000..2924e5ede --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-pipe-errors/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-web-stream-pipe-errors/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-pipes/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-pipes/main.ts.json new file mode 100644 index 000000000..cd4ad3474 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-pipes/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-web-stream-pipes/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-queues/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-queues/main.ts.json new file mode 100644 index 000000000..36e71b758 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-queues/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-web-stream-queues/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-readable-lifecycle/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-readable-lifecycle/main.ts.json new file mode 100644 index 000000000..044e77768 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-readable-lifecycle/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-web-stream-readable-lifecycle/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-readers/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-readers/main.ts.json new file mode 100644 index 000000000..f0d9ce0d6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-readers/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-web-stream-readers/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-tee/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-tee/main.ts.json new file mode 100644 index 000000000..e0b1412fa --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-tee/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-web-stream-tee/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-transforms/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-transforms/main.ts.json new file mode 100644 index 000000000..f64f71e8c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/node24-web-stream-transforms/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/node24-web-stream-transforms/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/npm-reexport/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/npm-reexport/main.ts.json new file mode 100644 index 000000000..2cef03a8a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/npm-reexport/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/npm-reexport/facade.ts", + "/tests/fixtures/npm/cases/npm-reexport/default-facade.ts", + "/tests/fixtures/npm/cases/npm-reexport/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/package-imports/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/package-imports/main.ts.json new file mode 100644 index 000000000..48e80563b --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/package-imports/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/package-imports/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/promise-bridge-forever/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/promise-bridge-forever/main.ts.json new file mode 100644 index 000000000..f4a7b9bba --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/promise-bridge-forever/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/promise-bridge-forever/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/promise-bridge-unhandled/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/promise-bridge-unhandled/main.ts.json new file mode 100644 index 000000000..8166d1dd0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/promise-bridge-unhandled/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/promise-bridge-unhandled/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/promise-bridge/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/promise-bridge/main.ts.json new file mode 100644 index 000000000..d31288ba1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/promise-bridge/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/promise-bridge/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/scoped-nested/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/scoped-nested/main.ts.json new file mode 100644 index 000000000..b6dc0f6f6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/scoped-nested/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/scoped-nested/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/self-name/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/self-name/main.ts.json new file mode 100644 index 000000000..84dc96479 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/self-name/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/self-name/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/side-effect-order/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/side-effect-order/main.ts.json new file mode 100644 index 000000000..499baf7b1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/side-effect-order/main.ts.json @@ -0,0 +1,7 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/side-effect-order/mid.ts", + "/tests/fixtures/npm/cases/side-effect-order/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/stream-shims/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/stream-shims/main.ts.json new file mode 100644 index 000000000..c9533ed21 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/stream-shims/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/stream-shims/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/top-level-await-pending-exit-code/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/top-level-await-pending-exit-code/main.ts.json new file mode 100644 index 000000000..00aab0093 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/top-level-await-pending-exit-code/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/top-level-await-pending-exit-code/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/top-level-await-pending-exit-listener/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/top-level-await-pending-exit-listener/main.ts.json new file mode 100644 index 000000000..1dfb8359a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/top-level-await-pending-exit-listener/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/top-level-await-pending-exit-listener/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/typed-callbacks/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/typed-callbacks/main.ts.json new file mode 100644 index 000000000..82a39ce9d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/typed-callbacks/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/typed-callbacks/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/util-shims/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/util-shims/main.ts.json new file mode 100644 index 000000000..c2e8326d6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/util-shims/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/util-shims/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/web-streams/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/web-streams/main.ts.json new file mode 100644 index 000000000..41ab409f3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/web-streams/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/web-streams/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/workspace-copied/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/workspace-copied/main.ts.json new file mode 100644 index 000000000..8645778a8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/workspace-copied/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/workspace-copied/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/workspace-linked/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/workspace-linked/main.ts.json new file mode 100644 index 000000000..8974e44dc --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/workspace-linked/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/workspace-linked/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/workspace-unclean/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/workspace-unclean/main.ts.json new file mode 100644 index 000000000..7b3c33cef --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/workspace-unclean/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/workspace-unclean/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/zlib-shims/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/zlib-shims/main.ts.json new file mode 100644 index 000000000..3bf6669c7 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/npm/cases/zlib-shims/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/npm/cases/zlib-shims/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/indexed-loose/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/indexed-loose/main.ts.json new file mode 100644 index 000000000..6511f0966 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/indexed-loose/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/strictness/indexed-loose/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/indexed-strict/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/indexed-strict/main.ts.json new file mode 100644 index 000000000..c9bf26081 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/indexed-strict/main.ts.json @@ -0,0 +1,16 @@ +{ + "order": [ + "/tests/fixtures/strictness/indexed-strict/main.ts" + ], + "diags": [ + { + "code": "SC0001", + "message": "'picked' is possibly 'undefined'.", + "loc": { + "file": "/tests/fixtures/strictness/indexed-strict/main.ts", + "start": 360, + "end": 366 + } + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/json-any-broken/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/json-any-broken/main.ts.json new file mode 100644 index 000000000..0c99db11a --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/json-any-broken/main.ts.json @@ -0,0 +1,16 @@ +{ + "order": [ + "/tests/fixtures/strictness/json-any-broken/main.ts" + ], + "diags": [ + { + "code": "SC0001", + "message": "Type 'string' is not assignable to type 'number'.", + "loc": { + "file": "/tests/fixtures/strictness/json-any-broken/main.ts", + "start": 324, + "end": 325 + } + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/json-any/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/json-any/main.ts.json new file mode 100644 index 000000000..24a3cff01 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/json-any/main.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/fixtures/strictness/json-any/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/null-floor/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/null-floor/main.ts.json new file mode 100644 index 000000000..1d871e3b6 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/null-floor/main.ts.json @@ -0,0 +1,17 @@ +{ + "order": [ + "/tests/fixtures/strictness/null-floor/main.ts" + ], + "diags": [ + { + "code": "SC0002", + "message": "this project's tsconfig disables strictNullChecks, which scriptc requires (null and undefined are modeled as distinct static types; without the knob every type silently includes them)", + "loc": { + "file": "/tests/fixtures/strictness/null-floor/tsconfig.json", + "start": 0, + "end": 0 + }, + "hint": "set \"strictNullChecks\": true (or \"strict\": true) in the project tsconfig" + } + ] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/project-paths/main.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/project-paths/main.ts.json new file mode 100644 index 000000000..18256f6cf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/fixtures/strictness/project-paths/main.ts.json @@ -0,0 +1,8 @@ +{ + "order": [ + "/tests/fixtures/strictness/project-paths/src/exact.ts", + "/tests/fixtures/strictness/project-paths/src/message.ts", + "/tests/fixtures/strictness/project-paths/main.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/order-parity.test.ts b/packages/compiler/test/ts7/order-parity.test.ts index 3f888c5f0..d680ec2a6 100644 --- a/packages/compiler/test/ts7/order-parity.test.ts +++ b/packages/compiler/test/ts7/order-parity.test.ts @@ -2,7 +2,7 @@ * REAL lifecycle through the native (tsgo) frontend and must produce * exactly the RECORDED baseline's preflight diagnostics (code, message * text, span — the full structured diagnostic) and module evaluation - * order (baselines/order-parity.json). + * order (baselines/order-parity/, one file per fixture). * * The baselines were recorded from the typescript@5.9.3 program.ts lane at * the phase-4 flip commit — the last commit where both frontends shipped — @@ -24,7 +24,7 @@ * report upstream before shipping the bump. * 4. Re-record intentionally: SCRIPTC_UPDATE_BASELINES=1 pnpm exec vitest * run packages/compiler/test/ts7/order-parity.test.ts rewrites - * baselines/order-parity.json from the CURRENT native lane; commit it + * baselines/order-parity/ from the CURRENT native lane; commit it * with the behavior delta stated in the message, one bump per commit. * 5. Then the real gates: pnpm build + lint, both vitest lanes uncached, * and the diagnostics snapshots (tests/harness/__snapshots__) — those @@ -38,19 +38,31 @@ * sweep and the upgrade playbook's step 2. */ import { execFile } from "node:child_process"; -import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; +import { + existsSync, + globSync, + mkdirSync, + mkdtempSync, + readFileSync, + rmSync, + writeFileSync, +} from "node:fs"; import { tmpdir } from "node:os"; -import { join } from "node:path"; +import { dirname, join } from "node:path"; import { pathToFileURL } from "node:url"; import { promisify } from "node:util"; import { afterAll, describe, expect, test } from "vitest"; import { checkPreflightTs7 } from "../../src/frontend/program-node.js"; import { Ts7Host } from "../../src/frontend/ts7/program-adapter.js"; import type { ScrDiagnostic } from "../../src/diagnostics/diagnostic.js"; -import { allOrderEntries, orderEntriesUnder } from "../../../../scripts/ts7-order-fixtures.mjs"; +import { + allOrderEntries, + ORDER_BASELINE_DIR, + orderBaselinePath, + orderEntriesUnder, +} from "../../../../scripts/ts7-order-fixtures.mjs"; const repoRoot = join(import.meta.dirname, "../../../.."); -const baselinePath = join(import.meta.dirname, "baselines/order-parity.json"); const UPDATE = process.env["SCRIPTC_UPDATE_BASELINES"] === "1"; interface BaselineEntry { @@ -58,10 +70,6 @@ interface BaselineEntry { diags: ScrDiagnostic[]; } -const baseline = JSON.parse(readFileSync(baselinePath, "utf8")) as { - entries: Record; -}; - /** Machine-independent spelling: absolute repo paths become "/…" in * file fields AND message text (cycle messages embed paths). */ const rel = (s: string): string => @@ -72,6 +80,12 @@ const rel = (s: string): string => const relativeName = (s: string): string => rel(s).replace(/^\//, ""); +/** The recorded answer for a fixture, or undefined when none is recorded. */ +function recordedBaseline(entry: string): BaselineEntry | undefined { + const path = orderBaselinePath(repoRoot, relativeName(entry)); + return existsSync(path) ? (JSON.parse(readFileSync(path, "utf8")) as BaselineEntry) : undefined; +} + const execFileAsync = promisify(execFile); async function nativeAnswers(entries: string[]): Promise { @@ -147,14 +161,22 @@ for (let i = 0; i < entries.length; i += CHUNK) chunks.push(entries.slice(i, i + if (UPDATE) { test("re-record baselines from the current native frontend", async () => { - const record: Record = {}; + const written = new Set(); const all = allEntries(); for (let i = 0; i < all.length; i += CHUNK) { const batch = all.slice(i, i + CHUNK); const answers = await nativeAnswers(batch); - for (let j = 0; j < batch.length; j++) record[rel(batch[j]!)] = answers[j]!; + for (let j = 0; j < batch.length; j++) { + const path = orderBaselinePath(repoRoot, relativeName(batch[j]!)); + mkdirSync(dirname(path), { recursive: true }); + writeFileSync(path, JSON.stringify(answers[j]!, null, 1) + "\n"); + written.add(path); + } + } + // Drop the baselines of fixtures that no longer exist. + for (const path of globSync(join(repoRoot, ORDER_BASELINE_DIR, "**/*.json"))) { + if (!written.has(path)) rmSync(path); } - writeFileSync(baselinePath, JSON.stringify({ entries: record }, null, 1) + "\n"); }, 600_000); } else { describe(`preflight/order canary vs recorded 5.9.3 baselines (${entries.length} entries${FULL ? ", full sweep" : ""})`, () => { @@ -165,7 +187,7 @@ if (UPDATE) { for (let i = 0; i < chunk.length; i++) { const entry = chunk[i]!; const name = relativeName(entry); - const recorded = baseline.entries[rel(entry)]; + const recorded = recordedBaseline(entry); expect( recorded, `${name}: no recorded baseline — new fixture? re-record with SCRIPTC_UPDATE_BASELINES=1 (see the playbook comment)`, diff --git a/scripts/test-ts7.mjs b/scripts/test-ts7.mjs index bad8e557b..e022c1ff5 100644 --- a/scripts/test-ts7.mjs +++ b/scripts/test-ts7.mjs @@ -1,19 +1,16 @@ #!/usr/bin/env node -import { readdirSync, readFileSync } from "node:fs"; +import { existsSync, readdirSync, readFileSync } from "node:fs"; import { dirname, relative, resolve } from "node:path"; import { fileURLToPath } from "node:url"; import { spawnSync } from "node:child_process"; -import { allOrderEntries } from "./ts7-order-fixtures.mjs"; +import { allOrderEntries, orderBaselinePath } from "./ts7-order-fixtures.mjs"; const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), ".."); -const baseline = JSON.parse( - readFileSync(resolve(repoRoot, "packages/compiler/test/ts7/baselines/order-parity.json"), "utf8"), -); const missingBaselines = allOrderEntries(repoRoot) .map((path) => relative(repoRoot, path).replaceAll("\\", "/")) - .filter((path) => !Object.hasOwn(baseline.entries, `/${path}`)); + .filter((path) => !existsSync(orderBaselinePath(repoRoot, path))); if (missingBaselines.length > 0) { console.error(`Missing TypeScript preflight/order baselines:\n${missingBaselines.join("\n")}`); console.error( diff --git a/scripts/ts7-order-fixtures.mjs b/scripts/ts7-order-fixtures.mjs index a22a80692..fdc9cf884 100644 --- a/scripts/ts7-order-fixtures.mjs +++ b/scripts/ts7-order-fixtures.mjs @@ -19,3 +19,13 @@ export function allOrderEntries(repoRoot) { ...globSync(join(repoRoot, "tests/fixtures/node-types/*.ts")).sort(), ]; } + +/* Each fixture's recorded preflight/order answer lives in its own file, + * named after the fixture's repository path plus ".json", so changes that + * add or re-record different fixtures never edit the same file. */ +export const ORDER_BASELINE_DIR = "packages/compiler/test/ts7/baselines/order-parity"; + +/** The baseline file of `fixture`, a repository-relative "/" path. */ +export function orderBaselinePath(repoRoot, fixture) { + return join(repoRoot, ORDER_BASELINE_DIR, `${fixture}.json`); +} diff --git a/tests/harness/ts7-baselines.test.ts b/tests/harness/ts7-baselines.test.ts index 5382d5a0c..d365955bc 100644 --- a/tests/harness/ts7-baselines.test.ts +++ b/tests/harness/ts7-baselines.test.ts @@ -26,8 +26,7 @@ test("baseline preflight reports every missing fixture before loading the compil "tests/fixtures/node-types/api.ts", ]; for (const path of [...fixtures, "tests/corpus/modules/helper.ts"]) put(path, ""); - const baselinePath = "packages/compiler/test/ts7/baselines/order-parity.json"; - put(baselinePath, JSON.stringify({ entries: {} })); + const baselineDir = "packages/compiler/test/ts7/baselines/order-parity"; const run = () => spawnSync(process.execPath, [join(root, "scripts/test-ts7.mjs"), "--baselines-only"], { encoding: "utf8", @@ -38,14 +37,9 @@ test("baseline preflight reports every missing fixture before loading the compil expect(missing.stderr).not.toContain("helper.ts"); expect(missing.stderr).toContain("SCRIPTC_UPDATE_BASELINES=1"); - put( - baselinePath, - JSON.stringify({ - entries: Object.fromEntries( - fixtures.map((path) => [`/${path}`, { order: [], diags: [] }]), - ), - }), - ); + for (const path of fixtures) { + put(`${baselineDir}/${path}.json`, JSON.stringify({ order: [], diags: [] })); + } const complete = run(); expect(complete.status, complete.stderr).toBe(0); expect(complete.stdout).toContain("Every TypeScript preflight/order fixture"); From 5e5ec89c76426d6bad1129a22300acb45f1877c4 Mon Sep 17 00:00:00 2001 From: Chris Tate Date: Mon, 12 Oct 2026 00:32:48 -0500 Subject: [PATCH 8/8] Run the emission test's compiler passes off the test worker --- tests/harness/self-hosting-emission.test.ts | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/tests/harness/self-hosting-emission.test.ts b/tests/harness/self-hosting-emission.test.ts index 79985e6ac..d245c136d 100644 --- a/tests/harness/self-hosting-emission.test.ts +++ b/tests/harness/self-hosting-emission.test.ts @@ -3,11 +3,12 @@ import { tmpdir } from "node:os"; import { join } from "node:path"; import { fileURLToPath } from "node:url"; import { expect, test } from "vitest"; -import { analyze, compile, compileC, deserializeModule, serializeModule } from "@scriptc/compiler"; +import { compile, compileC, deserializeModule, serializeModule } from "@scriptc/compiler"; import { emitLlvmModule } from "../../packages/compiler/src/backend/llvm/emitter.js"; import { scalarizeNumericRecords } from "../../packages/compiler/src/ir/scalar-records.js"; import { everyStmtList } from "../../packages/compiler/src/ir/traverse.js"; import { type IrModule } from "../../packages/compiler/src/ir/ir.js"; +import { analyzeInChild, compileInChild } from "./self-hosting-compiler-process.js"; import { spawnResult } from "./spawn-result.js"; import { moduleUsesCopying, @@ -53,8 +54,8 @@ interface Emission { block: string; } -test("the production layout and metadata stage lowers statically", () => { - const { coverage } = analyze(entry, { dynamic: false }); +test("the production layout and metadata stage lowers statically", async () => { + const coverage = await analyzeInChild(entry, { dynamic: false }); expect(coverage.preflightFailed).toBe(false); expect(coverage.diagnostics).toEqual([]); expect(coverage.stats.statementsTotal).toBeGreaterThan(1200); @@ -72,7 +73,7 @@ for (const backend of ["llvm"] as const) { const executable = (name: string): string => join(dir, name + (process.platform === "win32" ? ".exe" : "")); try { - const built = await compile(entry, { + const built = await compileInChild(entry, { outDir: dir, outPath: executable("stage"), backend,