diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 950ce7796..85141d1ba 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -380,7 +380,7 @@ jobs: - name: Check version sync run: | VERSION="${{ needs.check-release.outputs.version }}" - for pkg in packages/runtime packages/runtime-* packages/llvm-* packages/compiler packages/threads packages/cli packages/cli-*; do + for pkg in packages/runtime packages/runtime-* packages/llvm-* packages/compiler packages/threads packages/types packages/cli packages/cli-*; do if [ "$(node -p "require('./$pkg/package.json').private === true")" = "true" ]; then continue fi @@ -478,6 +478,7 @@ jobs: for pkg in packages/cli-*; do publish_dir "$pkg"; done publish_dir packages/compiler publish_dir packages/threads + publish_dir packages/types publish_dir packages/cli echo "All package uploads accepted; npm registry propagation may continue after this job." >> "$GITHUB_STEP_SUMMARY" diff --git a/docs/content/docs/cli.mdx b/docs/content/docs/cli.mdx index eb5277533..64abc94a8 100644 --- a/docs/content/docs/cli.mdx +++ b/docs/content/docs/cli.mdx @@ -54,7 +54,7 @@ fib.s Different output kinds accumulate in `.scriptc/`; rebuilding a kind updates its file. -The IR and LLVM source outputs require only Node. On supported macOS, Linux, and Windows hosts, assembly and object outputs use the matching native helper installed with scriptc and do not invoke an external compiler, archiver, linker, or SDK. The object is a relocatable program object with undefined scr_* runtime symbols and a required scr_runtime_abi_v12 marker, not a standalone library. External consumption is experimental and requires the exact runtime version reported by --print=native-link-info. That option still writes the object, performs no link, and prints a versioned JSON recipe with the target, main entry, installed precompiled runtime pack, FFI inputs, and system libraries. It never reports private scriptc cache paths. See Native Program Objects for complete C-driver and direct-linker examples. --emit=exe is the default. LLVM builds emit the program object through the helper and link precompiled runtime objects; runtime development with AddressSanitizer compiles an instrumented C runtime. +The IR and LLVM source outputs require only Node. On supported macOS, Linux, and Windows hosts, assembly and object outputs use the matching native helper installed with scriptc and do not invoke an external compiler, archiver, linker, or SDK. The object is a relocatable program object with undefined scr_* runtime symbols and a required scr_runtime_abi_v13 marker, not a standalone library. External consumption is experimental and requires the exact runtime version reported by --print=native-link-info. That option still writes the object, performs no link, and prints a versioned JSON recipe with the target, main entry, installed precompiled runtime pack, FFI inputs, and system libraries. It never reports private scriptc cache paths. See Native Program Objects for complete C-driver and direct-linker examples. --emit=exe is the default. LLVM builds emit the program object through the helper and link precompiled runtime objects; runtime development with AddressSanitizer compiles an instrumented C runtime. ## scriptc run diff --git a/docs/content/docs/contracts.mdx b/docs/content/docs/contracts.mdx new file mode 100644 index 000000000..bb91e341e --- /dev/null +++ b/docs/content/docs/contracts.mdx @@ -0,0 +1,242 @@ +--- +title: "Contract Types" +--- + +Contract types are type aliases that mean nothing to TypeScript or Node.js but are promises scriptc checks. You import them from `@scriptc/types` with `import type`, which TypeScript erases, so Node.js never loads the package and runs the program exactly as without the annotations. scriptc proves each contract or rejects the program with a diagnostic that explains why the contract does not hold. A program that compiles behaves exactly as under Node.js; the contract only adds an optimization that scriptc can now rely on. + + + + + + + + + + + + + + + + + + + + + + + + + + +
ContractPromiseWhat scriptc does with it
NoThrow<T>The function never throws.Callers need no exception check after the call.
Int32Every value stored is a signed 32-bit integer by construction.The variable, field, parameter or result is stored as a 32-bit integer.
Immutable<T>No code writes to the value, through any reference.A module constant built from literals becomes immortal data: never reference counted, never traced by the collector.
+ +Add `@scriptc/types` to your project's development dependencies. It contains only type declarations. + +## Example + +```ts:main.ts +import type { Immutable, Int32, NoThrow } from "@scriptc/types"; + +const KEYWORDS: Immutable> = new Map([ + ["const", 1], + ["let", 2], + ["function", 3], +]); + +class Token { + pos: Int32; + end: Int32; + kind: number; + constructor(pos: Int32, end: Int32, kind: number) { + this.pos = pos; + this.end = end; + this.kind = kind; + } +} + +function isLetter(ch: number): NoThrow { + return (ch >= 97 && ch <= 122) || (ch >= 65 && ch <= 90); +} + +function scan(text: string): Token[] { + const tokens: Token[] = []; + let pos: Int32 = 0; + while (pos < text.length) { + if (!isLetter(text.charCodeAt(pos))) { + pos = (pos + 1) | 0; + continue; + } + let end: Int32 = pos; + while (end < text.length && isLetter(text.charCodeAt(end))) end = (end + 1) | 0; + tokens.push(new Token(pos, end, KEYWORDS.get(text.slice(pos, end)) ?? 0)); + pos = end; + } + return tokens; +} + +for (const t of scan("const answer = 42; function f() {}")) console.log(t.pos, t.end, t.kind); +``` + +Node.js 24 runs the program directly: + +```console +$ node main.ts +0 5 1 +6 12 0 +19 27 3 +28 29 0 +``` + +The scriptc executable prints the same output. `KEYWORDS` is immortal, `Token.pos`, `Token.end` and the scanner's positions are 32-bit integers, and the calls to `isLetter` carry no exception checks: + +```console +$ scriptc build main.ts -o scan >/dev/null +$ ./scan +0 5 1 +6 12 0 +19 27 3 +28 29 0 +``` + +## Where contracts apply + +scriptc recognizes a contract where it is written as the annotation of a declaration, and only when the name is imported from `@scriptc/types` (a named import, possibly renamed, or a namespace import such as `sc.Int32`). TypeScript does not keep alias names in inferred types, so a contract never spreads by inference: write it where the value is declared. + +
+
NoThrow<T>
+
The written return type of a function, method or arrow function. NoThrow<Int32> and NoThrow<Immutable<T>> combine the result contracts.
+
Int32
+
Parameters, variables, class instance fields and function results whose type is a plain number.
+
Immutable<T>
+
Parameters, variables, class instance fields and function results.
+
+ +A contract anywhere else (a type alias, an interface member, an element or type argument such as `Int32[]`, a function type) would promise something scriptc does not check, so the build reports it with SC7006. + +## NoThrow + +A `NoThrow` function must not contain a path to a throwing operation: a `throw`, a call to a function that may throw, a call through a function value that may hold such a function, an operation that throws in Node.js (such as reading a property of `undefined`), or recursion, whose stack guard can throw `RangeError`. scriptc already computes this for every function to omit exception checks; the contract turns the result into a guarantee and reports the first throwing path when it does not hold. + +In this version a surrounding `try`/`catch` does not discharge the contract, and `async` functions and generators cannot be `NoThrow`. + +## Int32 + +Each value stored into an `Int32` slot (initializers, assignments, compound assignments, `++` and `--`, arguments and returns) must be an int32 in Node.js semantics, so storing it as a 32-bit integer cannot change it: + +- an integer literal in range; +- the result of `|`, `&`, `^`, `~`, `<<`, `>>` or `Math.imul`; +- another `Int32` value; +- arithmetic whose range scriptc can bound, such as `i + 1` under a loop condition `i < text.length`. + +`x >>> 0` is a uint32 and is not accepted. Anything else needs an explicit `| 0`, which makes Node.js compute the same 32-bit value. Reads keep JavaScript semantics: `a + b` of two `Int32` values is an ordinary number that may exceed the int32 range. + +scriptc refuses an `Int32` slot whose writes it cannot all see (SC7003): a parameter of a function used as a value, or a field of a class whose instances reach `any` or dynamic code. + +## Immutable + +`Immutable` is a deep read-only view, so TypeScript already rejects direct writes such as `KEYWORDS.set(...)`. scriptc also checks the writes TypeScript cannot see: + +- a method that writes `this`, called on the value; +- a function that writes a parameter, given the value; +- a cast such as `value as number[]`, an `any` alias, `Object.assign`, or index-signature writes; +- a value stored into an `Immutable` slot that another reference can still change. + +A value stored into an `Immutable` slot must be fresh: a literal, a `new` expression whose constructor keeps `this` to itself, or a function that returns what it builds. Values that reach dynamic code, or functions scriptc cannot see, are refused. + +## Diagnostics + +Each failed contract names the declaration and the reason: + +```ts:reject.ts +import type { Immutable, Int32, NoThrow } from "@scriptc/types"; + +const LIMITS: Immutable = [10, 20]; + +function widen(limits: number[]): void { + limits.push(30); +} + +function parseDigit(ch: number): number { + if (ch < 48 || ch > 57) throw new RangeError("not a digit"); + return ch - 48; +} + +function digitAt(text: string, i: number): NoThrow { + return parseDigit(text.charCodeAt(i)); +} + +function middle(start: Int32, end: Int32): Int32 { + return (start + end) / 2; +} + +widen(LIMITS as number[]); +console.log(digitAt("7", 0), middle(2, 5), LIMITS.length); +``` + +```console +$ scriptc build reject.ts +/tmp/app/reject.ts:6:3 - error SC7004: 'limits.push(30)' writes to a value that may be Immutable ('limits' may be an Immutable value passed to 'widen' at reject.ts:22:1) + + 5 | function widen(limits: number[]): void { + 6 | limits.push(30); + | ^~~~~~~~~~~~~~~ + 7 | } + + hint: Immutable values cannot be written through any reference; copy the value before changing it + +/tmp/app/reject.ts:14:44 - error SC7001: 'digitAt' is declared NoThrow but may throw: calls 'parseDigit' at reject.ts:15:10 → throw statement at reject.ts:10:27 + + 13 | + 14 | function digitAt(text: string, i: number): NoThrow { + | ^~~~~~~~~~~~~~~ + 15 | return parseDigit(text.charCodeAt(i)); + + hint: remove the throwing operation from the path (or the recursion), or remove NoThrow; a surrounding try/catch does not discharge the contract in this version + +/tmp/app/reject.ts:19:10 - error SC7002: the value returned from 'middle' (Int32) is not provably an int32: '(start + end) / 2' + + 18 | function middle(start: Int32, end: Int32): Int32 { + 19 | return (start + end) / 2; + | ^~~~~~~~~~~~~~~~~ + 20 | } + + hint: make the int32 conversion explicit, for example '((start + end) / 2) | 0', so Node computes the same value + +3 errors. +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CodeMeaning
SC7001A NoThrow function may throw; the message shows the path to the throwing operation.
SC7002A value stored into an Int32 slot is not provably an int32; the hint shows the | 0 form.
SC7003An Int32 slot has writes scriptc cannot see.
SC7004A write can reach an Immutable value, or a stored value is not fresh.
SC7005An Immutable value escapes to code scriptc cannot check.
SC7006A contract is written where scriptc does not check it.
diff --git a/docs/content/docs/how-it-works.mdx b/docs/content/docs/how-it-works.mdx index f0d5efabb..5fcd664a8 100644 --- a/docs/content/docs/how-it-works.mdx +++ b/docs/content/docs/how-it-works.mdx @@ -68,7 +68,7 @@ Without `-o`, artifacts are written to `.scriptc/` next to the input. Different ### External linking -Program objects define `main` and leave selected `scr_*` runtime functions undefined. A strong reference to `scr_runtime_abi_v12` checks runtime compatibility at link time. +Program objects define `main` and leave selected `scr_*` runtime functions undefined. A strong reference to `scr_runtime_abi_v13` checks runtime compatibility at link time. `--print=native-link-info` emits the program object and a JSON recipe containing the runtime pack and link order for external builds. This object ABI is experimental and requires an exact runtime version. See [Native Program Objects](/docs/native-objects) for examples. diff --git a/docs/content/docs/limitations.mdx b/docs/content/docs/limitations.mdx index cf354b971..c2860ee27 100644 --- a/docs/content/docs/limitations.mdx +++ b/docs/content/docs/limitations.mdx @@ -128,6 +128,10 @@ scriptc checks programs against the `es2025` standard library and its own ambien A program that passes its project's TypeScript check may still use unsupported operations. A second preflight using the project's declarations distinguishes those sites from ordinary type errors and reports scriptc diagnostics with rewrite hints. Declared APIs without a compiler implementation, such as unsupported console members, produce `SC2020`. +### Contract types + +[Contract types](/docs/contracts) are checked only where they are written as the annotation of a parameter, variable, class instance field or function result; aliases, interface members and nested type positions are reported. A surrounding `try`/`catch` does not discharge `NoThrow`. `Int32` refuses parameters of functions used as values and fields of classes whose instances reach dynamic code, and `Immutable` refuses values that reach dynamic code or that another reference can still change. + ### three.js With `--npm-static=three`, native and WASI builds support published package imports and tested CPU workflows for math, bounds, procedural geometry, curves, shapes, extrusion, text geometry, scene graphs, cameras, lights, materials, textures, and render-target data. Mesh workflows include instancing, batching, morph targets, skeletal deformation, LOD, and sprites. Raycasting includes mesh intersections, sorted results, recursive traversal, layers, distance limits, camera rays, lines, and points. diff --git a/docs/content/docs/meta.json b/docs/content/docs/meta.json index e756322c1..a92346155 100644 --- a/docs/content/docs/meta.json +++ b/docs/content/docs/meta.json @@ -10,6 +10,7 @@ "ffi", "native-objects", "threads", + "contracts", "wasm", "platforms", "---Reference---", diff --git a/docs/content/docs/native-objects.mdx b/docs/content/docs/native-objects.mdx index 609065160..caa5baefd 100644 --- a/docs/content/docs/native-objects.mdx +++ b/docs/content/docs/native-objects.mdx @@ -8,7 +8,7 @@ title: "Native Program Objects" The external object ABI is **experimental**. Its `scr_*` function and data surface may change before 1.0, so consumers must use the exact runtime-pack version reported by the same compiler installation. This is stricter than semver compatibility. -The object intentionally leaves its selected runtime symbols undefined. It also holds a strong reference to `scr_runtime_abi_v12`, which the matching runtime defines. Linking an object against a runtime with another ABI marker fails at link time with the missing versioned symbol; it cannot become a latent runtime incompatibility. +The object intentionally leaves its selected runtime symbols undefined. It also holds a strong reference to `scr_runtime_abi_v13`, which the matching runtime defines. Linking an object against a runtime with another ABI marker fails at link time with the missing versioned symbol; it cannot become a latent runtime incompatibility. ## Machine-readable link information diff --git a/docs/src/lib/page-titles.ts b/docs/src/lib/page-titles.ts index 3f36f89b2..1b240d4d3 100644 --- a/docs/src/lib/page-titles.ts +++ b/docs/src/lib/page-titles.ts @@ -8,6 +8,7 @@ export const PAGE_TITLES: Record = { ffi: "Native FFI", "native-objects": "Native Program Objects", threads: "Sharing Data Between Workers", + contracts: "Contract Types", wasm: "WebAssembly Modules", platforms: "Platform Support", compatibility: "Node.js 24 Compatibility", diff --git a/docs/test/fixtures/migration-baseline.json b/docs/test/fixtures/migration-baseline.json index dfac93ebe..f938545d4 100644 --- a/docs/test/fixtures/migration-baseline.json +++ b/docs/test/fixtures/migration-baseline.json @@ -227,6 +227,36 @@ } ] }, + { + "href": "/docs/contracts", + "title": "Contract Types", + "headings": [ + { + "text": "Example", + "id": "example" + }, + { + "text": "Where contracts apply", + "id": "where-contracts-apply" + }, + { + "text": "NoThrow", + "id": "nothrow" + }, + { + "text": "Int32", + "id": "int32" + }, + { + "text": "Immutable", + "id": "immutable" + }, + { + "text": "Diagnostics", + "id": "diagnostics" + } + ] + }, { "legacy": "/wasm", "href": "/docs/wasm", diff --git a/examples/native-object/README.md b/examples/native-object/README.md index 486612a0e..3086e995c 100644 --- a/examples/native-object/README.md +++ b/examples/native-object/README.md @@ -15,4 +15,4 @@ $ ./app-ld `cc` uses the C compiler as a linker driver. `ld` links the same precompiled runtime objects directly with the selected Apple SDK. The object defines `main`; it is a complete program object, not a library to load into another process. Use `scriptc build --lib --profile ...` for a host-callable static library. -The external object ABI is experimental. Always consume the runtime pack at the exact `runtime_pack.version` reported by the same scriptc installation. The object requires `scr_runtime_abi_v12`, so a mismatched runtime fails during the link instead of starting with an incompatible ABI. +The external object ABI is experimental. Always consume the runtime pack at the exact `runtime_pack.version` reported by the same scriptc installation. The object requires `scr_runtime_abi_v13`, so a mismatched runtime fails during the link instead of starting with an incompatible ABI. diff --git a/package.json b/package.json index 885d6f4e6..ddd89df37 100644 --- a/package.json +++ b/package.json @@ -34,6 +34,7 @@ }, "devDependencies": { "@scriptc/threads": "workspace:*", + "@scriptc/types": "workspace:*", "@types/node": "^24.0.0", "effect": "3.22.2", "js-yaml": "4.3.0", diff --git a/packages/cli/README.md b/packages/cli/README.md index b4876f9b0..a8dfbc798 100644 --- a/packages/cli/README.md +++ b/packages/cli/README.md @@ -34,7 +34,7 @@ Builds use a bounded persistent cache. Unchanged source can reuse the validated - `scriptc run ` — compile and run - `scriptc coverage ` — what compiles statically, and why the rest doesn't -`scriptc build app.ts --emit=ir|llvm|asm|obj` selects serialized typed IR, textual LLVM IR, target assembly, or a relocatable program object as the one primary artifact. `--emit=exe` is the default. Assembly/object emission uses the matching helper on supported macOS, Linux, and Windows hosts (and produces WASI artifacts when that target is selected). Objects retain undefined `scr_*` runtime references plus the `scr_runtime_abi_v12` compatibility marker; they are not library archives. External consumption is experimental and requires the exact matching runtime. `scriptc build app.ts --print=native-link-info -o app.o` prints the versioned JSON target/runtime/link recipe without performing a link. `--emit=asm|obj --sanitize` is rejected until ASan pipeline parity is available. +`scriptc build app.ts --emit=ir|llvm|asm|obj` selects serialized typed IR, textual LLVM IR, target assembly, or a relocatable program object as the one primary artifact. `--emit=exe` is the default. Assembly/object emission uses the matching helper on supported macOS, Linux, and Windows hosts (and produces WASI artifacts when that target is selected). Objects retain undefined `scr_*` runtime references plus the `scr_runtime_abi_v13` compatibility marker; they are not library archives. External consumption is experimental and requires the exact matching runtime. `scriptc build app.ts --print=native-link-info -o app.o` prints the versioned JSON target/runtime/link recipe without performing a link. `--emit=asm|obj --sanitize` is rejected until ASan pipeline parity is available. For embedder-hosted modules that are not installed npm packages, coverage can map an exact bare specifier to a local declaration with repeatable `--external-types ` options. This is analysis-only: the types unblock application measurement, while runtime module uses remain reported as blockers. diff --git a/packages/cli/test/native-link-info.test.ts b/packages/cli/test/native-link-info.test.ts index ad7791c66..4e1616a8c 100644 --- a/packages/cli/test/native-link-info.test.ts +++ b/packages/cli/test/native-link-info.test.ts @@ -72,7 +72,7 @@ describe.runIf(supported)("macOS arm64 native link info", () => { minimum_os: "14.0", }, program: { object, entry_symbol: "main" }, - runtime_abi: { version: 12, marker: "scr_runtime_abi_v12" }, + runtime_abi: { version: 13, marker: "scr_runtime_abi_v13" }, runtime_pack: { kind: "precompiled", package: "@scriptc/runtime-darwin-arm64", @@ -165,6 +165,6 @@ describe.runIf(supported)("macOS arm64 native link info", () => { () => null, (failure: { stderr?: string }) => failure, ); - expect(error?.stderr).toContain("scr_runtime_abi_v12"); + expect(error?.stderr).toContain("scr_runtime_abi_v13"); }); }); diff --git a/packages/compiler/src/backend/cycle-mutability.ts b/packages/compiler/src/backend/cycle-mutability.ts index 67196efd7..e5a183db5 100644 --- a/packages/compiler/src/backend/cycle-mutability.ts +++ b/packages/compiler/src/backend/cycle-mutability.ts @@ -292,14 +292,11 @@ export function constructorThisAliases(fn: IrFunction, thisId: string): Set { - if (s.kind === "fieldSet" && isThisRef(s.obj)) { - if (options.selfStores === true) { - // `this` itself, possibly wrapped into the field's union type. - const self = s.value.kind === "unionWrap" ? s.value.value : s.value; - if (isThisRef(self)) return wrapper(s.obj) && wrapper(self); - } - return wrapper(s.obj) && expr(s.value); - } + if (s.kind === "fieldSet" && isThisRef(s.obj)) return wrapper(s.obj) && expr(s.value); if (s.kind === "exprStmt" && isThisRef(s.expr)) return wrapper(s.expr); // Declaring an alias is not an escape; its uses are checked like `this`. if (s.kind === "varDecl" && aliases.has(s.localId) && s.init !== null) return wrapper(s.init); diff --git a/packages/compiler/src/backend/immutability.test.ts b/packages/compiler/src/backend/immutability.test.ts new file mode 100644 index 000000000..98ecf91ef --- /dev/null +++ b/packages/compiler/src/backend/immutability.test.ts @@ -0,0 +1,172 @@ +import { expect, test } from "vitest"; +import { + DYN, + F64, + STRING, + VOID, + type IrExpr, + type IrModule, + type IrStmt, + type IrType, +} from "../ir/ir.js"; +import { computeConstructionFacts, computeImmutableFields, stableGlobals } from "./immutability.js"; + +const loc = { file: "immutability.ts", start: 0, end: 1 }; +const obj = (className: string): IrType => ({ kind: "object", className }); +const value = (type: IrType): IrExpr => ({ kind: "varRef", localId: "v", type, loc }); +const thisRef = (className: string): IrExpr => ({ + kind: "varRef", + localId: "this.0", + type: obj(className), + loc, +}); +const setThis = (className: string, field: string): IrStmt => ({ + kind: "fieldSet", + obj: thisRef(className), + className, + field, + value: value(F64), + loc, +}); +const call = (callee: string, args: IrExpr[]): IrStmt => ({ + kind: "exprStmt", + expr: { kind: "call", callee, args, type: VOID, loc }, + loc, +}); +function ctor(className: string, body: IrStmt[]): IrModule["functions"][number] { + return { + name: `%${className}.constructor`, + params: [{ localId: "this.0", name: "this", type: obj(className) }], + locals: [], + returnType: VOID, + body, + loc, + }; +} +function module( + classes: NonNullable, + functions: IrModule["functions"], +): IrModule { + return { + irVersion: 15, + sourceFile: loc.file, + entry: "main", + classes, + functions: [ + { name: "main", locals: [], params: [], returnType: VOID, body: [], loc }, + ...functions, + ], + }; +} +const fields = (...names: string[]) => names.map((name) => ({ name, type: F64 })); + +/** The fields of `className` whose constructor stores are private. */ +function privateFields(mod: IrModule, className: string): string[] { + const facts = computeConstructionFacts(mod); + const fn = mod.functions.find((f) => f.name === `%${className}.constructor`)!; + return fn.body + .filter((s): s is Extract => s.kind === "fieldSet") + .filter((s) => facts.privateStores.has(s)) + .map((s) => s.field); +} + +test("constructor stores before this escapes are private", () => { + const mod = module( + [{ name: "P", fields: fields("a", "b"), loc }], + [ctor("P", [setThis("P", "a"), call("register", [thisRef("P")]), setThis("P", "b")])], + ); + expect(privateFields(mod, "P")).toEqual(["a"]); +}); + +test("storing this into its own field ends private construction", () => { + // A later read of the field yields `this` again, so any use of it + // (publishing it, handing it to a worker) would expose the object. + const self: IrStmt = { ...setThis("P", "self"), value: thisRef("P") } as IrStmt; + const mod = module( + [{ name: "P", fields: [...fields("a", "b"), { name: "self", type: obj("P") }], loc }], + [ctor("P", [setThis("P", "a"), self, setThis("P", "b")])], + ); + expect(privateFields(mod, "P")).toEqual(["a"]); +}); + +test("a base constructor's escape makes every subclass store public", () => { + const superCall = call("%Base.constructor", [ + { kind: "upcast", value: thisRef("Sub"), type: obj("Base"), loc }, + ]); + const mod = module( + [ + { name: "Base", fields: fields("a"), loc }, + { name: "Sub", base: "Base", fields: fields("a", "b"), loc }, + ], + [ + ctor("Base", [setThis("Base", "a"), call("register", [thisRef("Base")])]), + ctor("Sub", [superCall, setThis("Sub", "b")]), + ], + ); + expect(privateFields(mod, "Base")).toEqual(["a"]); + expect(privateFields(mod, "Sub")).toEqual([]); +}); + +test("a constructor called on an existing object keeps every guard", () => { + const mod = module([{ name: "P", fields: fields("a"), loc }], [ctor("P", [setThis("P", "a")])]); + expect(privateFields(mod, "P")).toEqual(["a"]); + mod.functions[0]!.body.push(call("%P.constructor", [value(obj("P"))])); + expect(privateFields(mod, "P")).toEqual([]); +}); + +test("library builds keep every guard", () => { + const mod = module([{ name: "P", fields: fields("a"), loc }], [ctor("P", [setThis("P", "a")])]); + mod.lib = {} as NonNullable; + expect(privateFields(mod, "P")).toEqual([]); +}); + +test("construction-only fields exclude later writes and dynamic stores", () => { + const mod = module( + [{ name: "P", fields: fields("a", "b"), loc }], + [ctor("P", [setThis("P", "a"), setThis("P", "b")])], + ); + mod.functions[0]!.body.push( + { kind: "fieldSet", obj: value(obj("P")), className: "P", field: "b", value: value(F64), loc }, + { kind: "exprStmt", expr: { kind: "dynFrom", value: value(obj("P")), type: DYN, loc }, loc }, + ); + const facts = computeImmutableFields(mod)!; + expect(facts.classField("P", "a")).toBe(true); + expect(facts.classField("P", "b")).toBe(false); + // A runtime store into a dynamic value can reach P through its capsule. + mod.functions[0]!.body.push({ + kind: "exprStmt", + expr: { + kind: "libCall", + fn: "dyn.keySet", + args: [value(DYN), value(STRING), value(DYN)], + type: VOID, + loc, + }, + loc, + }); + expect(computeImmutableFields(mod)!.classField("P", "a")).toBe(false); +}); + +test("module constants are stable once assigned exactly once", () => { + const mod = module([], []); + mod.globals = [ + { id: "%g.k", name: "k", type: STRING, mutable: false }, + { id: "%g.m", name: "m", type: STRING, mutable: true }, + { id: "%g.t", name: "t", type: STRING, mutable: false, tdz: true }, + { id: "%g.twice", name: "twice", type: STRING, mutable: false }, + ]; + const assign = (localId: string): IrStmt => ({ + kind: "assign", + localId, + value: value(STRING), + loc, + }); + mod.functions[0]!.body.push( + assign("%g.k"), + assign("%g.m"), + assign("%g.t"), + assign("%g.twice"), + assign("%g.twice"), + ); + expect([...stableGlobals(mod)]).toEqual(["%g.k"]); +}); diff --git a/packages/compiler/src/backend/immutability.ts b/packages/compiler/src/backend/immutability.ts new file mode 100644 index 000000000..a0b792496 --- /dev/null +++ b/packages/compiler/src/backend/immutability.ts @@ -0,0 +1,214 @@ +/* Static immutability facts the backend uses to drop run-time immutability + * checks (see computeConstructionFacts). Pure functions of the IR module. */ +import type { IrExpr, IrModule, IrStmt } from "../ir/ir.js"; +import { everyExprChild, everyStmtChild } from "../ir/traverse.js"; +import { + computeCycleMutability, + constructorEscapePoint, + constructorThisAliases, + fieldKey, + type CycleMutability, +} from "./cycle-mutability.js"; + +/** Fields that are never written once their object can be observed outside + * its own construction (cycle-mutability.ts derives the facts from every + * store in the IR, including typed-ref commits from checked-dynamic code, + * and disables them for library builds and dynamic islands). + * + * Outside constructors, a reference read from such a field stays valid for + * as long as its owner object is alive: nothing can replace it and release + * the old value. Constructors themselves may still write their own + * `this`'s fields, so the facts do not apply while one runs. */ +export class ImmutableFields { + constructor( + private readonly mutability: CycleMutability, + private readonly unitOfClass: (className: string) => string, + ) {} + + /** `obj.field` on a class instance is construction-only. */ + classField(className: string, field: string): boolean { + return this.unit(this.unitOfClass(className), field); + } + + /** `obj.field` on a record is never written after the literal. */ + recordField(shapeId: string, field: string): boolean { + return this.unit(`record:${shapeId}`, field); + } + + private unit(unit: string, field: string): boolean { + return ( + !this.mutability.all && + !this.mutability.units.has(unit) && + !this.mutability.fields.has(fieldKey(unit, field)) + ); + } +} + +export function computeImmutableFields(mod: IrModule): ImmutableFields | null { + if (mod.lib !== undefined) return null; + const baseOf = new Map((mod.classes ?? []).map((c) => [c.name, c.base ?? null] as const)); + const roots = new Map(); + const rootOf = (name: string): string => { + const known = roots.get(name); + if (known !== undefined) return known; + let cur = name; + for (let base = baseOf.get(cur); base !== null && base !== undefined; base = baseOf.get(cur)) + cur = base; + roots.set(name, cur); + return cur; + }; + const unitOfClass = (name: string): string => `object:${rootOf(name)}`; + const mutability = computeCycleMutability(mod, unitOfClass); + return mutability.all ? null : new ImmutableFields(mutability, unitOfClass); +} + +/** Stores that provably target an object no other code can reach yet. + * + * A published object (@scriptc/threads `publish`) rejects every write, so + * the emitter guards each store into a type the program may publish. A + * store into the constructor's own `this` cannot target a published object + * when nothing outside the construction can hold `this` at that point: + * + * - the constructor runs on a fresh object: it is only reached through + * `new` (or a construct thunk) for its class or a subclass, never by a + * direct call on an existing object (`%C.constructor` called anywhere but + * as the direct super call of a subclass constructor disqualifies C and + * every ancestor, which that call reaches with the same receiver); + * - no ancestor constructor, which runs before this body continues, lets + * `this` escape, and the store lies in a top-level statement before the + * first one in which this constructor lets it escape + * (cycle-mutability's constructorEscapePoint: `this`, or a constant alias + * of it, may only be a field-store target, a field-read receiver or the + * direct base constructor's receiver; storing it anywhere, including + * into one of its own fields whose later reads would hand it out again, + * and closures and class references capturing it count as escapes). + * A subclass constructor's code only runs after this body returns. + * + * Library builds keep every guard: their constructors can be invoked by an + * embedder in ways the module does not show. */ +export interface ConstructionFacts { + /** `fieldSet` statements whose target is a still-private `this`. */ + privateStores: Set; +} + +export function computeConstructionFacts(mod: IrModule): ConstructionFacts { + const facts: ConstructionFacts = { privateStores: new Set() }; + if (mod.lib !== undefined) return facts; + const classes = new Map((mod.classes ?? []).map((c) => [c.name, c] as const)); + const ctorClass = new Map([...classes.keys()].map((name) => [`%${name}.constructor`, name])); + const fnByName = new Map(mod.functions.map((fn) => [fn.name, fn] as const)); + const thisOf = (name: string): string | null => + fnByName.get(`%${name}.constructor`)?.params[0]?.localId ?? null; + const isThisRef = (e: IrExpr, thisId: string | null): boolean => { + if (thisId === null) return false; + if (e.kind === "varRef") return e.localId === thisId; + if (e.kind === "upcast") return isThisRef(e.value, thisId); + if (e.kind === "seqExpr") return isThisRef(e.result, thisId); + return false; + }; + + // Constructors reached with a receiver that may not be fresh. + const reused = new Set(); + const markReused = (name: string): void => { + for (let c: string | undefined = name; c !== undefined && classes.has(c);) { + if (reused.has(c)) break; + reused.add(c); + c = classes.get(c)!.base; + } + }; + for (const fn of mod.functions) { + const own = ctorClass.get(fn.name); + const thisId = own !== undefined ? thisOf(own) : null; + const baseCtor = + own !== undefined && classes.get(own)!.base !== undefined + ? `%${classes.get(own)!.base}.constructor` + : null; + const expr = (e: IrExpr): boolean => { + if (e.kind === "call") { + const target = ctorClass.get(e.callee); + if ( + target !== undefined && + !(e.callee === baseCtor && e.args.length > 0 && isThisRef(e.args[0]!, thisId)) + ) + markReused(target); + } else if (e.kind === "closure") { + const target = ctorClass.get(e.fnName); + if (target !== undefined) markReused(target); + } + return everyExprChild(e, expr, stmt); + }; + const stmt = (s: IrStmt): boolean => everyStmtChild(s, expr, stmt); + fn.body.every(stmt); + } + + // The first escaping statement of each constructor (body length: none). + // A class without a constructor function of its own (runtime roots) is + // treated as escaping at once. + const points = new Map(); + const escapePoint = (name: string): number => { + const known = points.get(name); + if (known !== undefined) return known; + const fn = fnByName.get(`%${name}.constructor`); + const base = classes.get(name)?.base; + const thisId = thisOf(name); + const point = + fn === undefined || thisId === null || classes.get(name)?.runtime === true + ? 0 + : constructorEscapePoint(fn, thisId, base !== undefined ? `%${base}.constructor` : null); + points.set(name, point); + return point; + }; + const ancestorEscapes = (name: string): boolean => { + for (let c = classes.get(name)?.base; c !== undefined; c = classes.get(c)?.base) { + const fn = fnByName.get(`%${c}.constructor`); + if (!classes.has(c) || fn === undefined || escapePoint(c) < fn.body.length) return true; + } + return false; + }; + + for (const [name] of classes) { + const fn = fnByName.get(`%${name}.constructor`); + if (fn === undefined || reused.has(name) || ancestorEscapes(name)) continue; + const point = escapePoint(name); + if (point === 0) continue; + const aliases = constructorThisAliases(fn, thisOf(name)!); + const isOwn = (e: IrExpr): boolean => + (e.kind === "varRef" && aliases.has(e.localId)) || + (e.kind === "upcast" && isOwn(e.value)) || + (e.kind === "seqExpr" && isOwn(e.result)); + const expr = (e: IrExpr): boolean => everyExprChild(e, expr, stmt); + const stmt = (s: IrStmt): boolean => { + if (s.kind === "fieldSet" && isOwn(s.obj)) facts.privateStores.add(s); + return everyStmtChild(s, expr, stmt); + }; + for (let i = 0; i < point; i++) stmt(fn.body[i]!); + } + return facts; +} + +/** Module constants whose value never changes once initialized: immutable, + * not TDZ-checked (every read follows the initialization), no import-cycle + * init flag, and at most one assignment in the whole module. Such a global + * owns its value for the rest of the program, so a read of it can be + * borrowed across any later operand or call. */ +export function stableGlobals(mod: IrModule): Set { + const candidates = new Set( + (mod.globals ?? []) + .filter((g) => !g.mutable && g.tdz !== true && g.initFlag === undefined) + .map((g) => g.id), + ); + const assigned = new Set(); + const expr = (e: IrExpr): boolean => { + if (e.kind === "assignExpr" && candidates.has(e.localId)) candidates.delete(e.localId); + return everyExprChild(e, expr, stmt); + }; + const stmt = (s: IrStmt): boolean => { + if (s.kind === "assign" && candidates.has(s.localId)) { + if (assigned.has(s.localId)) candidates.delete(s.localId); + assigned.add(s.localId); + } + return everyStmtChild(s, expr, stmt); + }; + for (const fn of mod.functions) fn.body.every(stmt); + return candidates; +} diff --git a/packages/compiler/src/backend/llvm/borrowed-inputs.ts b/packages/compiler/src/backend/llvm/borrowed-inputs.ts index af921a105..16839afd6 100644 --- a/packages/compiler/src/backend/llvm/borrowed-inputs.ts +++ b/packages/compiler/src/backend/llvm/borrowed-inputs.ts @@ -1,4 +1,5 @@ import type { IrExpr } from "../../ir/ir.js"; +import type { Writes } from "./reference-writes.js"; import type { LlValue, LlvmEmitterContext } from "./expr-context.js"; /** For a runtime input whose ABI borrows rather than consumes ownership. @@ -14,18 +15,33 @@ export function emitBorrowedInput(host: LlvmEmitterContext, value: IrExpr): LlVa * while every operation preserves existing owners. Compute suffix facts * once, keeping left-to-right evaluation and the owning fallback for each * argument independently. The consumer must borrow all inputs and preserve - * reference edges itself; mutating runtime operations use emitBorrowedInput. */ + * reference edges itself; mutating runtime operations use emitBorrowedInput. + * With `consumerWrites` (the locations the consumer may overwrite), a + * projection also borrows when neither the consumer nor any later operand + * can write a location its read depends on (ReferenceWrites). */ export function borrowableInputs( host: LlvmEmitterContext, inputs: readonly IrExpr[], consumerPreserves = true, + consumerWrites?: Writes, ): boolean[] { const result: boolean[] = new Array(inputs.length); let preserves = consumerPreserves; + const writes = host.referenceWrites; + let suffix: Writes = + consumerWrites !== undefined + ? consumerWrites + : consumerPreserves + ? null + : (writes?.heapAll ?? null); for (let i = inputs.length - 1; i >= 0; i--) { const value = inputs[i]!; - result[i] = host.canBorrowCallArgument(value) || (preserves && host.canBorrowReceiver(value)); + result[i] = + host.canBorrowCallArgument(value) || + (preserves && host.canBorrowReceiver(value)) || + (writes !== null && host.canBorrowReceiver(value) && host.unwrittenRead(value, suffix)); preserves = preserves && host.referenceEffects.preserves(value); + if (writes !== null) suffix = writes.union([suffix, writes.expr(value)]); } return result; } @@ -36,3 +52,21 @@ export function emitBorrowedInputs(host: LlvmEmitterContext, inputs: readonly Ir borrowed[index] ? host.emitReadReceiver(value) : host.emitExpr(value), ); } + +/** The writes after each input: the consumer's plus every later input's + * (null entries: nothing; an empty array without ReferenceWrites). */ +export function inputSuffixWrites( + host: LlvmEmitterContext, + inputs: readonly IrExpr[], + consumerWrites: Writes, +): Writes[] { + const writes = host.referenceWrites; + if (writes === null) return []; + const out: Writes[] = new Array(inputs.length); + let suffix = consumerWrites; + for (let i = inputs.length - 1; i >= 0; i--) { + out[i] = suffix; + suffix = writes.union([suffix, writes.expr(inputs[i]!)]); + } + return out; +} diff --git a/packages/compiler/src/backend/llvm/common.ts b/packages/compiler/src/backend/llvm/common.ts index 25a735356..c409fb87b 100644 --- a/packages/compiler/src/backend/llvm/common.ts +++ b/packages/compiler/src/backend/llvm/common.ts @@ -9,6 +9,20 @@ import type { } from "../../ir/ir.js"; import type { LlvmEmitterContext } from "./expr-context.js"; +/** Field numbers of %ScrArr, which mirrors scr_runtime.h's ScrArr field for + * field (its static assertions pin `cyc` and `data`). */ +export const SCR_ARR_FIELD = { + rc: 0, + len: 1, + cap: 2, + elem: 3, + cyc: 4, + ops: 5, + data: 6, + present: 7, + ext: 8, +} as const; + /** Lines that decide whether the double `index` is an integer in * `[0, length)`, where `length` is an unsigned `sizeType` count, and give * that integer as an i64. `%{ok}` is the answer; `%{wide}` is meaningful diff --git a/packages/compiler/src/backend/llvm/dense-array-access.test.ts b/packages/compiler/src/backend/llvm/dense-array-access.test.ts index 4ff7b1b16..8101008a5 100644 --- a/packages/compiler/src/backend/llvm/dense-array-access.test.ts +++ b/packages/compiler/src/backend/llvm/dense-array-access.test.ts @@ -77,7 +77,17 @@ test.each([32, 64] as const)("strict scalar reads check dense storage inline (%i test("reference reads retain inline and keep a cold +1 runtime fallback", () => { const read: IrExpr = { kind: "arrayGet", arr: ref("s", words), index, type: STRING, loc }; - const llvm = emitLlvmModule(module("word", STRING, [{ kind: "return", value: read, loc }])); + // An element removal in the body keeps the read from being lent as a + // borrowed return: the result must own its reference. + const truncate: IrStmt = { + kind: "arraySetLength", + arr: ref("s", words), + length: { kind: "numLit", value: 1, type: F64, loc }, + loc, + }; + const llvm = emitLlvmModule( + module("word", STRING, [truncate, { kind: "return", value: read, loc }]), + ); const fn = body(llvm, "word"); expect(fn).toMatch(/icmp ne ptr .*, null/); expect(fn).toContain("@scr_str_retain_v("); diff --git a/packages/compiler/src/backend/llvm/dense-array-access.ts b/packages/compiler/src/backend/llvm/dense-array-access.ts index 34428db8b..dd0c20588 100644 --- a/packages/compiler/src/backend/llvm/dense-array-access.ts +++ b/packages/compiler/src/backend/llvm/dense-array-access.ts @@ -8,9 +8,10 @@ * `undefined`, sparse indices, noncanonical numeric properties (negative, * fractional, NaN, infinite, 2^32-1), and out-of-range reads branch to the * unchanged runtime call, which is marked cold. The ScrArr field indices - * match the C layout in scr_runtime.h: len 1, cap 2, data 7, present 8. */ + * (SCR_ARR_FIELD) match the C layout in scr_runtime.h. */ import { isRefCounted, type IrExpr, type IrType } from "../../ir/ir.js"; +import { SCR_ARR_FIELD } from "./common.js"; import type { LlValue, LlvmEmitterContext } from "./expr-context.js"; import { exactInteger, widenInteger } from "./integer-values.js"; @@ -85,10 +86,14 @@ function emitDenseGuard( data = B.tmp(), statesPtr = B.tmp(), states = B.tmp(); - B.line(`${dataPtr} = getelementptr inbounds %ScrArr, ptr ${array}, i32 0, i32 7`); + B.line( + `${dataPtr} = getelementptr inbounds %ScrArr, ptr ${array}, i32 0, i32 ${SCR_ARR_FIELD.data}`, + ); host.markMemoryPointer(dataPtr, "array:header"); B.line(`${data} = load ptr, ptr ${dataPtr}${host.fieldAliasAttachment(dataPtr)}`); - B.line(`${statesPtr} = getelementptr inbounds %ScrArr, ptr ${array}, i32 0, i32 8`); + B.line( + `${statesPtr} = getelementptr inbounds %ScrArr, ptr ${array}, i32 0, i32 ${SCR_ARR_FIELD.present}`, + ); host.markMemoryPointer(statesPtr, "array:header"); B.line(`${states} = load ptr, ptr ${statesPtr}${host.fieldAliasAttachment(statesPtr)}`); const widen = (value: string): string => { @@ -389,9 +394,9 @@ export function emitDenseArrayPush( join = B.newLabel("arr.push.join"); B.condBr(room, fast, slow); B.startBlock(fast); - const dataPtr = header(7), + const dataPtr = header(SCR_ARR_FIELD.data), data = B.tmp(), - statesPtr = header(8), + statesPtr = header(SCR_ARR_FIELD.present), states = B.tmp(); B.line(`${data} = load ptr, ptr ${dataPtr}${host.fieldAliasAttachment(dataPtr)}`); B.line(`${states} = load ptr, ptr ${statesPtr}${host.fieldAliasAttachment(statesPtr)}`); diff --git a/packages/compiler/src/backend/llvm/dyn.ts b/packages/compiler/src/backend/llvm/dyn.ts index b474068cc..56b18e2b4 100644 --- a/packages/compiler/src/backend/llvm/dyn.ts +++ b/packages/compiler/src/backend/llvm/dyn.ts @@ -1,6 +1,6 @@ import { typedRefConstructor } from "./shapes.js"; import { bindLiveArrayOps } from "./expr-stream-bridges.js"; -import { BYTES_ELEM_NUM, f64Lit } from "./common.js"; +import { BYTES_ELEM_NUM, SCR_ARR_FIELD, f64Lit } from "./common.js"; import { emitUnionPeek, emitUnionTag } from "./union-repr.js"; import { InternalCompilerError } from "../../errors.js"; /* ScrDyn helpers for the LLVM backend: per-type match predicates @@ -1199,8 +1199,8 @@ export class LlDyn { : [ { index: 1, type: host.sizeType, name: "length" }, { index: 2, type: host.sizeType, name: "capacity" }, - { index: 7, type: "ptr" as const, name: "data" }, - { index: 8, type: "ptr" as const, name: "presence" }, + { index: SCR_ARR_FIELD.data, type: "ptr" as const, name: "data" }, + { index: SCR_ARR_FIELD.present, type: "ptr" as const, name: "presence" }, ]; members.forEach((member) => { const cachedPtr = B.tmp(); diff --git a/packages/compiler/src/backend/llvm/emitter.test.ts b/packages/compiler/src/backend/llvm/emitter.test.ts index 958df8cbe..8b8c166ca 100644 --- a/packages/compiler/src/backend/llvm/emitter.test.ts +++ b/packages/compiler/src/backend/llvm/emitter.test.ts @@ -99,6 +99,26 @@ test("separate LLVM parts preserve complete module bytes in native, WASI, and de } }); +test("the shared indexed-read helpers carry an inline hint", () => { + const helper = (name: string): IrFunction => ({ + name, + params: [], + returnType: F64, + locals: [], + body: [{ kind: "return", value: { kind: "numLit", value: 1, type: F64, loc }, loc }], + loc, + }); + const module = moduleFor([]); + const llvm = emitLlvmModule({ + ...module, + functions: [...module.functions, helper("%arr.idxOr.0"), helper("plain")], + }); + const define = (name: string): string => + llvm.split("\n").find((line) => line.startsWith("define") && line.endsWith(`{ ; ${name}`))!; + expect(define("%arr.idxOr.0")).toMatch(/\) inlinehint #0 \{/); + expect(define("plain")).not.toContain("inlinehint"); +}); + test("throwing-call count does not multiply identical scope cleanup", () => { for (const boxed of [false, true]) { const small = emitLlvmModule(moduleFor(Array.from({ length: 4 }, call), { boxed })); diff --git a/packages/compiler/src/backend/llvm/emitter.ts b/packages/compiler/src/backend/llvm/emitter.ts index 5ac705048..9f405c3bb 100644 --- a/packages/compiler/src/backend/llvm/emitter.ts +++ b/packages/compiler/src/backend/llvm/emitter.ts @@ -99,6 +99,7 @@ import { scalarizeNumericRecords } from "../../ir/scalar-records.js"; import { specializeNumericCalls } from "../../ir/numeric-call-specialization.js"; import { everyExprChild, everyStmtChild, everyStmtList } from "../../ir/traverse.js"; import { analyzeIntegerRanges, INT32_RANGE, type IntegerRanges } from "../../ir/integer-ranges.js"; +import { unshareNodes } from "../../ir/unshare.js"; import { analyzeInt32Slots, type Int32Slots } from "../../ir/int32-slots.js"; import { analyzeFinalFields, constructorClass, type FinalFields } from "../../ir/final-fields.js"; import { foldConstantGlobals } from "../../ir/constant-globals.js"; @@ -159,10 +160,11 @@ import { type MapReadLifetimes, } from "./map-read-lifetimes.js"; import { emitBorrowedFieldSequence, guardedValue } from "./borrowed-receivers.js"; -import { emitBorrowedInput } from "./borrowed-inputs.js"; -import { analyzeWalks, findWalkBorrows } from "./walk-borrows.js"; +import { borrowableInputs, emitBorrowedInput } from "./borrowed-inputs.js"; +import { analyzeWalks, findWalkBorrows, type WalkBorrowHost } from "./walk-borrows.js"; import { findReboundParameters } from "./rebound-parameters.js"; import { ReferenceEffects } from "./reference-effects.js"; +import { ReferenceWrites, type Writes } from "./reference-writes.js"; import { LlvmDebugInfo } from "./debug-info.js"; import { StackCallbacks } from "./stack-callbacks.js"; import { findLoopArrayBorrows } from "./loop-array-borrows.js"; @@ -197,6 +199,7 @@ import { emitBorrowedResultCall, emitCallExpr } from "./expr-calls.js"; import { emitDynamicExpr } from "./expr-dynamic.js"; import { emitIntrinsicExpr, emitSerializationExpr, emitAsyncExpr } from "./expr-async.js"; import { PublishWalkers } from "./publish.js"; +import { computeImmutableFields, stableGlobals, type ImmutableFields } from "../immutability.js"; import { computePublishedTypes, type PublishedTypes } from "../publication.js"; import { emitJsInteropExpr, emitExpr } from "./expr-dispatch.js"; import { @@ -301,7 +304,7 @@ import { LlWalkers } from "./walkers.js"; import { isObjectArm, NULLABLE_ABSENT, NULLABLE_NULL, NullableUnions } from "./nullable-unions.js"; import { emitNullablePresent, emitUnionPeek, emitUnionTag } from "./union-repr.js"; import { literalCapWord, literalCapWord32 } from "./string-key-hash.js"; -import { NUMBER_MAP_ENTRY_DECL } from "./map-number-lookup.js"; +import { NUMBER_MAP_ENTRY_DECL, STRING_MAP_ENTRY_DECL } from "./map-number-lookup.js"; import { STRING_READ_HELPERS } from "./string-reads.js"; import { emitConcatInputs, @@ -407,7 +410,10 @@ export interface LlvmTargetOptions { detachedExit?: boolean; } -export function emitLlvmModule(mod: IrModule, options: LlvmTargetOptions = {}): string { +export function emitLlvmModule(input: IrModule, options: LlvmTargetOptions = {}): string { + // Facts are keyed by node identity: emit the same module whether it was + // lowered in memory or read back from its serialized form. + const mod = unshareNodes(input); // Keep source storage intact for debugger inspection in dev builds. return new LlEmitter( options.debugSources === undefined @@ -419,9 +425,10 @@ export function emitLlvmModule(mod: IrModule, options: LlvmTargetOptions = {}): /** Keep large translation units below the host's single-string limit. */ export function emitLlvmModuleSource( - mod: IrModule, + input: IrModule, options: LlvmTargetOptions = {}, ): string | readonly string[] { + const mod = unshareNodes(input); const parts = new LlEmitter( options.debugSources === undefined ? scalarizeNumericRecords(specializeNumericCalls(foldConstantGlobals(mod), mangleFunction)) @@ -598,6 +605,12 @@ export class LlEmitter { * fiberless-async analysis scans it for suspension entry points. */ private readonly fnDefText = new Map(); readonly referenceEffects: ReferenceEffects; + /** Field-sensitive reference writes (null in debug builds). */ + referenceWrites: ReferenceWrites | null = null; + private readonly borrowedReturnKeyCache = new Map(); + /** The statement list being emitted and the current index, for blocks + * whose bindings end with the list (emitBlock and function bodies). */ + private stmtCursor: { stmts: IrStmt[]; index: number } | null = null; readonly optionalArrayReads: OptionalArrayReads; readonly checkedNarrows: CheckedNarrows; callArrayReads = new Map(); @@ -641,6 +654,9 @@ export class LlEmitter { readonly ffiHasRetainedCallback: boolean; private readonly ffiHasForeignCallback: boolean; private readonly globalTypes = new Map(); + /** Module constants that keep one value once initialized + * (immutability.ts stableGlobals). */ + private stableGlobals: ReadonlySet = new Set(); private readonly tdzGlobals = new Map(); readonly constantNumericTables: ReadonlyMap; /** May-throw analysis (computeMayThrow): pending @@ -656,6 +672,13 @@ export class LlEmitter { /** Static types whose values can be published (@scriptc/threads): their * stores carry the frozen-object guard. Null without publish calls. */ readonly publishedTypes: PublishedTypes | null; + /** Construction-only class and record fields (immutability.ts); null + * where the facts are disabled. */ + private readonly immutableFields: ImmutableFields | null; + /** Constructor function names: their bodies may still write their own + * `this`'s construction-only fields. */ + private readonly constructorFunctions: ReadonlySet; + private inConstructor = false; /** Method names with at least one may-throw implementation — the * virtualCall pending check's key. */ readonly mayThrowMethods = new Set(); @@ -744,6 +767,9 @@ export class LlEmitter { private readonly initializerBindings: ReturnType; /** Whole-program int32 storage and parameter/result facts. */ readonly int32Slots: Int32Slots; + /** Immutable module constants (contract types) whose graphs become + * immortal once initialized: their reads need no reference counting. */ + readonly immortalGlobals: ReadonlySet; private numericLocals = new Map(); private captureIds = new Set(); /** Active induction bindings retain their width independently of size_t. */ @@ -831,6 +857,7 @@ export class LlEmitter { this.constantNumericTables = findConstantNumericTables(mod); this.initializerBindings = findInitializerBindings(mod); this.int32Slots = analyzeInt32Slots(mod); + this.immortalGlobals = new Set(mod.contracts?.immortalGlobals ?? []); this.finalFields = analyzeFinalFields(mod); this.sizeType = options.pointerBits === 32 ? "i32" : "i64"; this.ffiExtendNarrowIntegers = @@ -884,6 +911,8 @@ export class LlEmitter { this.workerEntryPolls = mt.workerEntryPolls ?? null; this.stackChecks = mt.stackChecks ?? null; this.publishedTypes = computePublishedTypes(mod); + this.immutableFields = computeImmutableFields(mod); + this.constructorFunctions = new Set((mod.classes ?? []).map((c) => `%${c.name}.constructor`)); this.indirectMayThrow = mt.indirect || mod.workers === true; for (const cls of mod.classes ?? []) { for (const m of cls.methods ?? []) { @@ -907,6 +936,15 @@ export class LlEmitter { (call) => this.optionalArrayReads.get(call) !== null, mod.classes ?? [], ); + if (this.debug === null) + this.referenceWrites = new ReferenceWrites( + this.fnByName, + mod.classes ?? [], + (call) => this.optionalArrayReads.get(call) !== null, + new Set((mod.globals ?? []).map((g) => g.id)), + { unions: mod.unions, records: mod.records }, + this.immutableFields, + ); const walkParameters = new Map>(); if (this.debug === null) { const host = { @@ -914,8 +952,9 @@ export class LlEmitter { borrowsWithoutOwning: (e: IrExpr) => this.borrowsWithoutOwning(e), }; for (const fn of this.fnByName.values()) { - if (!this.referenceEffects.functions.has(fn.name)) continue; - const walks = findWalkBorrows(fn, host); + const preserving = this.referenceEffects.functions.has(fn.name); + if (!preserving && this.referenceWrites === null) continue; + const walks = findWalkBorrows(fn, preserving ? host : this.unwrittenWalkHost(fn, host)); if (walks.size === 0) continue; this.walkBorrowsByFunction.set(fn.name, walks); const indexes = new Set(); @@ -1023,6 +1062,7 @@ export class LlEmitter { this.globalTypes.set(g.id, g.type); if (g.tdz) this.tdzGlobals.set(g.id, g.name); } + this.stableGlobals = stableGlobals(mod); // Runtime error, EventEmitter, and stream classes have known layouts. // Subclasses embed the ScrEmitter/ScrStream prefixes from classes.ts. const classes = mod.classes ?? []; @@ -1881,12 +1921,14 @@ export class LlEmitter { `%ScrFfiTable = type { ptr, ${this.sizeType}, ${this.sizeType}, ptr, i8, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ptr }`, `%ScrRegex = type { ${this.sizeType}, ptr, ptr, ptr, double, ptr, ptr }`, // ScrArr mirrors scr_runtime.h field-for-field: { rc, len, cap, elem, - // elem_retain, elem_release, elem_trace, data, present, ext }, where - // ext points at the out-of-line sparse, property and metadata storage - // (NULL until first used). Live dynamic stream commits swap its dense, - // presence and out-of-line storage while preserving the target - // object's identity. - `%ScrArr = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, i32, ptr, ptr, ptr, ptr, ptr, ptr }`, + // cyc, ops, data, present, ext } (field numbers in SCR_ARR_FIELD), + // where ops points at the element type's constant RC descriptor + // (%ScrArrOps, SCR_ELEM_REF only) and ext at the out-of-line sparse, + // property and metadata storage (NULL until first used). Live dynamic + // stream commits swap its dense, presence and out-of-line storage while + // preserving the target object's identity. + `%ScrArr = type { ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, i32, i32, ptr, ptr, ptr, ptr }`, + `%ScrArrOps = type { ptr, ptr, ptr }`, // The ScrMap prefix { rc, key_kind, val_kind, val_retain, val_release, // val_trace, key_retain, key_release, key_trace } — the inline RC // fast paths test the two trace slots (shapes.ts). @@ -1899,9 +1941,13 @@ export class LlEmitter { ...(this.decls.has(NUMBER_MAP_ENTRY_DECL) ? [ `%ScrMapIx = type { ${this.sizeType}, i32, i32, ptr, ptr, ptr, ptr, ptr, ptr, ${this.sizeType}, ${this.sizeType}, ${this.sizeType}, ptr, ${this.sizeType}, ptr, ${this.sizeType}, ptr, ptr, ptr, ${this.sizeType} }`, - `%ScrMapEntry = type { i64, i64, i64 }`, ] : []), + // String-keyed reference reads load the value slot of the entry + // scr_map_entry_str returns (map-number-lookup.ts). + ...(this.decls.has(NUMBER_MAP_ENTRY_DECL) || this.decls.has(STRING_MAP_ENTRY_DECL) + ? [`%ScrMapEntry = type { i64, i64, i64 }`] + : []), // The runtime error prefix { rc, vt, name, message, code, cause } and the // class-object shape { rc, pre, post, ctor, name } — field reads on // builtin errors and classval loads GEP through these. @@ -2067,7 +2113,7 @@ export class LlEmitter { out.push( `@${inst.sym}_data = internal constant [${n} x ptr] [ ${inst.slots.map((s) => `ptr ${s}`).join(", ")} ]`, `@${inst.sym}_present = internal constant [${n} x i8] ${present}`, - `@${inst.sym} = internal global %ScrArr { ${this.sizeType} -1, ${this.sizeType} ${n}, ${this.sizeType} ${n}, i32 2, ptr null, ptr null, ptr null, ptr @${inst.sym}_data, ptr @${inst.sym}_present, ptr null }`, + `@${inst.sym} = internal global %ScrArr { ${this.sizeType} -1, ${this.sizeType} ${n}, ${this.sizeType} ${n}, i32 2, i32 0, ptr null, ptr @${inst.sym}_data, ptr @${inst.sym}_present, ptr null }`, ); } if (this.templateStringsInstances.size > 0) out.push(``); @@ -5089,6 +5135,7 @@ export class LlEmitter { const numericFn = withInitializerBindings(fn, initializerBindings); this.numericLocals = new Map(numericFn.locals.map((l) => [l.id, l])); this.borrowedParameters.clear(); + this.referenceWrites?.enter(fn); this.reboundOwnerSlots.clear(); this.projectedParameters.clear(); const projectedParameterIndexes = this.callLifetimes.parameters.get(fn.name); @@ -5129,6 +5176,7 @@ export class LlEmitter { this.callLifetimes, this.referenceEffects, this.optionalArrayReads, + this.referenceWrites, ) : new Set(); this.localArrayReads = findLocalArrayReads( @@ -5169,6 +5217,7 @@ export class LlEmitter { this.currentReturnType = fn.returnType; this.currentGenerator = fn.generator ?? null; this.currentBorrowedReturn = this.borrowedReturns.has(fn.name); + this.inConstructor = this.constructorFunctions.has(fn.name); this.currentWasiCoro = null; this.logArgSlots = 0; @@ -5335,7 +5384,7 @@ export class LlEmitter { } if (this.stackChecks?.has(fn.name)) this.emitStackCheck(); if (this.workerEntryPolls?.has(fn.name)) this.emitPendingCheck(undefined, true); - this.emitStmts(fn.body); + this.emitStmts(fn.body, true); // Implicit exit of a void function: release the function scope unless // the body already terminated its final block (return, or a throw // whose unwind released everything down to depth 0). @@ -5399,7 +5448,13 @@ export class LlEmitter { // Lifted functions receive their closure first (the callValue ABI). if (fn.captures !== undefined) params.unshift("ptr %sc_env"); const ret = this.llType(fn.returnType); - const attrs = coro !== null ? "#1" : FN_ATTRS; + let attrs = coro !== null ? "#1" : FN_ATTRS; + // The shared indexed-read helper (lowerSafeIndexRead) is a dense bounds + // test, a state test and a load behind cold runtime fallbacks, called + // from every `a[i]` of one element type. Without the hint LLVM keeps the + // hot instances out of line once they have many callers: every read pays + // a call, and an integer index converts to a double and back across it. + if (fn.name.startsWith("%arr.idxOr.")) attrs = `inlinehint ${attrs}`; const debug = this.debugScope === null ? "" : ` !dbg ${this.debugScope}`; const symbol = borrowed ? mangleBorrowedFunction(fn.name) : mangleFunction(fn.name); const body = `define internal ${ret} @${symbol}(${params.join(", ")}) ${attrs}${debug} { ; ${fn.name}\n${B.render()}\n}`; @@ -5504,11 +5559,17 @@ export class LlEmitter { this.canBorrowCallArgument(value.then) && this.canBorrowCallArgument(value.else_) ); + // A construction-only field of a stable owner keeps its value until the + // owner dies: no later operand or callee can replace and release it. + if ((value.kind === "fieldGet" || value.kind === "recordGet") && this.immutableRead(value)) + return this.canBorrowCallArgument(value.obj); // An optional chain's bound receiver stays unchanged until its body // finishes (see emitReadReceiver). if (value.kind === "chainRecv") return this.chainSlots.has(value.id); if (value.kind !== "varRef") return false; const binding = this.binding(value.localId); + // A module constant owns its value for the rest of the program. + if (binding.kind === "global") return this.stableGlobals.has(value.localId); return ( binding.kind === "local" && binding.local !== undefined && @@ -5521,15 +5582,213 @@ export class LlEmitter { ); } + /** A plain-pointer read of a construction-only field outside any + * constructor (ImmutableFields). */ + private immutableRead(e: ExprOf<"fieldGet" | "recordGet">): boolean { + if (this.inConstructor || this.immutableFields === null) return false; + const t = e.type.kind; + if (t !== "object" && t !== "record" && t !== "array" && t !== "string") return false; + return e.kind === "fieldGet" + ? this.immutableFields.classField(e.className, e.field) + : this.immutableFields.recordField(e.shapeId, e.field); + } + + /** A projection read whose locations nothing writes while a borrowed + * read of it is in use (ReferenceWrites), given the writes of that + * extent. The root binding itself must stay alive across it too, which + * its own location (`l:`, `g:`, `bx`) covers. */ + unwrittenRead(e: IrExpr, writes: Writes): boolean { + const rw = this.referenceWrites; + if (rw === null) return false; + const keys = rw.readKeys(e, (call) => this.borrowedReturnKeys(call.callee)); + return keys !== null && !rw.conflicts(keys, writes); + } + + /** A stable binding initialized by a projection can borrow it when the + * rest of its block (its whole lifetime) writes none of the projection's + * locations: the source edge then keeps the value alive, and uses that + * escape still retain their own copies. */ + private unwrittenAlias(s: IrStmt & { kind: "varDecl" }): boolean { + const cursor = this.stmtCursor; + const rw = this.referenceWrites; + if (rw === null || s.init === null || cursor === null || cursor.stmts[cursor.index] !== s) + return false; + if ( + !this.plainReference(s.init.type) || + !this.canBorrowReceiver(s.init) || + !this.unownedWalk(s.init) + ) + return false; + const writes = rw.union([rw.expr(s.init), rw.stmts(cursor.stmts.slice(cursor.index + 1))]); + return this.unwrittenRead(s.init, writes); + } + + /** An optional element read into a projection-only local can borrow the + * element when the rest of the block writes no array element and none of + * the locations keeping the array alive (which must itself be read + * without a frame owner). */ + private unwrittenLocalArrayRead(s: IrStmt & { kind: "varDecl" }, read: LocalArrayRead): boolean { + const cursor = this.stmtCursor; + const rw = this.referenceWrites; + if (rw === null || s.init === null || cursor === null || cursor.stmts[cursor.index] !== s) + return false; + if (!this.unownedWalk(read.array)) return false; + const keys = rw.readKeys(read.array); + if (keys === null || rw.expr(read.index) !== null) return false; + const writes = rw.union([rw.expr(s.init), rw.stmts(cursor.stmts.slice(cursor.index + 1))]); + return !rw.conflicts(["a", ...keys], writes); + } + + /** An optional element read passed to a projection-only parameter can + * borrow the element when the callee and later arguments (`writes`) + * write no array element and nothing keeping the array alive. */ + unwrittenCallArrayRead(read: LocalArrayRead, writes: Writes): boolean { + const rw = this.referenceWrites; + if (rw === null) return false; + const keys = rw.readKeys(read.array); + if (keys === null || rw.expr(read.index) !== null) return false; + return !rw.conflicts(["a", ...keys], writes); + } + + /** `return x` of a local whose slot is an owned scope entry of the same + * type: the return can take over the local's reference. */ + private movableReturn( + value: IrExpr | null, + ): { scope: LlScopeEntry[]; entry: LlScopeEntry; index: number } | null { + if (value === null || value.kind !== "varRef" || !isRefCounted(value.type)) return null; + if (this.currentBorrowedReturn || this.currentWasiCoro !== null) return null; + const binding = this.binding(value.localId); + if (binding.kind !== "local" || binding.local === undefined || binding.local.boxed) return null; + if (!typeEquals(binding.type, value.type) || !typeEquals(this.currentReturnType, value.type)) + return null; + for (const scope of this.scopes) { + const index = scope.findIndex((entry) => entry.slot === binding.slot); + if (index < 0) continue; + const entry = scope[index]!; + if (entry.boxed || entry.lazy || !typeEquals(entry.type, value.type)) return null; + return { scope, entry, index }; + } + return null; + } + + /** A walk host for a body that may write the heap: each walk must read + * only locations the whole body (with its callees) never writes; + * rebinding the walk locals themselves releases nothing. */ + private unwrittenWalkHost(fn: IrFunction, host: WalkBorrowHost): WalkBorrowHost { + return { + ...host, + unwritten: (value, candidates) => + this.referenceWrites?.unwrittenWalk(fn, value, candidates, (call) => + this.borrowedReturnKeys(call.callee), + ) ?? false, + }; + } + + /** emitReadReceiver yields a plain pointer for `e` that no statement + * frame owns, so it can outlive the statement (walk-borrows' walks, from + * any unboxed plain-pointer binding, plus element reads). */ + private unownedWalk(e: IrExpr): boolean { + switch (e.kind) { + case "varRef": { + const binding = this.binding(e.localId); + if (binding.kind === "global") return this.plainReference(binding.type); + return ( + binding.kind === "local" && + binding.local !== undefined && + !binding.local.boxed && + !binding.local.tdz && + this.plainReference(binding.local.type) && + !this.stringSlices.has(e.localId) && + !this.storedSplits.has(e.localId) && + !this.localUnionStorage.has(e.localId) + ); + } + case "fieldGet": + case "recordGet": + return this.borrowsWithoutOwning(e) && this.unownedWalk(e.obj); + case "unionNarrow": + case "downcast": + case "upcast": + return this.borrowsWithoutOwning(e) && this.unownedWalk(e.value); + case "unionWrap": + if (!this.borrowsWithoutOwning(e)) return false; + return e.value.kind === "unitLit" || this.unownedWalk(e.value); + case "ternary": { + const arm = (v: IrExpr): boolean => + (v.kind === "libCall" && v.fn === "error.nodeThrow") || this.unownedWalk(v); + return this.borrowsWithoutOwning(e) && arm(e.then) && arm(e.else_); + } + case "call": + return ( + this.borrowsWithoutOwning(e) && + e.args.every((arg) => !isRefCounted(arg.type) || this.unownedWalk(arg)) + ); + case "arrayGet": + return ( + !this.isStackUnionSource(e) && + this.optionalArrayReads.get(e) === null && + this.unownedWalk(e.arr) + ); + case "seqExpr": { + const guarded = guardedValue(e); + return guarded !== null && this.unownedWalk(guarded); + } + default: + return false; + } + } + + /** Every location a borrowed-return callee's walks can read (its body's + * field, record and element reads, through nested borrowed returns). */ + private borrowedReturnKeys(callee: string): string[] | null { + if (!this.borrowedReturns.has(callee)) return null; + const known = this.borrowedReturnKeyCache.get(callee); + if (known) return known; + const rw = this.referenceWrites!; + const keys = new Set(); + const seen = new Set([callee]); + const pending = [callee]; + while (pending.length > 0) { + const fn = this.fnByName.get(pending.pop()!); + if (!fn) continue; + everyStmtList(fn.body, { + stmt: () => true, + expr: (e) => { + if (e.kind === "fieldGet") keys.add(rw.fieldKey(e.className, e.field)); + else if (e.kind === "recordGet") { + keys.add(`r:${e.field}`); + keys.add("r:*"); + } else if (e.kind === "arrayGet") keys.add("a"); + else if (e.kind === "call" && this.borrowedReturns.has(e.callee) && !seen.has(e.callee)) { + seen.add(e.callee); + pending.push(e.callee); + } + return true; + }, + }); + } + const result = [...keys]; + this.borrowedReturnKeyCache.set(callee, result); + return result; + } + // ── statements ────────────────────────────────────────────────────────── - private emitStmts(stmts: IrStmt[]): void { - for (const s of stmts) { - // Statements after a terminator are unreachable (dead code after - // return/break/continue). Skip them so no dropped SSA definition - // can leak forward. - if (this.B.isTerminated()) return; - this.emitStmt(s); + private emitStmts(stmts: IrStmt[], scoped = false): void { + const saved = this.stmtCursor; + const cursor = scoped ? { stmts, index: 0 } : null; + try { + for (let i = 0; i < stmts.length; i++) { + // Statements after a terminator are unreachable (dead code after + // return/break/continue). Skip them so no dropped SSA definition + // can leak forward. + if (this.B.isTerminated()) return; + if (cursor) cursor.index = i; + this.stmtCursor = cursor; + this.emitStmt(stmts[i]!); + } + } finally { + this.stmtCursor = saved; } } @@ -5542,7 +5801,7 @@ export class LlEmitter { const scope: LlScopeEntry[] = []; this.scopes.push(scope); setup?.(scope); - this.emitStmts(stmts); + this.emitStmts(stmts, true); const ended = endsWithJump(stmts); this.scopes.pop(); if (!ended) this.releaseScope(scope); @@ -5606,7 +5865,13 @@ export class LlEmitter { } const localRead = this.localArrayReads.get(s.localId); if (localRead) { - const owner = emitLocalArrayRead(this, localRead, b.slot); + const owner = emitLocalArrayRead( + this, + !localRead.borrow && this.unwrittenLocalArrayRead(s, localRead) + ? { ...localRead, borrow: true } + : localRead, + b.slot, + ); if (owner) this.scopes[this.scopes.length - 1]!.push(owner); break; } @@ -5695,7 +5960,7 @@ export class LlEmitter { b.local && isRefCounted(b.type) && this.stableCallBindings.has(s.localId) && - this.canBorrowCallArgument(s.init) + (this.canBorrowCallArgument(s.init) || this.unwrittenAlias(s)) ) { const v = this.emitReadReceiver(s.init); B.line(`store ptr ${v.name}, ptr ${b.slot}`); @@ -5761,6 +6026,33 @@ export class LlEmitter { } B.line(`store ${this.llType(b.type)} ${v.name}, ptr ${b.slot}`); this.storeIntegerView(s.localId, v, s.value); + if (b.kind === "global" && this.immortalGlobals.has(s.localId)) { + // An Immutable module constant (contracts/check.ts proved it is + // fresh, publishable and never written): its graph becomes + // immortal, so reads skip reference counting and the collector + // never visits it. + const lines = this.publishWalkers.emitPublish(v.name, v.type, s.loc); + for (const line of lines) B.line(line.trimStart()); + // Reads of this global skip retains from here on, which is only + // sound once the graph really is immortal. Node.js never fails + // here, so a refusal means the contract proof was wrong: stop + // rather than keep running with a mortal graph read as immortal. + if (lines.length > 0) { + this.declare(`declare zeroext i1 @scr_exc_pending()`); + this.declare(`declare void @scr_trap(ptr)`); + const refused = B.tmp(); + B.line(`${refused} = call zeroext i1 @scr_exc_pending()`); + const stop = B.newLabel("immutable.refused"); + const done = B.newLabel("immutable.published"); + B.condBr(refused, stop, done); + B.startBlock(stop); + B.line( + `call void @scr_trap(ptr ${this.cstr("scriptc: internal error: an Immutable value could not be published\n")})`, + ); + B.terminate("unreachable"); + B.startBlock(done); + } + } break; } case "exprStmt": @@ -5877,21 +6169,21 @@ export class LlEmitter { const obj = this.emitStableReceiver(s.obj, [s.value]); // (The guard precedes the value here: the nullable store // evaluates it itself.) - this.emitPublishedFieldGuard(obj.name, s.className, s.field); + this.emitStoreGuard(obj.name, s); this.emitNullableFieldStore(obj.name, s.className, s.field, nullable, s.value); break; } if (s.kind === "fieldSet" && this.int32Slots.isField(s.className, s.field)) { const obj = this.emitStableReceiver(s.obj, [s.value]); const v = this.emitExpr(s.value); - this.emitPublishedFieldGuard(obj.name, s.className, s.field); + this.emitStoreGuard(obj.name, s); const { ptr } = this.classFieldPtr(obj.name, s.className, s.field); this.storeInt32Field(ptr, v, s.value); break; } const obj = this.emitStableReceiver(s.obj, [s.value]); const v = this.emitExpr(s.value); - if (s.kind === "fieldSet") this.emitPublishedFieldGuard(obj.name, s.className, s.field); + if (s.kind === "fieldSet") this.emitStoreGuard(obj.name, s); else if (this.publishedTypes?.recordGuarded(s.shapeId) === true) this.emitPublishedFieldGuard(obj.name, null, s.field); const { ptr, type } = @@ -6596,10 +6888,29 @@ export class LlEmitter { // the actual ret. The parked value owns a synthetic slot-backed // scope entry during each copy so a throwing finally releases it. let v: LlValue | null = null; - if (s.value !== null && this.currentBorrowedReturn) { + const moved = this.finallyStack.length === 0 ? this.movableReturn(s.value) : null; + if (moved !== null) { + // Returning an owned local hands its reference to the caller: no + // retain now and no release of the local below. + const t = B.tmp(); + B.line(`${t} = load ptr, ptr ${moved.entry.slot}`); + v = { name: t, type: s.value!.type }; + moved.scope.splice(moved.scope.indexOf(moved.entry), 1); + this.releaseForJump(0, 0); + moved.scope.splice(moved.index, 0, moved.entry); + } else if (s.value !== null && this.currentBorrowedReturn) { // A borrowed-return body hands back its walk without a reference - // (it has no try statements, so no finally can intervene). - v = this.emitReadReceiver(s.value); + // (it has no try statements, so no finally can intervene). An + // optional element read lends the element its array keeps alive. + const read = this.optionalArrayReads.get(s.value); + if (read) { + const slot = B.slot(); + B.entryAllocas.push(`${slot} = alloca ptr`); + emitLocalArrayRead(this, { ...read, borrow: true }, slot); + const t = B.tmp(); + B.line(`${t} = load ptr, ptr ${slot}`); + v = { name: t, type: s.value.type }; + } else v = this.emitReadReceiver(s.value); } else if (s.value !== null) { v = this.emitExpr(s.value); this.moveTemp(v); @@ -6631,7 +6942,7 @@ export class LlEmitter { this.scopes = savedScopes; this.finallyStack = savedFinally; this.tryStack = savedTry; - } else { + } else if (moved === null) { this.releaseForJump(0, 0); } if (!B.isTerminated()) { @@ -6886,7 +7197,7 @@ export class LlEmitter { const caseLabels = s.cases.map(() => B.newLabel("sw.c")); const defaultIdx = s.cases.findIndex((c) => c.test === null); const fallback = defaultIdx >= 0 ? caseLabels[defaultIdx]! : end; - if (!emitLiteralSwitch(this, disc, s.cases, caseLabels, fallback)) { + if (!emitLiteralSwitch(this, disc, s.disc, s.cases, caseLabels, fallback)) { s.cases.forEach((c, i) => { if (c.test === null) return; // Lazy source-order test evaluation (a test after the match never @@ -7342,6 +7653,13 @@ export class LlEmitter { ]; } + /** The frozen-object guard of a class field store, unless the store + * provably targets a still-private `this` (PublishedTypes.privateStores). */ + private emitStoreGuard(obj: string, s: Extract): void { + if (this.publishedTypes?.privateStores.has(s) === true) return; + this.emitPublishedFieldGuard(obj, s.className, s.field); + } + /** The frozen-object guard of a class field or record field store: * Node's "Cannot assign to read only property" TypeError when the target * is published. `className` null means a record (`#`). */ @@ -7498,6 +7816,10 @@ export class LlEmitter { if (result.owner) this.ownSlot(result.owner.slot, result.owner.type); return result.value; } + // A borrowed-return helper (such as an optional element read) lends its + // result like any borrowed-return call. + if (e.kind === "call" && this.borrowedReturns.has(e.callee) && this.canBorrowReceiver(e)) + return emitBorrowedResultCall(this, e); const arrayRead = this.optionalArrayReads.get(e); if (arrayRead) return emitProjectedArrayRead(this, arrayRead); const narrow = this.checkedNarrows.get(e); @@ -7763,17 +8085,21 @@ export class LlEmitter { const wrap = this.borrowableNullableWrap(e); return wrap === "unit" || (wrap === "ref" && this.canBorrowReceiver(e.value)); } - // A borrowed-return callee preserves edges, so its result stays - // reachable from borrowable arguments until the consumer runs. - case "call": - return ( - this.borrowedReturns.has(e.callee) && - e.args.every( - (arg) => - (!isRefCounted(arg.type) || this.canBorrowReceiver(arg)) && - this.referenceEffects.preserves(arg), - ) - ); + // A borrowed-return result stays reachable from its borrowed + // arguments until the consumer runs. Each argument is lent without a + // snapshot, so neither the callee nor a later argument may replace + // what it was read from: a callee that preserves every edge cannot, + // and any other one must leave the argument's locations unwritten. + case "call": { + if (!this.borrowedReturns.has(e.callee)) return false; + if (!e.args.every((arg) => this.referenceEffects.preserves(arg))) return false; + const preserving = this.referenceEffects.functions.has(e.callee); + if (preserving) + return e.args.every((arg) => !isRefCounted(arg.type) || this.canBorrowReceiver(arg)); + if (this.referenceWrites === null) return false; + const lent = borrowableInputs(this, e.args, false, this.referenceWrites.summary(e.callee)); + return e.args.every((arg, i) => !isRefCounted(arg.type) || lent[i] === true); + } // A required element read: the (borrowed) array owns the element // while an edge-preserving index computes. case "arrayGet": @@ -7821,17 +8147,20 @@ export class LlEmitter { const indexes = this.callLifetimes.borrowed.get(fn.name); return new Set(fn.params.filter((_, i) => indexes?.has(i)).map((p) => p.localId)); }; - const hostFor = (fn: IrFunction) => { + const hostFor = (fn: IrFunction): WalkBorrowHost => { const allowed = borrowedIds(fn); - return { + const host = { pointerLocal: (local: IrLocal) => pointer(local.type), borrowsWithoutOwning: (e: IrExpr) => this.borrowsWithoutOwning(e), borrowedReturn: (callee: string) => this.borrowedReturns.has(callee), parameterAllowed: (id: string) => allowed.has(id), }; + return this.referenceEffects.functions.has(fn.name) ? host : this.unwrittenWalkHost(fn, host); }; - const preserving = [...this.fnByName.values()].filter((fn) => - this.referenceEffects.functions.has(fn.name), + // With ReferenceWrites, a body that writes none of its walks' locations + // qualifies like one that preserves every edge. + const preserving = [...this.fnByName.values()].filter( + (fn) => this.referenceEffects.functions.has(fn.name) || this.referenceWrites !== null, ); const candidates = preserving.filter((fn) => { if (!pointer(fn.returnType) || fn.async || fn.generator || fn.captures) return false; @@ -7851,6 +8180,8 @@ export class LlEmitter { if (this.borrowedReturns.has(fn.name)) continue; if (!analyzeWalks(fn, hostFor(fn)).returnsWalk) continue; this.borrowedReturns.add(fn.name); + // Nested borrowed returns extend the locations a caller depends on. + this.borrowedReturnKeyCache.clear(); changed = true; } } @@ -7875,6 +8206,14 @@ export class LlEmitter { return this.nullableFieldGet(e) === null; case "recordGet": return true; + // emitReadReceiver lends a required element of a borrowed array when + // computing the index removes no edge. + case "arrayGet": + return ( + e.arr.type.kind === "array" && + this.optionalArrayReads.get(e) === null && + this.referenceEffects.preserves(e.index) + ); case "unionNarrow": return this.nullableUnions.has(e.unionId); case "downcast": diff --git a/packages/compiler/src/backend/llvm/expr-calls.ts b/packages/compiler/src/backend/llvm/expr-calls.ts index d707de555..afd2ae7b0 100644 --- a/packages/compiler/src/backend/llvm/expr-calls.ts +++ b/packages/compiler/src/backend/llvm/expr-calls.ts @@ -25,7 +25,13 @@ import { f64Lit, ffiNativeTypeLl, ffiNativeParamLl, ffiNativeReturnLl } from "./ import { canStackUnion, emitStackUnion } from "./stack-unions.js"; import { emitCallArrayRead } from "./local-array-reads.js"; import { emitStackMapRead } from "./map-read-lifetimes.js"; -import { borrowableInputs, emitBorrowedInput, emitBorrowedInputs } from "./borrowed-inputs.js"; +import { + borrowableInputs, + emitBorrowedInput, + emitBorrowedInputs, + inputSuffixWrites, +} from "./borrowed-inputs.js"; +import type { Writes } from "./reference-writes.js"; export function emitCallExpr( host: LlvmEmitterContext, @@ -58,12 +64,18 @@ export function emitCallExpr( const borrowed = host.callLifetimes.borrowed.get(e.callee); const projected = host.callLifetimes.parameters.get(e.callee); const inputs = borrowed - ? borrowableInputs(host, e.args, host.referenceEffects.functions.has(e.callee)) + ? borrowableInputs( + host, + e.args, + host.referenceEffects.functions.has(e.callee), + host.referenceWrites?.summary(e.callee), + ) : []; // Borrowed snapshots live through this call, not through the whole // enclosing expression. Otherwise a large initializer accumulates // owners and repeats their cleanup at every later throwing call. if (borrowed) host.frames.push([]); + let suffixes: Writes[] | undefined; const args = e.args.map((a, index) => { if (borrowed?.has(index)) { // A heap-borrowing helper may retain or return its argument. @@ -73,7 +85,18 @@ export function emitCallExpr( const callback = host.stackCallbacks.emit(host, a); if (callback) return callback; const read = host.callArrayReads.get(a); - if (read) return emitCallArrayRead(host, read); + if (read) { + suffixes ??= inputSuffixWrites( + host, + e.args, + host.referenceWrites?.summary(e.callee) ?? null, + ); + const lend = + !read.borrow && + index < suffixes.length && + host.unwrittenCallArrayRead(read, suffixes[index]!); + return emitCallArrayRead(host, lend ? { ...read, borrow: true } : read); + } const mapRead = host.mapReadLifetimes.arguments.get(a); if (mapRead) { const result = emitStackMapRead(host, mapRead); @@ -739,6 +762,7 @@ export function emitCallExpr( host, e.args, host.referenceEffects.functions.has(ctorName), + host.referenceWrites?.constructWrites(e.className), ); host.frames.push([]); const args = e.args.map((a, i) => { @@ -951,7 +975,15 @@ export function emitCallExpr( // (LlEmitter.computeVirtualBorrowing): those are passed like borrowed // arguments of a direct call, owned snapshots living in this frame. const borrowed = host.virtualSlotBorrowed(meta.root.def.name, slotIdx); - const inputs = borrowed.size > 0 ? borrowableInputs(host, e.args, false) : []; + const inputs = + borrowed.size > 0 + ? borrowableInputs( + host, + e.args, + false, + host.referenceWrites?.virtualWrites(e.className, e.method), + ) + : []; if (borrowed.size > 0) host.frames.push([]); const args = e.args.map((a, index) => borrowed.has(index) && inputs[index] ? host.emitReadReceiver(a) : host.emitExpr(a), diff --git a/packages/compiler/src/backend/llvm/expr-containers.ts b/packages/compiler/src/backend/llvm/expr-containers.ts index 4b5c0f876..05dce98fe 100644 --- a/packages/compiler/src/backend/llvm/expr-containers.ts +++ b/packages/compiler/src/backend/llvm/expr-containers.ts @@ -4,6 +4,7 @@ import { isStableReceiverOperand, undefinedArmTag } from "../../ir/analysis.js"; import { type IrExpr, type IrType, isRefCounted, typeEquals, typeKey } from "../../ir/ir.js"; import { mangleResolveThunk } from "../mangle.js"; import { + arrOps, elemAccess, FN_ATTRS, mapKeyAccess, @@ -23,11 +24,13 @@ import { borrowsMapReadInputs, borrowsMapMutationReceiver, inlineNumberKey, + entryStringKey, } from "./map-read-lifetimes.js"; import { emitNumberMapGetRef, emitNumberMapGetScalar, emitNumberMapHas, + emitStringMapGetRef, } from "./map-number-lookup.js"; import { emitBorrowedInput } from "./borrowed-inputs.js"; import { emitStringSliceRead } from "./string-slices.js"; @@ -1131,12 +1134,15 @@ export function emitMapLikeIntrinsic( return host.own({ name: t, type: e.type }); } const numberKey = inlineNumberKey(k); + const stringKey = entryStringKey(k); if (value.kind === "union") { const isnull = B.tmp(); const t = B.tmp(); let raw: string; if (numberKey !== null) { raw = emitNumberMapGetRef(host, r.name, numberKey, value); + } else if (stringKey !== null) { + raw = emitStringMapGetRef(host, r.name, stringKey, value); } else { host.declare(`declare ptr @scr_map_get_${kAcc}_ref(ptr, ${kTy})`); raw = B.tmp(); @@ -1209,6 +1215,10 @@ export function emitMapLikeIntrinsic( const raw = emitNumberMapGetRef(host, r.name, numberKey, value); return host.wrapNullable(raw, raw, value, valueTag, e.type, undefTag); } + if (stringKey !== null && isRefCounted(value)) { + const raw = emitStringMapGetRef(host, r.name, stringKey, value); + return host.wrapNullable(raw, raw, value, valueTag, e.type, undefTag); + } host.declare(`declare ptr @scr_map_get_${kAcc}_ref(ptr, ${kTy})`); const raw = B.tmp(); B.line(`${raw} = call ptr @scr_map_get_${kAcc}_ref(ptr ${r.name}, ${k.args})`); @@ -1302,10 +1312,18 @@ export function emitMapLikeIntrinsic( return { name: "", type: e.type }; case "toArray": { if (receiverType.kind !== "set") throw new InternalCompilerError("unreachable"); - // Fresh +1 elem[] of the live entries in insertion order. - host.declare(`declare ptr @scr_set_to_arr_${kAcc}(ptr)`); + // Fresh +1 elem[] of the live entries in insertion order; a REF result + // takes its element type's array descriptor. const t = B.tmp(); - B.line(`${t} = call ptr @scr_set_to_arr_${kAcc}(ptr ${r.name})`); + if (kAcc === "ref") { + host.declare(`declare ptr @scr_set_to_arr_ref(ptr, ptr)`); + B.line( + `${t} = call ptr @scr_set_to_arr_ref(ptr ${r.name}, ptr ${arrOps(host.shapeHost, receiverType.elem)})`, + ); + } else { + host.declare(`declare ptr @scr_set_to_arr_${kAcc}(ptr)`); + B.line(`${t} = call ptr @scr_set_to_arr_${kAcc}(ptr ${r.name})`); + } return host.own({ name: t, type: e.type }); } default: { diff --git a/packages/compiler/src/backend/llvm/expr-primitives.ts b/packages/compiler/src/backend/llvm/expr-primitives.ts index ea7061c4a..6807b0d07 100644 --- a/packages/compiler/src/backend/llvm/expr-primitives.ts +++ b/packages/compiler/src/backend/llvm/expr-primitives.ts @@ -89,8 +89,12 @@ export function emitLiteralExpr( B.line(`${uint32} = load i32, ptr ${integerView}`); return { name: t, type: e.type, uint32 }; } - if (isRefCounted(e.type)) + if (isRefCounted(e.type)) { + // An immortal Immutable constant: nothing to count. + if (b.kind === "global" && host.immortalGlobals.has(e.localId)) + return host.markImmortal({ name: t, type: e.type }); return host.own({ name: host.retainValue(t, e.type), type: e.type }); + } return { name: t, type: e.type }; } default: { diff --git a/packages/compiler/src/backend/llvm/expr-stream-bridges.ts b/packages/compiler/src/backend/llvm/expr-stream-bridges.ts index d6cd7ff4c..cdce1000c 100644 --- a/packages/compiler/src/backend/llvm/expr-stream-bridges.ts +++ b/packages/compiler/src/backend/llvm/expr-stream-bridges.ts @@ -16,7 +16,7 @@ import { import { mangleFunction, mangleGlobal, mangleRecordStruct } from "../mangle.js"; import { BlockBuilder } from "./blocks.js"; import { classFieldIndex, classStructSym } from "./classes.js"; -import { llvmCommentText } from "./common.js"; +import { SCR_ARR_FIELD, llvmCommentText } from "./common.js"; import { FN_ATTRS, elemAccess, @@ -176,9 +176,9 @@ export function streamTypedRefCommitAdapter( const storageMembers = [ { name: "len", index: 1, type: host.sizeType }, { name: "cap", index: 2, type: host.sizeType }, - { name: "data", index: 7, type: "ptr" }, - { name: "present", index: 8, type: "ptr" }, - { name: "ext", index: 9, type: "ptr" }, + { name: "data", index: SCR_ARR_FIELD.data, type: "ptr" }, + { name: "present", index: SCR_ARR_FIELD.present, type: "ptr" }, + { name: "ext", index: SCR_ARR_FIELD.ext, type: "ptr" }, ]; for (const member of storageMembers) { lines.push( diff --git a/packages/compiler/src/backend/llvm/local-array-reads.ts b/packages/compiler/src/backend/llvm/local-array-reads.ts index abe88c9d1..73b79b741 100644 --- a/packages/compiler/src/backend/llvm/local-array-reads.ts +++ b/packages/compiler/src/backend/llvm/local-array-reads.ts @@ -12,7 +12,7 @@ import { everyStmtList } from "../../ir/traverse.js"; import { analyzeCallLifetimes, type CallLifetimes } from "./call-lifetimes.js"; import type { LlValue, LlvmEmitterContext } from "./expr-context.js"; import { ReferenceEffects } from "./reference-effects.js"; -import { exactIndexLines } from "./common.js"; +import { SCR_ARR_FIELD, exactIndexLines } from "./common.js"; export interface LocalArrayRead { type: IrType; @@ -513,7 +513,9 @@ function emitDenseReferenceArrayRead( statePtr = B.tmp(), denseState = B.tmp(), densePresent = B.tmp(); - B.line(`${statesPtr} = getelementptr inbounds %ScrArr, ptr ${array.name}, i32 0, i32 8`); + B.line( + `${statesPtr} = getelementptr inbounds %ScrArr, ptr ${array.name}, i32 0, i32 ${SCR_ARR_FIELD.present}`, + ); host.markMemoryPointer(statesPtr, "array:header"); B.line(`${states} = load ptr, ptr ${statesPtr}${host.fieldAliasAttachment(statesPtr)}`); B.line(`${statePtr} = getelementptr inbounds i8, ptr ${states}, ${host.sizeType} ${offset}`); @@ -526,7 +528,9 @@ function emitDenseReferenceArrayRead( data = B.tmp(), valuePtr = B.tmp(), raw = B.tmp(); - B.line(`${dataPtr} = getelementptr inbounds %ScrArr, ptr ${array.name}, i32 0, i32 7`); + B.line( + `${dataPtr} = getelementptr inbounds %ScrArr, ptr ${array.name}, i32 0, i32 ${SCR_ARR_FIELD.data}`, + ); host.markMemoryPointer(dataPtr, "array:header"); B.line(`${data} = load ptr, ptr ${dataPtr}${host.fieldAliasAttachment(dataPtr)}`); B.line(`${valuePtr} = getelementptr inbounds i64, ptr ${data}, ${host.sizeType} ${offset}`); diff --git a/packages/compiler/src/backend/llvm/loop-array-borrows.ts b/packages/compiler/src/backend/llvm/loop-array-borrows.ts index 75435e7a9..07ae3ed9f 100644 --- a/packages/compiler/src/backend/llvm/loop-array-borrows.ts +++ b/packages/compiler/src/backend/llvm/loop-array-borrows.ts @@ -3,18 +3,22 @@ import { everyStmtList } from "../../ir/traverse.js"; import type { CallLifetimes } from "./call-lifetimes.js"; import type { ReferenceEffects } from "./reference-effects.js"; import type { OptionalArrayReads } from "./local-array-reads.js"; +import type { ReferenceWrites } from "./reference-writes.js"; /** Limit a borrow to a loop whose complete iteration preserves heap edges. * Initialization and unrelated work elsewhere in the function may mutate. * The array remains owned by its unchanged local or global binding; the * iteration binding can only project it or forward it to proven consumers. * Callbacks, suspension, capture, reference writes, and escaping uses keep - * the ordinary owned read. Missing elements retain the runtime's checks. */ + * the ordinary owned read. Missing elements retain the runtime's checks. + * With ReferenceWrites, an iteration that writes no array element (nor the + * binding holding the array) suffices, whatever else it writes. */ export function findLoopArrayBorrows( fn: IrFunction, lifetimes: CallLifetimes, effects: ReferenceEffects, optionalReads?: OptionalArrayReads, + writes?: ReferenceWrites | null, ): ReadonlySet { const result = new Set(); if (fn.async || fn.generator) return result; @@ -45,19 +49,28 @@ export function findLoopArrayBorrows( !local.tdz && projected?.has(loop.localId) && bindings?.has(loop.localId) && - effects.preservesScope(loop.body) && - effects.preserves(loop.iterable) + ((effects.preservesScope(loop.body) && effects.preserves(loop.iterable)) || + // The loop owns the evaluated array; only element removals can + // release an element it lends. + (writes && !writes.conflicts(["a"], writes.stmts(loop.body)))) ) result.add(loop); return true; } if (loop.kind !== "for" && loop.kind !== "while" && loop.kind !== "doWhile") return true; - if ( - !effects.preservesScope(loop.body) || - (loop.cond && !effects.preserves(loop.cond)) || - (loop.kind === "for" && loop.update && !effects.preservesScope([loop.update])) - ) - return true; + const preserving = + effects.preservesScope(loop.body) && + (!loop.cond || effects.preserves(loop.cond)) && + (loop.kind !== "for" || !loop.update || effects.preservesScope([loop.update])); + const loopWrites = + preserving || !writes + ? null + : writes.union([ + writes.stmts(loop.body), + loop.cond ? writes.expr(loop.cond) : null, + loop.kind === "for" && loop.update ? writes.stmt(loop.update) : null, + ]); + if (!preserving && !writes) return true; everyStmtList(loop.body, { expr: () => true, stmt: (stmt) => { @@ -71,7 +84,12 @@ export function findLoopArrayBorrows( return true; const source = stmt.init.kind === "arrayGet" ? stmt.init.arr : optionalReads?.get(stmt.init)?.array; - if (source && stableSource(source)) result.add(stmt); + if (!source || !stableSource(source)) return true; + if (preserving) result.add(stmt); + else { + const keys = writes!.readKeys(source); + if (keys && !writes!.conflicts(["a", ...keys], loopWrites)) result.add(stmt); + } return true; }, }); diff --git a/packages/compiler/src/backend/llvm/map-number-lookup.ts b/packages/compiler/src/backend/llvm/map-number-lookup.ts index af0b91bed..552770852 100644 --- a/packages/compiler/src/backend/llvm/map-number-lookup.ts +++ b/packages/compiler/src/backend/llvm/map-number-lookup.ts @@ -7,6 +7,9 @@ * scr_map_entry_f64 otherwise. The generated code then reads the entry's * value slot itself and retains a reference value with the value type's own * retain, which is the adapter the collection was constructed with. + * String-keyed reference reads use the same entry contract through + * scr_map_entry_str, so their retain is inline rather than the runtime's + * indirect adapter call. */ import type { IrType } from "../../ir/ir.js"; import type { LlvmEmitterContext } from "./expr-context.js"; @@ -31,6 +34,16 @@ export function emitNumberMapSlot(host: LlvmEmitterContext, entry: string, type: return value; } +export const STRING_MAP_ENTRY_DECL = "declare ptr @scr_map_entry_str(ptr, ptr)"; + +/** The entry for a string `key`, or null when absent. Valid until the next mutation. */ +export function emitStringMapEntry(host: LlvmEmitterContext, map: string, key: string): string { + host.declare(STRING_MAP_ENTRY_DECL); + const entry = host.B.tmp(); + host.B.line(`${entry} = call ptr @scr_map_entry_str(ptr ${map}, ptr ${key})`); + return entry; +} + /** Map.get of a reference value: a +1 value, or null when absent — the * contract of scr_map_get_f64_ref. */ export function emitNumberMapGetRef( @@ -39,8 +52,24 @@ export function emitNumberMapGetRef( key: string, value: IrType, ): string { + return emitMapEntryGetRef(host, emitNumberMapEntry(host, map, key), value); +} + +/** Map.get of a reference value under a string key, with scr_map_get_str_ref's + * contract. The value type's own retain replaces the collection's adapter, so + * the retain is inline instead of an indirect call in the runtime. */ +export function emitStringMapGetRef( + host: LlvmEmitterContext, + map: string, + key: string, + value: IrType, +): string { + return emitMapEntryGetRef(host, emitStringMapEntry(host, map, key), value); +} + +/** The +1 value of a found entry, or null for a missing (null) entry. */ +function emitMapEntryGetRef(host: LlvmEmitterContext, entry: string, value: IrType): string { const B = host.B; - const entry = emitNumberMapEntry(host, map, key); const found = B.tmp(); B.line(`${found} = icmp ne ptr ${entry}, null`); const hit = B.newLabel("mapn.hit"), diff --git a/packages/compiler/src/backend/llvm/map-read-lifetimes.test.ts b/packages/compiler/src/backend/llvm/map-read-lifetimes.test.ts index cd1fdf455..3d75432ec 100644 --- a/packages/compiler/src/backend/llvm/map-read-lifetimes.test.ts +++ b/packages/compiler/src/backend/llvm/map-read-lifetimes.test.ts @@ -111,6 +111,11 @@ test("local map results keep scalar and owned reference payloads without heap wr expect(ir).toContain("call ptr @sc_map_entry_f64("); expect(ir).not.toContain("@scr_map_get_"); } else if (value === BOOL) expect(ir).toMatch(/zext i8 %\w+ to i64/); + else if (value === STRING) { + // String keys read reference values through the entry and retain inline. + expect(ir).toContain("call ptr @scr_map_entry_str("); + expect(ir).not.toContain("@scr_map_get_str_ref"); + } if (value === STRING) expect(ir).toContain("@scr_str_release"); } } diff --git a/packages/compiler/src/backend/llvm/map-read-lifetimes.ts b/packages/compiler/src/backend/llvm/map-read-lifetimes.ts index 27a2fd195..7de971af7 100644 --- a/packages/compiler/src/backend/llvm/map-read-lifetimes.ts +++ b/packages/compiler/src/backend/llvm/map-read-lifetimes.ts @@ -9,7 +9,11 @@ import { import { everyStmtList } from "../../ir/traverse.js"; import type { CallLifetimes } from "./call-lifetimes.js"; import type { LlValue, LlvmEmitterContext } from "./expr-context.js"; -import { emitNumberMapGetRef, emitNumberMapGetScalar } from "./map-number-lookup.js"; +import { + emitNumberMapGetRef, + emitNumberMapGetScalar, + emitStringMapGetRef, +} from "./map-number-lookup.js"; import { mapKeyAccess, mapKeyParamType } from "./shapes.js"; function hasTypedCollectionReceiver( @@ -167,6 +171,11 @@ export function inlineNumberKey(key: { access: string; value?: string }): string return key.access === "f64" && key.value !== undefined ? key.value : null; } +/** The key's string operand when a reference read can take the entry path. */ +export function entryStringKey(key: { access: string; value?: string }): string | null { + return key.access === "str" && key.value !== undefined ? key.value : null; +} + export interface StackMapRead { value: LlValue; owner: { slot: string; type: IrType } | null; @@ -205,9 +214,14 @@ export function emitStackMapRead(host: LlvmEmitterContext, read: LocalMapRead): B.line(`store i64 ${scalar.bits}, ptr ${payload}`); } } else if (isRefCounted(read.value)) { - const raw = B.tmp(); - host.declare(`declare ptr @scr_map_get_${access}_ref(ptr, ${keyType})`); - B.line(`${raw} = call ptr @scr_map_get_${access}_ref(ptr ${receiver.name}, ${key.args})`); + const stringKey = entryStringKey(key); + let raw: string; + if (stringKey !== null) raw = emitStringMapGetRef(host, receiver.name, stringKey, read.value); + else { + raw = B.tmp(); + host.declare(`declare ptr @scr_map_get_${access}_ref(ptr, ${keyType})`); + B.line(`${raw} = call ptr @scr_map_get_${access}_ref(ptr ${receiver.name}, ${key.args})`); + } B.line(`${found} = icmp ne ptr ${raw}, null`); B.line(`store i64 0, ptr ${payload}`); B.line(`store ptr ${raw}, ptr ${payload}`); diff --git a/packages/compiler/src/backend/llvm/reference-writes.ts b/packages/compiler/src/backend/llvm/reference-writes.ts new file mode 100644 index 000000000..fac6fd35c --- /dev/null +++ b/packages/compiler/src/backend/llvm/reference-writes.ts @@ -0,0 +1,1095 @@ +import { + isRefCounted, + type IrClassDef, + type IrExpr, + type IrFunction, + type IrRecordShape, + type IrStmt, + type IrType, + type IrUnionDef, +} from "../../ir/ir.js"; +import { everyExprChild, everyStmtChild } from "../../ir/traverse.js"; +import { borrowsMapMutationReceiver, borrowsMapReadInputs } from "./map-read-lifetimes.js"; +import { preservesRegexInputs, VirtualTargets } from "./reference-effects.js"; +import { borrowsStringInputs } from "./string-lifetimes.js"; +import { preservesDynTest } from "./checked-value-lifetimes.js"; +import { isStableReceiverOperand } from "../../ir/analysis.js"; +import type { ImmutableFields } from "../immutability.js"; + +type Call = IrExpr & { kind: "call" }; + +/** A set of reference locations, as a bitset over the interned keys; `null` + * is the empty set. Key 0 (`*`) is an unknown heap write: it covers every + * heap location but no local of the current function. */ +export type Writes = Uint32Array | null; + +/** Every heap location (key 0). */ +const HEAP_KEY = "*"; + +/** Array element slots of every reference array share one location: arrays + * are covariant, so element types do not separate them. */ +const ARRAY_KEY = "a"; +/** Entries of typed maps and sets. */ +const MAP_KEY = "m"; +/** Captured-binding boxes. */ +const BOX_KEY = "bx"; +/** Record fields written through a computed key. */ +const ANY_RECORD_KEY = "r:*"; + +/** The pseudo-function standing for every indirect call target. */ +const ANY_FUNCTION = "%anyFunctionValue"; + +/** Value-producing kinds that only move an existing function value. */ +const FUNCTION_MOVES = new Set([ + "closure", + "selfRef", + "varRef", + "fieldGet", + "recordGet", + "arrayGet", + "call", + "virtualCall", + "callValue", + "ternary", + "logical", + "nullish", + "orDefault", + "unionNarrow", + "seqExpr", + "assignExpr", + "optChain", + "chainRecv", + "upcast", + "downcast", + "mapIntrinsic", + "setIntrinsic", + "arrIntrinsic", + "recordKeyGet", + "unionKeyGet", +]); + +/** Runtime library families that run no user code and never write a + * program reference (scalars, strings, byte buffers, files, clocks). */ +const INERT_LIB_PREFIXES = [ + "math.", + "num.", + "number.", + "string.", + "str.", + "bigint.", + "buffer.", + "arrayBuffer.", + "sharedArrayBuffer.", + "atomics.", + "perf.", + "date.", + "text.", + "path.", + "fs.", + "stats.", + "spawnRes.", +]; +const INERT_LIB_CALLS = new Set([ + "dyn.compare", + "error.new", + "error.nodeThrow", + "dyn.typedRefIs", + "dyn.bagGet", + "json.parse", + "process.stderrWrite", + "process.stdoutWrite", + "process.envGet", + "process.envPairs", + "process.cwd", + "process.argv", + "process.platform", + "process.execPath", + "process.isTTY", + "worker.data", + "worker.isMainThread", + "worker.parentPort", + "worker.root", + "cp.spawnSyncOpts", +]); + +/** Array methods that never release an existing element or run user code. */ +const PRESERVING_ARRAY_METHODS = new Set([ + "length", + "getNumber", + "indexEq", + "push", + "pushSpread", + "concatSpread", + "unshift", + "unshiftSpread", + "indexOf", + "includes", + "nextPresent", + "join", + "slice", + "flatCopy", + "flatOne", + "toReversed", + "toSpliced", + "with", + "withUndefined", + "toSortedPrimitive", + // Permutes primitive payloads in place: every element keeps its owner. + "sortPrimitive", +]); + +/** Which heap reference locations evaluating code may overwrite or remove. + * + * ReferenceEffects answers one bit (does anything remove any edge?). This + * analysis keeps the location, so a borrow that reads `x.f` only conflicts + * with code that can write field `f` of x's hierarchy (or array elements, + * map entries, a global or a captured box, for those reads), not with + * every reference store. Locations: + * + * - `f:.` class fields (all classes of a hierarchy + * that name the field share it, so redeclarations alias); + * - `r:` record fields, plus `r:*` for computed-key writes and + * deletions (every record read also depends on `r:*`); + * - `a` reference array elements, `m` map/set entries, `bx` boxes; + * - `g:` module globals, `l:` the current function's own locals + * (dropped from summaries: a callee cannot rebind its caller's locals); + * - ALL for anything unknown: dynamic code, callbacks, suspension, unknown + * runtime operations. + * + * Stores a constructor makes into its own `this` write a fresh object that + * no borrow outside the construction can reach, so `new` (and `super` + * calls from constructors) use a constructor summary without them, as long + * as constructors are invoked only through `new` and `super`. + * + * Facts belong to one finalized module and one emission. */ +export class ReferenceWrites { + private readonly keys = new Map(); + private readonly roots = new Map(); + private readonly fieldOwners = new Map(); + private readonly classes = new Map(); + private readonly virtualTargets: VirtualTargets; + private readonly summaries = new Map(); + private readonly exprCache = new Map(); + private readonly stmtCache = new Map(); + private words = 0; + /** The unknown heap write alone. */ + heapAll: Uint32Array = new Uint32Array(1).fill(1); + /** Constructors only ever run on fresh objects. */ + private readonly freshConstructors: boolean; + private readonly unions: ReadonlyMap; + private readonly records: ReadonlyMap; + private readonly inertJson = new Map(); + /** Closure bodies an indirect call can reach. */ + private readonly functionValues = new Set(); + private callTargets!: CallTargets; + /** Some function value comes from outside the module's closures. */ + private foreignFunctionValues = false; + private current: IrFunction | null = null; + private currentBoxed = new Set(); + private currentLocals = new Set(); + private constructors: ReadonlySet = new Set(); + private inConstructor = false; + + constructor( + private readonly functions: ReadonlyMap, + classes: readonly IrClassDef[], + private readonly intrinsicCall: (call: Call) => boolean, + private readonly globals: ReadonlySet, + types: { + unions?: readonly IrUnionDef[] | undefined; + records?: readonly IrRecordShape[] | undefined; + } = {}, + /** Fields no code writes once their object is constructed + * (immutability.ts, from cycle-mutability's construction-only facts). */ + private readonly immutable: ImmutableFields | null = null, + ) { + this.key(HEAP_KEY); + this.unions = new Map((types.unions ?? []).map((u) => [u.id, u])); + this.records = new Map((types.records ?? []).map((r) => [r.id, r])); + for (const cls of classes) this.classes.set(cls.name, cls); + this.virtualTargets = new VirtualTargets(classes); + const constructors = new Set(classes.map((cls) => `%${cls.name}.constructor`)); + this.constructors = constructors; + this.freshConstructors = [...functions.values()].every((fn) => + fn.body.every((s) => this.onlySuperCalls(fn, s, constructors)), + ); + this.callTargets = new CallTargets(functions, this.virtualTargets); + this.solve(constructors); + } + + /** Every direct call of a constructor is a `super` call from a + * constructor on its own `this`. */ + private onlySuperCalls(fn: IrFunction, s: IrStmt, constructors: ReadonlySet): boolean { + const thisId = constructors.has(fn.name) ? fn.params[0]?.localId : undefined; + const expr = (e: IrExpr): boolean => { + if (e.kind === "call" && constructors.has(e.callee)) { + const self = e.args[0]; + if (thisId === undefined || !self || !isThisRef(self, thisId)) return false; + } + return everyExprChild(e, expr, stmt); + }; + const stmt = (node: IrStmt): boolean => everyStmtChild(node, expr, stmt); + return stmt(s); + } + + private key(k: string): number { + let id = this.keys.get(k); + if (id === undefined) { + id = this.keys.size; + this.keys.set(k, id); + } + return id; + } + + /** The hierarchy root of a class (runtime bases included). */ + private root(className: string): string { + let r = this.roots.get(className); + if (r !== undefined) return r; + r = className; + for (let cls = this.classes.get(className); cls?.base !== undefined;) { + r = cls.base; + cls = this.classes.get(cls.base); + } + this.roots.set(className, r); + return r; + } + + fieldKey(className: string, field: string): string { + return `f:${this.root(className)}.${field}`; + } + + // ── phase 1: per-function local writes and call edges ───────────────── + + private solve(constructors: ReadonlySet): void { + interface Node { + local: Set; + edges: Set; + } + const nodes = new Map(); + const scan = (fn: IrFunction, external: boolean): Node => { + const node: Node = { local: new Set(), edges: new Set() }; + if (fn.async || fn.generator) { + node.local.add(0); + return node; + } + const thisId = external && constructors.has(fn.name) ? (fn.params[0]?.localId ?? null) : null; + const boxed = boxedLocals(fn); + const sink: WriteSink = { + add: (k) => { + // Interned for queries; a callee's locals are private to it. + const id = this.key(k); + if (!k.startsWith("l:")) node.local.add(id); + }, + all: () => node.local.add(0), + call: (callee, fresh) => { + if (callee === ANY_FUNCTION) { + node.edges.add(ANY_FUNCTION); + return true; + } + if (!this.functions.has(callee)) return false; + node.edges.add( + fresh && this.freshConstructors && constructors.has(callee) ? `${callee}#ext` : callee, + ); + return true; + }, + }; + const expr = (e: IrExpr): boolean => { + this.nodeWrites(e, sink, boxed, fn, constructors); + if (e.kind === "closure") this.functionValues.add(e.fnName); + else if ( + e.type?.kind === "func" && + !FUNCTION_MOVES.has(e.kind) && + !(e.kind === "libCall" && e.fn === "error.nodeThrow") + ) + this.foreignFunctionValues = true; + return everyExprChild(e, expr, stmt); + }; + const stmt = (s: IrStmt): boolean => { + if (thisId !== null && s.kind === "fieldSet" && isThisRef(s.obj, thisId)) { + // A store into the fresh `this`: no outside borrow can reach it. + } else this.stmtWrites(s, sink, boxed); + return everyStmtChild(s, expr, stmt); + }; + fn.body.every(stmt); + return node; + }; + for (const fn of this.functions.values()) { + nodes.set(fn.name, scan(fn, false)); + if (this.freshConstructors && constructors.has(fn.name)) + nodes.set(`${fn.name}#ext`, scan(fn, true)); + } + // Indirect calls reach any closure body; values made elsewhere + // (dynamic conversions) reach unknown code. + nodes.set(ANY_FUNCTION, { + local: new Set(this.foreignFunctionValues ? [0] : []), + edges: new Set([...this.functionValues].filter((name) => this.functions.has(name))), + }); + this.words = (this.keys.size + 31) >>> 5; + this.heapAll = new Uint32Array(this.words); + this.heapAll[0] = 1; + // Tarjan's SCCs, iteratively; components come out callees first. + const index = new Map(); + const low = new Map(); + const onStack = new Set(); + const stack: string[] = []; + let counter = 0; + for (const start of nodes.keys()) { + if (index.has(start)) continue; + const work: { name: string; edges: Iterator }[] = []; + const enter = (name: string): void => { + index.set(name, counter); + low.set(name, counter++); + stack.push(name); + onStack.add(name); + work.push({ name, edges: nodes.get(name)!.edges.values() }); + }; + enter(start); + while (work.length > 0) { + const top = work[work.length - 1]!; + const next = top.edges.next(); + if (!next.done) { + const callee = next.value; + if (!nodes.has(callee)) continue; + if (!index.has(callee)) enter(callee); + else if (onStack.has(callee)) + low.set(top.name, Math.min(low.get(top.name)!, index.get(callee)!)); + continue; + } + work.pop(); + if (work.length > 0) { + const parent = work[work.length - 1]!.name; + low.set(parent, Math.min(low.get(parent)!, low.get(top.name)!)); + } + if (low.get(top.name) !== index.get(top.name)) continue; + const members: string[] = []; + for (;;) { + const m = stack.pop()!; + onStack.delete(m); + members.push(m); + if (m === top.name) break; + } + const bits = new Uint32Array(this.words); + const inComponent = new Set(members); + for (const m of members) { + const node = nodes.get(m)!; + for (const id of node.local) setBit(bits, id); + for (const callee of node.edges) { + if (inComponent.has(callee)) continue; + const s = this.summaries.get(callee); + if (s === undefined || s === null) continue; + orInto(bits, s); + } + } + // An unknown heap write subsumes the precise heap keys. + const summary: Writes = (bits[0]! & 1) !== 0 ? this.heapAll : anyBit(bits) ? bits : null; + for (const m of members) this.summaries.set(m, summary); + } + } + } + + /** Writes of one expression node itself (children are separate). */ + private nodeWrites( + e: IrExpr, + sink: WriteSink, + boxed: ReadonlySet, + fn: IrFunction | null, + constructors: ReadonlySet, + ): void { + switch (e.kind) { + case "call": { + const fresh = + fn !== null && + constructors.has(e.callee) && + constructors.has(fn.name) && + e.args[0] !== undefined && + isThisRef(e.args[0], fn.params[0]?.localId ?? ""); + if (!sink.call(e.callee, fresh) && !this.intrinsicCall(e)) sink.all(); + return; + } + case "new": + if (!sink.call(`%${e.className}.constructor`, true)) sink.all(); + return; + case "virtualCall": { + const targets = this.virtualTargets.targets(e.className, e.method); + if (targets === null) sink.all(); + else for (const t of targets) if (!sink.call(t, false)) sink.all(); + return; + } + case "assignExpr": + case "incDec": + if (isRefCounted(e.type)) sink.add(this.localKey(e.localId, boxed)); + return; + case "callValue": { + const targets = fn !== null ? this.callTargets.of(e.callee, fn) : null; + if (targets === null) { + if (!sink.call(ANY_FUNCTION, false)) sink.all(); + } else for (const t of targets) if (!sink.call(t, false)) sink.all(); + return; + } + case "arrIntrinsic": + if (!PRESERVING_ARRAY_METHODS.has(e.method)) { + // The comparator sort orders a private snapshot. + if (e.method === "sortValues") { + const comparator = e.args[1]; + const targets = + fn !== null && comparator !== undefined ? this.callTargets.of(comparator, fn) : null; + if (targets === null) { + if (!sink.call(ANY_FUNCTION, false)) sink.all(); + } else for (const t of targets) if (!sink.call(t, false)) sink.all(); + } + sink.add(ARRAY_KEY); + } + return; + case "mapIntrinsic": + case "setIntrinsic": + if (borrowsMapReadInputs(e)) return; + if (borrowsMapMutationReceiver(e)) sink.add(MAP_KEY); + else if (e.receiver.type.kind === "map" || e.receiver.type.kind === "set") { + // Typed collections: copies and iteration bookkeeping run no + // user code; leaving an iteration may compact removed entries. + if (e.method === "iterEnter" || e.method === "iterExit") sink.add(MAP_KEY); + else if ( + e.method !== "clone" && + e.method !== "keySet" && + e.method !== "valueSet" && + e.method !== "toArray" + ) + sink.all(); + } else sink.all(); + return; + case "intrinsic": + // A TDZ test reads; publication only makes objects immortal. + if (e.name !== "module.tdzCheck" && e.name !== "threads.publish") sink.all(); + return; + case "dynFrom": + case "dynArrLit": + case "dynObjLit": + return; + case "dynCheck": + // Identity and kind tests of class and primitive targets. + if (!this.checkedWithoutCode(e.type)) sink.all(); + return; + case "jsonStringify": + if (!this.jsonInert(e.value.type)) sink.all(); + return; + case "bytesNew": + case "bytesIntrinsic": + return; + case "strIntrinsic": + if (!borrowsStringInputs(e.method)) sink.all(); + return; + case "regexIntrinsic": + if (!preservesRegexInputs(e.method)) sink.all(); + return; + case "libCall": + if (!this.inertLibCall(e)) sink.all(); + return; + case "toString": + if (!this.primitive(e.operand.type)) sink.all(); + return; + case "dynTest": + if (!preservesDynTest(e.test)) sink.all(); + return; + // Reads, tests, arithmetic and fresh allocations. + case "numLit": + case "boolLit": + case "strLit": + case "unitLit": + case "varRef": + case "bin": + case "unary": + case "toBool": + case "logical": + case "nullish": + case "ternary": + case "seqExpr": + case "fieldGet": + case "recordGet": + case "unionNarrow": + case "unionIsTag": + case "unionWrap": + case "downcast": + case "upcast": + case "instanceOf": + case "strConcat": + case "strEq": + case "strCmp": + case "arrayGet": + case "arrayHas": + case "arrayState": + case "unionEq": + case "unionFuncEq": + case "dynScalarEq": + case "caughtTest": + case "caughtNarrow": + case "caughtCheck": + case "classRef": + case "recordLit": + case "arrayLit": + case "arrayNewLen": + case "closure": + case "mapNew": + case "setNew": + case "regexLit": + case "recordHas": + case "recordKeyGet": + case "recordOvfHas": + case "recordOvfKeys": + case "fieldAbsent": + case "unionDisc": + case "unionKeyGet": + case "fieldIncDec": + case "optChain": + case "chainRecv": + case "orDefault": + case "instanceOfValue": + case "promiseVoidWiden": + return; + default: + sink.all(); + } + } + + /** Writes of one statement node itself. */ + private stmtWrites(s: IrStmt, sink: WriteSink, boxed: ReadonlySet): void { + switch (s.kind) { + case "assign": + if (isRefCounted(s.value.type)) sink.add(this.localKey(s.localId, boxed)); + return; + case "fieldSet": + if (isRefCounted(s.value.type)) sink.add(this.fieldKey(s.className, s.field)); + return; + case "recordSet": + if (isRefCounted(s.value.type)) sink.add(`r:${s.field}`); + return; + case "recordKeySet": + case "recordKeyDelete": + sink.add(ANY_RECORD_KEY); + return; + case "arraySet": + case "arraySetUndefined": + case "arrayDelete": + case "arraySetLength": + sink.add(ARRAY_KEY); + return; + case "varDecl": + case "exprStmt": + case "return": + case "throw": + case "runtimeFence": + case "if": + case "for": + case "forOf": + case "while": + case "doWhile": + case "block": + case "switch": + case "break": + case "continue": + case "bytesSet": + case "tryCatch": + case "rethrow": + return; + default: + sink.all(); + } + } + + /** Library calls that run no user code: inert families without callback + * arguments, and an Error options bag that is a typed record (no + * accessors) or absent. */ + private inertLibCall(e: IrExpr & { kind: "libCall" }): boolean { + if (e.fn === "error.nodeThrow" || isStableReceiverOperand(e, "")) return true; + if (e.fn === "error.newOptions") + return e.args.every( + (arg) => + arg.type.kind !== "dyn" || + (arg.kind === "dynFrom" && + (arg.value.type.kind === "record" || this.primitive(arg.value.type))), + ); + if (!INERT_LIB_CALLS.has(e.fn) && !INERT_LIB_PREFIXES.some((p) => e.fn.startsWith(p))) + return false; + return e.args.every( + (arg) => + arg.type.kind !== "func" && + (arg.type.kind !== "dyn" || + (e.fn !== "dyn.compare" && e.fn.startsWith("dyn.")) || + // A wrapped primitive has no methods to call back into. + (arg.kind === "dynFrom" && this.primitive(arg.value.type))), + ); + } + + /** Numbers, booleans, strings and unit values (and unions of them). */ + private primitive(t: IrType): boolean { + switch (t.kind) { + case "f64": + case "bool": + case "string": + case "undefinedT": + case "nullT": + return true; + case "union": + return this.unions.get(t.unionId)?.arms.every((arm) => this.primitive(arm)) ?? false; + default: + return false; + } + } + + /** A dynamic-to-typed check that only tests identity or kind. */ + private checkedWithoutCode(t: IrType): boolean { + if (t.kind === "object" || this.primitive(t)) return true; + if (t.kind !== "union") return false; + return ( + this.unions + .get(t.unionId) + ?.arms.every((arm) => arm.kind === "object" || this.primitive(arm)) ?? false + ); + } + + /** JSON.stringify of this type calls no toJSON or accessor: primitives + * and records/arrays/unions of them (class instances may define both). */ + private jsonInert(t: IrType): boolean { + if (this.primitive(t)) return true; + const key = JSON.stringify(t); + const known = this.inertJson.get(key); + if (known !== undefined) return known; + this.inertJson.set(key, true); // recursive shapes: assume, then confirm + let result: boolean; + if (t.kind === "array") result = this.jsonInert(t.elem); + else if (t.kind === "record") + result = this.records.get(t.shapeId)?.fields.every((f) => this.jsonInert(f.type)) ?? false; + else if (t.kind === "union") + result = this.unions.get(t.unionId)?.arms.every((arm) => this.jsonInert(arm)) ?? false; + else result = false; + this.inertJson.set(key, result); + return result; + } + + private localKey(id: string, boxed: ReadonlySet, locals?: ReadonlySet): string { + if (this.globals.has(id)) return `g:${id}`; + // A binding of another function (never expected) counts as a box. + if (boxed.has(id) || (locals !== undefined && !locals.has(id))) return BOX_KEY; + return `l:${id}`; + } + + // ── queries ──────────────────────────────────────────────────────────── + + /** Start answering expression queries for one function body. */ + enter(fn: IrFunction): void { + this.current = fn; + this.currentBoxed = boxedLocals(fn); + this.currentLocals = new Set(fn.locals.map((local) => local.id)); + this.inConstructor = this.constructors.has(fn.name); + for (const p of fn.params) this.currentLocals.add(p.localId); + this.exprCache.clear(); + this.stmtCache.clear(); + } + + private readonly bodyWrites = new Map(); + + /** Whether a walk of `fn` reads only locations its whole body never + * writes; the candidate walk locals' own rebinding is exempt. */ + unwrittenWalk( + fn: IrFunction, + value: IrExpr, + candidates: ReadonlySet, + call: (e: Call) => readonly string[] | null, + ): boolean { + if (this.current !== fn) this.enter(fn); + const keys = this.readKeys(value, call); + if (keys === null) return false; + let body = this.bodyWrites.get(fn.name); + if (body === undefined) { + body = this.stmts(fn.body); + this.bodyWrites.set(fn.name, body); + } + return !this.conflicts( + keys.filter((k) => !(k.startsWith("l:") && candidates.has(k.slice(2)))), + body, + ); + } + + /** The transitive writes of a call to a module function (`#ext` for a + * constructor reached through `new`). */ + summary(name: string): Writes { + const known = this.summaries.get(name); + return known === undefined ? this.heapAll : known; + } + + constructWrites(className: string): Writes { + const ctor = `%${className}.constructor`; + if (!this.functions.has(ctor)) return this.heapAll; + return this.summary(this.freshConstructors ? `${ctor}#ext` : ctor); + } + + virtualWrites(className: string, method: string): Writes { + const targets = this.virtualTargets.targets(className, method); + if (targets === null) return this.heapAll; + return this.union(targets.map((t) => this.summary(t))); + } + + /** Writes of evaluating an expression, with its operands. */ + expr(e: IrExpr): Writes { + const known = this.exprCache.get(e); + if (known !== undefined) return known; + const parts: Writes[] = []; + const sink = this.querySink(parts); + this.nodeWrites(e, sink, this.currentBoxed, this.current, new Set()); + everyExprChild( + e, + (child) => (parts.push(this.expr(child)), true), + (child) => (parts.push(this.stmt(child)), true), + ); + const result = this.union(parts); + this.exprCache.set(e, result); + return result; + } + + stmt(s: IrStmt): Writes { + const known = this.stmtCache.get(s); + if (known !== undefined) return known; + const parts: Writes[] = []; + this.stmtWrites(s, this.querySink(parts), this.currentBoxed); + everyStmtChild( + s, + (child) => (parts.push(this.expr(child)), true), + (child) => (parts.push(this.stmt(child)), true), + ); + const result = this.union(parts); + this.stmtCache.set(s, result); + return result; + } + + stmts(list: readonly IrStmt[]): Writes { + return this.union(list.map((s) => this.stmt(s))); + } + + private querySink(parts: Writes[]): WriteSink { + return { + add: (k) => parts.push(this.bitsOf([k])), + all: () => parts.push(this.heapAll), + call: (callee, fresh) => { + if (callee === ANY_FUNCTION) { + parts.push(this.summary(ANY_FUNCTION)); + return true; + } + if (!this.functions.has(callee)) return false; + const ctor = fresh && callee.endsWith(".constructor") && this.freshConstructors; + parts.push(this.summary(ctor ? `${callee}#ext` : callee)); + return true; + }, + }; + } + + union(parts: readonly Writes[]): Writes { + let out: Uint32Array | null = null; + for (const p of parts) { + if (p === null) continue; + if (out === null) out = new Uint32Array(this.words); + orInto(out, p); + } + return out; + } + + /** A bitset over known keys; keys nothing writes are dropped. */ + bitsOf(keys: readonly string[]): Writes { + let out: Uint32Array | null = null; + for (const k of keys) { + const id = this.keys.get(k); + if (id === undefined || id >= this.words * 32) continue; + if (out === null) out = new Uint32Array(this.words); + setBit(out, id); + } + return out; + } + + /** Whether writes may touch any of the read keys. */ + conflicts(reads: readonly string[], writes: Writes): boolean { + if (writes === null) return false; + const heap = (writes[0]! & 1) !== 0; + for (const k of reads) { + if (heap && !k.startsWith("l:")) return true; + const id = this.keys.get(k); + if (id === undefined || id >= this.words * 32) continue; + if ((writes[id >>> 5]! & (1 << (id & 31))) !== 0) return true; + } + return false; + } + + /** The locations whose writes could release the object a borrowed read + * of `e` yields, or null when `e` is not such a projection. `call` + * resolves borrowed-return callees to the locations their walks read. */ + readKeys(e: IrExpr, call?: (e: Call) => readonly string[] | null): string[] | null { + const out: string[] = []; + const walk = (node: IrExpr): boolean => { + switch (node.kind) { + case "varRef": + out.push(this.localKey(node.localId, this.currentBoxed, this.currentLocals)); + return true; + case "fieldGet": + // A construction-only field of an existing object never changes; + // only a constructor can still be writing it (its own `this`). + if (this.inConstructor || !this.immutable?.classField(node.className, node.field)) + out.push(this.fieldKey(node.className, node.field)); + return walk(node.obj); + case "recordGet": + if (this.inConstructor || !this.immutable?.recordField(node.shapeId, node.field)) + out.push(`r:${node.field}`, ANY_RECORD_KEY); + return walk(node.obj); + case "arrayGet": + out.push(ARRAY_KEY); + return this.expr(node.index) === null && walk(node.arr); + case "unionNarrow": + case "upcast": + case "downcast": + return walk(node.value); + case "unionWrap": + return node.value.kind === "unitLit" || walk(node.value); + case "ternary": + return this.expr(node.cond) === null && armWalk(node.then) && armWalk(node.else_); + case "seqExpr": { + // Guarded projections: `(check, value)` where the checks only + // read and throw. + if (this.stmts(node.stmts) !== null) return false; + return walk(node.result); + } + case "strLit": + return true; + case "call": { + const keys = call?.(node) ?? null; + if (keys === null) return false; + out.push(...keys); + return node.args.every((arg) => !isRefCounted(arg.type) || walk(arg)); + } + default: + return false; + } + }; + const armWalk = (node: IrExpr): boolean => + (node.kind === "libCall" && node.fn === "error.nodeThrow") || walk(node); + return walk(e) ? out : null; + } +} + +interface WriteSink { + add(key: string): void; + all(): void; + /** False when the callee is not a module function. */ + call(callee: string, fresh: boolean): boolean; +} + +function isThisRef(e: IrExpr, thisId: string): boolean { + if (e.kind === "varRef") return e.localId === thisId; + if (e.kind === "upcast") return isThisRef(e.value, thisId); + return false; +} + +/** Locals living in boxes: declared boxed or captured from an enclosing + * function. */ +function boxedLocals(fn: IrFunction): Set { + const out = new Set(); + for (const local of fn.locals) if (local.boxed) out.add(local.id); + for (const c of fn.captures ?? []) out.add(c.localId); + for (const c of fn.classCaptures ?? []) out.add(c.localId); + return out; +} + +/** The closure bodies a function value can be, when it flows only from + * closure expressions through stable locals and the function-typed + * parameters of functions that are only called directly (null: any + * function value). A small flow analysis over parameter positions: each + * position collects the targets every direct, virtual and `new` call site + * passes, to a fixpoint. */ +class CallTargets { + private readonly sites = new Map(); + private readonly opaque = new Set(); + private readonly params = new Map | null>(); + private readonly definitions = new Map>(); + /** Functions creating each closure body. */ + private readonly creators = new Map(); + + constructor( + private readonly functions: ReadonlyMap, + virtualTargets: VirtualTargets, + ) { + const site = (callee: string, caller: IrFunction, args: readonly IrExpr[]): void => { + let list = this.sites.get(callee); + if (!list) this.sites.set(callee, (list = [])); + list.push({ caller, args }); + }; + for (const fn of functions.values()) { + if (fn.captures !== undefined || fn.classCaptures !== undefined) this.opaque.add(fn.name); + const expr = (e: IrExpr): boolean => { + if (e.kind === "call") site(e.callee, fn, e.args); + else if (e.kind === "new") site(`%${e.className}.constructor`, fn, [e, ...e.args]); + else if (e.kind === "virtualCall") { + const targets = virtualTargets.targets(e.className, e.method); + for (const t of targets ?? []) site(t, fn, e.args); + } else if (e.kind === "closure") { + this.opaque.add(e.fnName); + let list = this.creators.get(e.fnName); + if (!list) this.creators.set(e.fnName, (list = [])); + list.push(fn); + } + return everyExprChild(e, expr, stmt); + }; + const stmt = (st: IrStmt): boolean => everyStmtChild(st, expr, stmt); + fn.body.every(stmt); + } + // Fixpoint over function-typed parameter positions. + const positions: [IrFunction, number][] = []; + for (const fn of functions.values()) + fn.params.forEach((p, i) => { + if (p.type.kind === "func") { + positions.push([fn, i]); + this.params.set(`${fn.name}#${i}`, new Set()); + } + }); + for (let changed = true; changed;) { + changed = false; + for (const [fn, i] of positions) { + const key = `${fn.name}#${i}`; + const known = this.params.get(key); + if (known === null) continue; + const sites = this.sites.get(fn.name); + let next: Set | null = new Set(known!); + if (this.opaque.has(fn.name) || !sites || this.assigned(fn, fn.params[i]!.localId)) + next = null; + else + for (const { caller, args } of sites) { + const arg = args[i]; + const t = arg === undefined ? null : this.resolve(arg, caller, 0); + if (t === null) { + next = null; + break; + } + for (const name of t) next.add(name); + } + if (next === null || next.size !== known!.size) { + this.params.set(key, next); + changed = true; + } + } + } + } + + of(callee: IrExpr, fn: IrFunction): readonly string[] | null { + const t = this.resolve(callee, fn, 0); + return t === null ? null : [...t]; + } + + private resolve(e: IrExpr, fn: IrFunction, depth: number): ReadonlySet | null { + if (depth > 8) return null; + switch (e.kind) { + case "closure": + return new Set([e.fnName]); + case "ternary": + case "logical": + case "nullish": + case "orDefault": { + const arms = e.kind === "ternary" ? [e.then, e.else_] : [e.left, e.right]; + const out = new Set(); + for (const arm of arms) { + if (arm.type.kind !== "func") { + if (arm.kind === "libCall" && arm.fn === "error.nodeThrow") continue; + if (e.kind === "ternary") return null; + continue; // the tested operand of `a ?? f`, `a || f` + } + const t = this.resolve(arm, fn, depth + 1); + if (t === null) return null; + for (const name of t) out.add(name); + } + return out; + } + case "varRef": { + if ((fn.captures ?? []).some((c) => c.localId === e.localId)) { + // A captured binding nothing rebinds holds what it held in every + // function creating this closure. + const creators = this.creators.get(fn.name); + if (!creators || this.assigned(fn, e.localId)) return null; + const out = new Set(); + for (const creator of creators) { + const t = this.resolve(e, creator, depth + 1); + if (t === null) return null; + for (const name of t) out.add(name); + } + return out; + } + const index = fn.params.findIndex((p) => p.localId === e.localId); + if (index >= 0) { + if (this.assigned(fn, e.localId)) return null; + return this.params.get(`${fn.name}#${index}`) ?? null; + } + const def = this.definition(fn, e.localId); + return def ? this.resolve(def, fn, depth + 1) : null; + } + case "call": { + // A function value returned by a module function: whatever every + // return yields (adapters return closures over their argument). + const callee = this.functions.get(e.callee); + if (!callee || callee.async || callee.generator) return null; + const out = new Set(); + let ok = true; + let any = false; + const stmt = (st: IrStmt): boolean => { + if (st.kind === "return") { + any = true; + const t = st.value ? this.resolve(st.value, callee, depth + 1) : null; + if (t === null) return (ok = false); + for (const name of t) out.add(name); + } + return everyStmtChild(st, () => true, stmt); + }; + callee.body.every(stmt); + return ok && any ? out : null; + } + default: + return null; + } + } + + /** The single initializer of a never-assigned, unboxed local. */ + private definition(fn: IrFunction, id: string): IrExpr | null { + let defs = this.definitions.get(fn); + if (!defs) { + defs = new Map(); + const boxed = new Set(fn.locals.filter((l) => l.boxed).map((l) => l.id)); + const counts = new Map(); + const expr = (e: IrExpr): boolean => { + if (e.kind === "assignExpr" || e.kind === "incDec") counts.set(e.localId, 2); + return everyExprChild(e, expr, stmt); + }; + const stmt = (st: IrStmt): boolean => { + if (st.kind === "varDecl") { + counts.set(st.localId, (counts.get(st.localId) ?? 0) + 1); + defs!.set(st.localId, st.init); + } else if (st.kind === "assign") counts.set(st.localId, 2); + return everyStmtChild(st, expr, stmt); + }; + fn.body.every(stmt); + for (const [local, n] of counts) if (n !== 1 || boxed.has(local)) defs.set(local, null); + this.definitions.set(fn, defs); + } + return defs.get(id) ?? null; + } + + private assigned(fn: IrFunction, id: string): boolean { + this.definition(fn, id); + const defs = this.definitions.get(fn)!; + return defs.has(id); + } +} + +function setBit(bits: Uint32Array, id: number): void { + const w = id >>> 5; + bits[w] = bits[w]! | (1 << (id & 31)); +} + +function orInto(bits: Uint32Array, other: Uint32Array): void { + for (let w = 0; w < bits.length; w++) bits[w] = bits[w]! | other[w]!; +} + +function anyBit(bits: Uint32Array): boolean { + for (let w = 0; w < bits.length; w++) if (bits[w] !== 0) return true; + return false; +} diff --git a/packages/compiler/src/backend/llvm/shapes.ts b/packages/compiler/src/backend/llvm/shapes.ts index 7f3e28d5d..2a3b983e7 100644 --- a/packages/compiler/src/backend/llvm/shapes.ts +++ b/packages/compiler/src/backend/llvm/shapes.ts @@ -27,7 +27,7 @@ import { mangleRecordTrace, } from "../mangle.js"; import { cycTypeDescriptor, emitObjectAlloc, emitObjectFree } from "./alloc.js"; -import { llvmCommentText } from "./common.js"; +import { SCR_ARR_FIELD, llvmCommentText } from "./common.js"; import type { NullableUnions } from "./nullable-unions.js"; import { LlvmUnsupportedError } from "./unsupported.js"; @@ -197,7 +197,7 @@ export function releaseSym(host: ShapeHost, t: IrType): string { /** How a runtime family decides whether an object carries a ScrCycHdr: * never, always, or per object through the trace slots its C release - * tests (`a->elem_trace`, `m->key_trace || m->val_trace`). */ + * tests (`a->cyc`, `m->key_trace || m->val_trace`). */ type RcCycle = "none" | "always" | "arr" | "map"; interface InlineRcFamily { @@ -318,9 +318,9 @@ export function inlineRcDecls(host: ShapeHost): string[] { function rcHeaderTest(cycle: "arr" | "map", yes: string, no: string): string[] { if (cycle === "arr") { return [ - ` %tracep = getelementptr inbounds %ScrArr, ptr %o, i32 0, i32 6 ; elem_trace`, - ` %trace = load ptr, ptr %tracep`, - ` %headered = icmp ne ptr %trace, null`, + ` %cycp = getelementptr inbounds %ScrArr, ptr %o, i32 0, i32 ${SCR_ARR_FIELD.cyc} ; cyc`, + ` %cyc = load i32, ptr %cycp`, + ` %headered = icmp ne i32 %cyc, 0`, ` br i1 %headered, label %${yes}, label %${no}`, ]; } @@ -566,7 +566,7 @@ function elemKindNum(elem: IrType): number { /** Array construction call text: ref elements * (records, unions, closures — and cycle-capable inner arrays, whose * SCR_ELEM_ARR spelling would hide them from the outer array's trace) - * construct through scr_arr_new_ref with the element type's `_v` RC entry + * construct through scr_arr_new_ops with the element type's `_v` RC entry * points; every other element kind keeps the plain scr_arr_new call. */ export function arrNewCall(host: ShapeHost, elem: IrType, capText: string): string { const useRef = @@ -590,9 +590,21 @@ export function arrNewCall(host: ShapeHost, elem: IrType, capText: string): stri host.declare(`declare ptr @scr_arr_new(i32, ${host.sizeType})`); return `call ptr @scr_arr_new(i32 ${elemKindNum(elem)}, ${host.sizeType} ${capText})`; } + host.declare(`declare ptr @scr_arr_new_ops(ptr, ${host.sizeType})`); + return `call ptr @scr_arr_new_ops(ptr ${arrOps(host, elem)}, ${host.sizeType} ${capText})`; +} + +/** The constant %ScrArrOps descriptor (retain, release, trace) of a REF + * element type, defined once per module and shared by all its arrays. */ +export function arrOps(host: ShapeHost, elem: IrType): string { const v = vAdapters(host, elem); - host.declare(`declare ptr @scr_arr_new_ref(ptr, ptr, ptr, ${host.sizeType})`); - return `call ptr @scr_arr_new_ref(ptr ${v.retain}, ptr ${v.release}, ptr ${traceArg(host, elem)}, ${host.sizeType} ${capText})`; + const trace = traceArg(host, elem); + const part = (sym: string): string => sym.replace(/^@/, "").replace(/[^A-Za-z0-9_.]/g, "_"); + const name = `@sc_arrops.${part(v.retain)}.${part(v.release)}.${part(trace)}`; + host.declare( + `${name} = internal constant %ScrArrOps { ptr ${v.retain}, ptr ${v.release}, ptr ${trace} }`, + ); + return name; } /* ── capture boxes ────────────────────────────────────────────────────── */ diff --git a/packages/compiler/src/backend/llvm/string-lifetimes.test.ts b/packages/compiler/src/backend/llvm/string-lifetimes.test.ts index 7aec30dd6..89c707c19 100644 --- a/packages/compiler/src/backend/llvm/string-lifetimes.test.ts +++ b/packages/compiler/src/backend/llvm/string-lifetimes.test.ts @@ -167,18 +167,23 @@ test("string operands preserve their left-to-right snapshot when a later assignm expect(facts(f).parameters.has("replace")).toBe(false); }); -test("a later global write keeps mutable string arguments owned", () => { +test("a callee's global write cannot replace the caller's mutable string locals", () => { const source = fn("source", [], str("next")); source.body.unshift({ kind: "assign", localId: "%g.changed", value: str("effect"), loc }); const compare = fn("compare", ["text"], equal(ref("text"), call("source", [], STRING))); - // A later write anywhere in this function rules out parameter borrowing. + // A write anywhere in this function rules out parameter borrowing, but + // the rebound local itself owns its value across the later operand. compare.body.unshift({ kind: "assign", localId: "text", value: str("first"), loc }); const module = mod(source, compare); module.globals = [{ id: "%g.changed", name: "changed", type: STRING, mutable: true }]; const ir = body(module, "sc_f_compare"); const sourceCall = ir.indexOf("@sc_f_source"); expect(sourceCall).toBeGreaterThan(0); - expect(ir.slice(0, sourceCall)).toContain("@scr_str_retain_v"); + expect(ir.slice(0, sourceCall)).not.toContain("@scr_str_retain_v"); + // Reading the global the later operand replaces still takes a snapshot. + compare.body = [ret(equal(ref("%g.changed"), call("source", [], STRING)))]; + const global = body(module, "sc_bf_compare"); + expect(global.slice(0, global.indexOf("@sc_f_source"))).toContain("@scr_str_retain_v"); }); test("immutable lexical owners survive arbitrary later operands", () => { @@ -214,8 +219,22 @@ test("reference fields borrow across preserving calls but snapshot across writes source.locals.push({ id: "changed", name: "changed", type: STRING, mutable: true }); source.body.unshift({ kind: "assign", localId: "changed", value: str("effect"), loc }); expect(body(module, "sc_bf_compare")).not.toContain("@scr_str_retain_v"); + // A global write replaces no record field: the projection still borrows. source.body.unshift({ kind: "assign", localId: "%g.changed", value: str("effect"), loc }); - module.globals = [{ id: "%g.changed", name: "changed", type: STRING, mutable: true }]; + module.globals = [ + { id: "%g.changed", name: "changed", type: STRING, mutable: true }, + { id: "%g.record", name: "record", type: record, mutable: true }, + ]; + expect(body(module, "sc_bf_compare")).not.toContain("@scr_str_retain_v"); + // Writing the projected field of any record does replace it. + source.body.unshift({ + kind: "recordSet", + obj: ref("%g.record", record), + shapeId: "text", + field: "value", + value: str("effect"), + loc, + }); expect(body(module, "sc_bf_compare")).toContain("@scr_str_retain_v"); f.body = [ret(equal(str("constant"), projection))]; expect(body(module, "sc_bf_compare")).not.toContain("@scr_str_retain_v"); @@ -287,7 +306,10 @@ const methodCases: { inline?: boolean; }[] = [ { method: "length", args: [], result: F64, target: "utf16_len", inline: true }, - { method: "charCodeAt", args: [num(1)], result: F64, target: "char_code_at", inline: true }, + // An exact integer index skips the double conversion; any other index + // enters through the double ABI. + { method: "charCodeAt", args: [num(1)], result: F64, target: "char_code_at_int", inline: true }, + { method: "charCodeAt", args: [num(1.5)], result: F64, target: "char_code_at", inline: true }, { method: "charAt", args: [num(1)], result: STRING, target: "char_at" }, { method: "indexOf", args: [ref("argument"), num(1)], result: F64, target: "index_of" }, { method: "includes", args: [ref("argument")], result: BOOL, target: "includes" }, @@ -321,7 +343,7 @@ const methodCases: { ]; test.each(methodCases)( - "$method passes borrowed string inputs through its runtime ABI", + "$method ($target) passes borrowed string inputs through its runtime ABI", ({ method, args, result, target, inline }) => { const f = fn( "method", @@ -342,7 +364,7 @@ test.each(methodCases)( }, ); -test("string search snapshots both receiver and needle before a numeric argument writes globally", () => { +test("string search borrows rebound locals but snapshots a global a later argument writes", () => { const position = fn("position", [], num(0)); position.body.unshift({ kind: "assign", localId: "%g.changed", value: str("effect"), loc }); const search = fn( @@ -361,9 +383,16 @@ test("string search snapshots both receiver and needle before a numeric argument const searchCall = ir.indexOf("@scr_str_index_of"); expect(start).toBeGreaterThan(0); expect(searchCall).toBeGreaterThan(start); - // Literals need no owner, but both reads take independent snapshots. - expect(ir.slice(0, start).match(/@scr_str_retain_v/g)).toHaveLength(2); - expect(ir.slice(searchCall)).toContain("@scr_str_release"); + // The rebound locals own their values across the call: no snapshots. + expect(ir.slice(0, start)).not.toContain("@scr_str_retain_v"); + // A receiver read from the global the numeric argument replaces does. + search.body = [ + ret(intrinsic(ref("%g.changed"), "indexOf", [ref("needle"), call("position", [], F64)], F64)), + ]; + const global = body(module, "sc_bf_search"); + const call2 = global.indexOf("@sc_f_position"); + expect(global.slice(0, call2).match(/@scr_str_retain_v/g)).toHaveLength(1); + expect(global.slice(global.indexOf("@scr_str_index_of"))).toContain("@scr_str_release"); }); test("global string ownership cannot be inferred from an immutable-looking reference", () => { diff --git a/packages/compiler/src/backend/llvm/switch-dispatch.test.ts b/packages/compiler/src/backend/llvm/switch-dispatch.test.ts index e49b9e36e..57c12728e 100644 --- a/packages/compiler/src/backend/llvm/switch-dispatch.test.ts +++ b/packages/compiler/src/backend/llvm/switch-dispatch.test.ts @@ -7,6 +7,11 @@ const number = (value: number): IrExpr => ({ kind: "numLit", value, type: F64, l const string = (value: string): IrExpr => ({ kind: "strLit", value, type: STRING, loc }); function emit(type: IrType, tests: (IrExpr | null)[], pointerBits: 32 | 64 = 64): string { + return emitWith({ kind: "varRef", localId: "value", type, loc }, tests, pointerBits); +} + +function emitWith(disc: IrExpr, tests: (IrExpr | null)[], pointerBits: 32 | 64 = 64): string { + const type = disc.kind === "varRef" ? disc.type : F64; const mod: IrModule = { irVersion: 15, sourceFile: loc.file, @@ -22,7 +27,7 @@ function emit(type: IrType, tests: (IrExpr | null)[], pointerBits: 32 | 64 = 64) body: [ { kind: "switch", - disc: { kind: "varRef", localId: "value", type, loc }, + disc, cases: tests.map((test, index) => ({ test, body: [{ kind: "return", value: number(index), loc }], @@ -39,22 +44,37 @@ function emit(type: IrType, tests: (IrExpr | null)[], pointerBits: 32 | 64 = 64) )![0]; } -test("integer dispatch guards range and fractions before selecting a native case", () => { - for (const [values, conversion, bits] of [ - [[-2147483648, -1, 0, 2147483647], "fptosi", "i32"], - [[0, 1, 2147483648, 4294967295], "fptoui", "i32"], - [[-9007199254740991, -1, 0, 9007199254740991], "fptosi", "i64"], +test("integer dispatch round-trips a frozen conversion before selecting a native case", () => { + for (const [values, bits] of [ + [[-2147483648, -1, 0, 2147483647], "i32"], + [[0, 1, 2147483648, 4294967295], "i64"], + [[-9007199254740991, -1, 0, 9007199254740991], "i64"], ] as const) { const body = emit(F64, values.map(number)); expect(body).toContain(`switch ${bits}`); - expect(body).toContain("fcmp oge double"); - expect(body).toContain("fcmp ole double"); - expect(body).toContain(`${conversion} double`); + expect(body).toContain(`fptosi double`); + expect(body).toContain(`freeze ${bits}`); + expect(body).toContain(`sitofp ${bits}`); expect(body).toContain("fcmp oeq double"); - expect(body.indexOf("br i1")).toBeLessThan(body.indexOf(`${conversion} double`)); + // NaN, infinities and out-of-range values fail the exact round trip; + // no separate range tests are needed. + expect(body).not.toContain("fcmp oge double"); + expect(body).not.toContain("fcmp ole double"); + expect(body.indexOf("freeze")).toBeLessThan(body.indexOf("br i1")); } }); +test("a proven integer discriminant selects without converting", () => { + const value: IrExpr = { kind: "varRef", localId: "value", type: F64, loc }; + const disc: IrExpr = { kind: "bin", op: "|", left: value, right: number(0), type: F64, loc }; + const body = emitWith(disc, [1, 2, 3, 4].map(number)); + expect(body).toContain("switch i32"); + // The ToInt32 coercion of `value | 0` converts once; dispatch adds no + // round trip of its own. + expect(body).not.toContain("freeze"); + expect(body).not.toContain("fcmp oeq double"); +}); + test("duplicate numeric labels keep the first destination and share zero", () => { const body = emit(F64, [-0, 0, 1, 2, 3, 1].map(number)); const dispatch = body.split("\n").find((line) => line.includes("switch i32"))!; diff --git a/packages/compiler/src/backend/llvm/switch-dispatch.ts b/packages/compiler/src/backend/llvm/switch-dispatch.ts index 6e11ffdfb..b02ab2d9e 100644 --- a/packages/compiler/src/backend/llvm/switch-dispatch.ts +++ b/packages/compiler/src/backend/llvm/switch-dispatch.ts @@ -1,5 +1,6 @@ import type { IrExpr, IrStmt } from "../../ir/ir.js"; -import { f64Lit } from "./common.js"; +import { withinInt32 } from "../../ir/integer-ranges.js"; +import { exactInteger, widenInteger } from "./integer-values.js"; import type { LlValue, LlvmEmitterContext } from "./expr-context.js"; type SwitchCase = Extract["cases"][number]; @@ -16,6 +17,7 @@ function integerLiteral(expr: IrExpr): number | null { function emitIntegerSwitch( host: LlvmEmitterContext, disc: LlValue, + discExpr: IrExpr | undefined, cases: readonly SwitchCase[], labels: readonly string[], fallback: string, @@ -36,30 +38,49 @@ function emitIntegerSwitch( if (targets.size < 4) return false; const B = host.B; - const unsigned = min >= 0 && max > 2147483647 && max <= 4294967295; - const bits = unsigned || (min >= -2147483648 && max <= 2147483647) ? "i32" : "i64"; - const low = B.tmp(); - const high = B.tmp(); - const inside = B.tmp(); - const convert = B.newLabel("sw.convert"); - const dispatch = B.newLabel("sw.integer"); - B.line(`${low} = fcmp oge double ${disc.name}, ${f64Lit(min)}`); - B.line(`${high} = fcmp ole double ${disc.name}, ${f64Lit(max)}`); - B.line(`${inside} = and i1 ${low}, ${high}`); - B.condBr(inside, convert, fallback); - B.startBlock(convert); - const integer = B.tmp(); + const bits = min >= -2147483648 && max <= 2147483647 ? "i32" : "i64"; + let selector: string; + const integer = exactInteger(host, disc, discExpr); + if (integer) { + // A proven exact integer selects directly. Narrowing is exact when its + // range fits the case width; otherwise dispatch on the full value. + const wide = widenInteger(host, integer); + if (bits === "i64" || !withinInt32(integer.range)) { + selector = wide; + return terminateSwitch(host, "i64", selector, targets, fallback); + } + selector = B.tmp(); + B.line(`${selector} = trunc i64 ${wide} to i32`); + return terminateSwitch(host, bits, selector, targets, fallback); + } + // freeze keeps NaN and out-of-range conversions from producing poison. + // The exact round trip then rejects every value that is not an integer + // of the case width: NaN and infinities compare unordered, a frozen + // out-of-range conversion converts back to a different value, and -0 + // selects case 0 exactly like strict equality. + const raw = B.tmp(); const restored = B.tmp(); const exact = B.tmp(); - // Ordered range checks dominate conversion: NaN and out-of-range values - // must not produce poison. The round trip rejects fractional inputs. - B.line(`${integer} = ${unsigned ? "fptoui" : "fptosi"} double ${disc.name} to ${bits}`); - B.line(`${restored} = ${unsigned ? "uitofp" : "sitofp"} ${bits} ${integer} to double`); + const dispatch = B.newLabel("sw.integer"); + selector = B.tmp(); + B.line(`${raw} = fptosi double ${disc.name} to ${bits}`); + B.line(`${selector} = freeze ${bits} ${raw}`); + B.line(`${restored} = sitofp ${bits} ${selector} to double`); B.line(`${exact} = fcmp oeq double ${disc.name}, ${restored}`); B.condBr(exact, dispatch, fallback); B.startBlock(dispatch); - B.terminate( - `switch ${bits} ${integer}, label %${fallback} [ ${[...targets] + return terminateSwitch(host, bits, selector, targets, fallback); +} + +function terminateSwitch( + host: LlvmEmitterContext, + bits: "i32" | "i64", + selector: string, + targets: ReadonlyMap, + fallback: string, +): true { + host.B.terminate( + `switch ${bits} ${selector}, label %${fallback} [ ${[...targets] .map(([value, label]) => `${bits} ${value}, label %${label}`) .join(" ")} ]`, ); @@ -121,11 +142,13 @@ function emitStringSwitch( export function emitLiteralSwitch( host: LlvmEmitterContext, disc: LlValue, + discExpr: IrExpr | undefined, cases: readonly SwitchCase[], labels: readonly string[], fallback: string, ): boolean { - if (disc.type.kind === "f64") return emitIntegerSwitch(host, disc, cases, labels, fallback); + if (disc.type.kind === "f64") + return emitIntegerSwitch(host, disc, discExpr, cases, labels, fallback); if (disc.type.kind === "string") return emitStringSwitch(host, disc, cases, labels, fallback); return false; } diff --git a/packages/compiler/src/backend/llvm/walk-borrows.ts b/packages/compiler/src/backend/llvm/walk-borrows.ts index 7ba048573..dc3e03c19 100644 --- a/packages/compiler/src/backend/llvm/walk-borrows.ts +++ b/packages/compiler/src/backend/llvm/walk-borrows.ts @@ -17,6 +17,11 @@ export interface WalkBorrowHost { /** Parameters that may become candidates; once calling conventions are * fixed, only borrowed parameters qualify. Defaults to every parameter. */ parameterAllowed?(localId: string): boolean; + /** For bodies that may write the heap: whether a walk only reads + * locations the whole body never writes, given the current candidates + * (whose own rebinding releases nothing). Absent: the body preserves + * every edge. */ + unwritten?(value: IrExpr, candidates: ReadonlySet): boolean; } export interface WalkFacts { @@ -34,7 +39,9 @@ export interface WalkFacts { * calling convention. * * Soundness rests on the whole body preserving heap edges (the caller - * passes only functions in ReferenceEffects.functions): neither the body + * passes only functions in ReferenceEffects.functions, or supplies + * `unwritten` to admit only walks over locations the body never writes; + * the argument below then applies to those locations): neither the body * nor anything it calls removes a field, element or global reference, so * every object reachable from a parameter at entry stays reachable (and * alive) until the function returns. Such a local therefore needs no @@ -133,6 +140,10 @@ export function analyzeWalks(fn: IrFunction, host: WalkBorrowHost): WalkFacts { case "fieldGet": case "recordGet": return host.borrowsWithoutOwning(e) && walk(e.obj); + // A required element of a walked array (the read still traps when the + // element is missing). + case "arrayGet": + return host.borrowsWithoutOwning(e) && walk(e.arr); case "unionNarrow": case "downcast": case "upcast": @@ -155,12 +166,20 @@ export function analyzeWalks(fn: IrFunction, host: WalkBorrowHost): WalkFacts { return false; } }; - const walkOrThrow = (e: IrExpr): boolean => - (e.kind === "libCall" && e.fn === "error.nodeThrow") || walk(e); + const isThrow = (e: IrExpr): boolean => e.kind === "libCall" && e.fn === "error.nodeThrow"; + const walkOrThrow = (e: IrExpr): boolean => isThrow(e) || walk(e); for (let changed = true; changed;) { changed = false; for (const id of candidates) { - if (definitions.get(id)!.every((value) => value === null || walk(value))) continue; + if ( + definitions + .get(id)! + .every( + (value) => + value === null || (walk(value) && host.unwritten?.(value, candidates) !== false), + ) + ) + continue; candidates.delete(id); changed = true; } @@ -169,6 +188,11 @@ export function analyzeWalks(fn: IrFunction, host: WalkBorrowHost): WalkFacts { const returnsWalk = !guarded && returns.length > 0 && - returns.every((value) => value !== null && walkOrThrow(value)); + returns.every( + (value) => + value !== null && + walkOrThrow(value) && + (isThrow(value) || host.unwritten?.(value, candidates) !== false), + ); return { locals: result, returnsWalk }; } diff --git a/packages/compiler/src/backend/may-throw.test.ts b/packages/compiler/src/backend/may-throw.test.ts index fee54361c..c593de309 100644 --- a/packages/compiler/src/backend/may-throw.test.ts +++ b/packages/compiler/src/backend/may-throw.test.ts @@ -526,3 +526,41 @@ test("throw-only, storage and primitive library operations stay bounded in worke // Only a library call that can reach a dynamic value's conversion polls. expect([...computeMayThrow(mod).workerEntryPolls!].sort()).toEqual(["dynamic"]); }); + +test("explain names the first throwing operation and each call edge", () => { + const message: IrExpr = { + kind: "strLit", + value: "Cannot read properties of undefined (reading 'length')", + type: STRING, + loc, + }; + const code: IrExpr = { kind: "strLit", value: "", type: STRING, loc }; + const typeError: IrExpr = { kind: "numLit", value: 1, type: F64, loc }; + const nodeThrow: IrExpr = { + kind: "libCall", + fn: "error.nodeThrow", + args: [typeError, code, message], + type: VOID, + loc, + }; + const callLoc = { file: "tdz.ts", start: 5, end: 9 }; + const mod = moduleWith( + fn("thrower", [exprStmt(nodeThrow)], []), + fn( + "caller", + [exprStmt({ kind: "call", callee: "thrower", args: [], type: VOID, loc: callLoc })], + [], + ), + fn("quiet", [exprStmt(value)], []), + ); + const result = computeMayThrow(mod, { explain: true }); + expect([...result.fns].sort()).toEqual(["caller", "thrower"]); + expect(result.why?.get("thrower")).toEqual({ + kind: "seed", + what: "throws TypeError: Cannot read properties of undefined (reading 'length')", + loc, + }); + expect(result.why?.get("caller")).toEqual({ kind: "call", callee: "thrower", loc: callLoc }); + // Without the option the analysis records nothing extra. + expect(computeMayThrow(mod).why).toBeUndefined(); +}); diff --git a/packages/compiler/src/backend/may-throw.ts b/packages/compiler/src/backend/may-throw.ts index 55effebad..8f0bab18e 100644 --- a/packages/compiler/src/backend/may-throw.ts +++ b/packages/compiler/src/backend/may-throw.ts @@ -1,12 +1,19 @@ /* Cheap whole-module may-throw analysis (see computeMayThrow). Pure function * of the IR module; the emitter consults the result to place unwind checks. */ -import type { IrExpr, IrStmt, IrModule, IrType } from "../ir/ir.js"; +import type { IrExpr, IrStmt, IrModule, IrType, SrcLoc } from "../ir/ir.js"; import { isFfiCallbackParam, MAY_THROW_ARR_METHODS, MAY_THROW_BYTES_METHODS } from "../ir/ir.js"; import { MAY_THROW_LIB_FNS } from "../ir/builtin-effects.js"; import { everyStmtList } from "../ir/traverse.js"; import { hasRetainedFfiCallback } from "./ffi-callbacks.js"; import { computePublishedTypes, writesPublished } from "./publication.js"; +/** Why a function may throw (computeMayThrow's `explain` option): its own + * throwing operation, or the first call edge to a function that may throw. */ +export type MayThrowReason = + | { kind: "seed"; what: string; loc: SrcLoc | null } + | { kind: "call"; callee: string; loc: SrcLoc | null } + | { kind: "indirect"; target: string; loc: SrcLoc | null }; + /** Cheap may-throw analysis (cost discipline: functions that transitively * CANNOT throw pay for no pending-exception checks). A function may throw * iff it contains a `throw`, calls a may-throw function (direct `call` or @@ -19,9 +26,11 @@ import { computePublishedTypes, writesPublished } from "./publication.js"; * surface a catchable rejection/error and seed the fixpoint like a `throw`. */ export function computeMayThrow( mod: IrModule, - options: { stackChecks?: boolean } = {}, + options: { stackChecks?: boolean; explain?: boolean } = {}, ): { fns: Set; + /** With `explain`: the reason each may-throw function was marked. */ + why?: Map; indirect: boolean; /** Worker programs: the functions that poll for termination on entry. */ workerEntryPolls?: Set; @@ -37,7 +46,13 @@ export function computeMayThrow( throws: boolean; callees: string[]; callsValue: boolean; + /** With `explain`: the first throwing operation, the first site of each + * callee, and the first indirect call. */ + seed?: MayThrowReason; + calleeLocs?: Map; + callValueLoc?: SrcLoc; } + const explain = options.explain === true; const facts = new Map(); const closureTargets = new Set(); // FUNC-targeted dynChecks synthesize adapter closures outside the IR's @@ -70,6 +85,7 @@ export function computeMayThrow( } for (const fn of mod.functions) { const f: Facts = { throws: false, callees: [], callsValue: false }; + if (explain) f.calleeLocs = new Map(); // TDZ reads and non-initializing writes can throw ReferenceError. // Capture locals carry the same flag as the declaring binding. const tdzIds = new Set([...tdzGlobals, ...fn.locals.filter((l) => l.tdz).map((l) => l.id)]); @@ -79,6 +95,8 @@ export function computeMayThrow( ]); // Traverse typed executable nodes without copying the IR into unknown. const visit = (rec: IrExpr | IrStmt): boolean => { + const threw = f.throws; + const callees = f.callees.length; if (published !== null && writesPublished(published, rec)) f.throws = true; switch (rec.kind) { case "throw": @@ -304,19 +322,40 @@ export function computeMayThrow( } case "callValue": f.callsValue = true; + if (explain) f.callValueLoc ??= rec.loc; break; case "closure": closureTargets.add(rec.fnName); break; } + if (explain) { + if (!threw && f.throws) + f.seed = { kind: "seed", what: describeThrowingNode(rec), loc: rec.loc }; + for (let i = callees; i < f.callees.length; i++) + if (!f.calleeLocs!.has(f.callees[i]!)) f.calleeLocs!.set(f.callees[i]!, rec.loc); + if (rec.kind === "newValue" && !f.calleeLocs!.has("\0classValue")) + f.calleeLocs!.set("\0classValue", rec.loc); + } return true; }; everyStmtList(fn.body, { expr: visit, stmt: visit }); // A worker can be terminated at any of its polls: the noncatchable // stop unwinds like an exception from every function that polls. - if (terminations?.polls.has(fn.name)) f.throws = true; + if (terminations?.polls.has(fn.name)) { + if (explain && !f.throws) + f.seed = { kind: "seed", what: "polls for worker termination", loc: fn.loc }; + f.throws = true; + } // A stack-overflow check throws Node's RangeError from the entry. - if (stackChecks?.has(fn.name)) f.throws = true; + if (stackChecks?.has(fn.name)) { + if (explain && !f.throws) + f.seed = { + kind: "seed", + what: "can recurse (directly or through callbacks), so the stack guard may throw RangeError", + loc: fn.loc, + }; + f.throws = true; + } facts.set(fn.name, f); } @@ -326,13 +365,23 @@ export function computeMayThrow( const indirectCallers: string[] = []; const may = new Set(); const pending: string[] = []; - const mark = (name: string): void => { + const why = explain ? new Map() : null; + const mark = (name: string, reason?: MayThrowReason): void => { if (may.has(name)) return; may.add(name); pending.push(name); + if (why !== null && reason !== undefined) why.set(name, reason); }; + const callEdge = (caller: string, callee: string): MayThrowReason | undefined => + why === null + ? undefined + : { kind: "call", callee, loc: facts.get(caller)?.calleeLocs?.get(callee) ?? null }; + const indirectEdge = (caller: string, target: string): MayThrowReason | undefined => + why === null + ? undefined + : { kind: "indirect", target, loc: facts.get(caller)?.callValueLoc ?? null }; for (const [name, f] of facts) { - if (f.throws) mark(name); + if (f.throws) mark(name, f.seed); if (f.callsValue) indirectCallers.push(name); for (const callee of new Set(f.callees)) { let list = callers.get(callee); @@ -347,32 +396,128 @@ export function computeMayThrow( // is reached at most once, without materializing every descendant edge. const throwingHierarchies = new Set(); let indirect = sawDynFuncAdapter; - if (indirect) for (const name of indirectCallers) mark(name); + if (indirect) for (const name of indirectCallers) mark(name, indirectEdge(name, "")); for (let i = 0; i < pending.length; i++) { const name = pending[i]!; if (!indirect && closureTargets.has(name) && !asyncFns.has(name) && !genFns.has(name)) { indirect = true; - for (const caller of indirectCallers) mark(caller); + for (const caller of indirectCallers) mark(caller, indirectEdge(caller, name)); } - for (const caller of callers.get(name) ?? []) mark(caller); + for (const caller of callers.get(name) ?? []) mark(caller, callEdge(caller, name)); let cls = constructorClasses.get(name); while (cls !== undefined && !throwingHierarchies.has(cls)) { const def = classes.get(cls); if (!def) break; throwingHierarchies.add(cls); const valueCallers = classValueCallers.get(cls); - if (valueCallers) for (const caller of valueCallers) mark(caller); + if (valueCallers) + for (const caller of valueCallers) + mark( + caller, + why === null + ? undefined + : { + kind: "call", + callee: name, + loc: facts.get(caller)?.calleeLocs?.get("\0classValue") ?? null, + }, + ); cls = def.base; } } return { fns: may, + ...(why !== null ? { why } : {}), indirect, ...(terminations ? { workerEntryPolls: entryPolls(mod, terminations.entry, stackChecks) } : {}), ...(stackChecks ? { stackChecks } : {}), }; } +/** Error constructors by runtime error kind (SCR_ERR_* in scr_runtime.h). */ +const ERROR_KIND_NAMES: readonly string[] = [ + "Error", + "TypeError", + "RangeError", + "SyntaxError", + "DOMException", + "ReferenceError", + "EvalError", + "URIError", +]; + +/** A short description of a node that seeds the may-throw fixpoint. */ +function describeThrowingNode(rec: IrExpr | IrStmt): string { + switch (rec.kind) { + case "throw": + return "throw statement"; + case "rethrow": + return "rethrow"; + case "runtimeFence": + return "deferred compile fence"; + case "varRef": + case "incDec": + case "assignExpr": + case "assign": + return "binding accessed before initialization (ReferenceError)"; + case "dynCheck": + case "caughtCheck": + return "checked cast of a dynamic value (TypeError)"; + case "dynCall": + case "dynInvoke": + return "call through a dynamic value"; + case "dynKeyGet": + case "dynHasKey": + return "property access on a dynamic value (undefined or null receiver)"; + case "dynDestrCheck": + case "dynIterN": + return "destructuring a dynamic value"; + case "awaitExpr": + case "awaitUnionExpr": + return "await (a rejected promise throws)"; + case "yieldExpr": + case "genResume": + return "generator resumption"; + case "libCall": { + // Compiler-resolved Node throws: name the error and its message. + if (rec.fn === "error.nodeThrow" || rec.fn === "error.new") { + const nodeThrow = rec.fn === "error.nodeThrow"; + const kind = rec.args[0]; + const message = nodeThrow ? rec.args[2] : rec.args[0]; + const name = nodeThrow + ? kind?.kind === "numLit" + ? (ERROR_KIND_NAMES[kind.value] ?? "Error") + : "Error" + : rec.type.kind === "object" + ? rec.type.className.replace(/^%/, "") + : "Error"; + return message?.kind === "strLit" ? `throws ${name}: ${message.value}` : `throws ${name}`; + } + return `library call ${rec.fn}`; + } + case "intrinsic": + return `intrinsic ${rec.name}`; + case "strIntrinsic": + case "regexIntrinsic": + case "arrIntrinsic": + case "bytesIntrinsic": + case "mapIntrinsic": + case "setIntrinsic": + return `${rec.kind} ${rec.method}`; + case "arraySetLength": + return "array length assignment (RangeError)"; + case "jsonStringify": + return "JSON.stringify of a possibly circular value (TypeError)"; + case "toString": + return "string conversion of a dynamic value"; + case "fieldSet": + case "recordSet": + return "write into a possibly published object (TypeError)"; + default: + return rec.kind; + } +} + /** The termination polls a worker program places on function entry. A * stack-checked synchronous function needs none: it may throw (the stack * guard seeds the fixpoint), so every caller tests the pending state after diff --git a/packages/compiler/src/backend/publication.ts b/packages/compiler/src/backend/publication.ts index 7040539dd..4f21bec5f 100644 --- a/packages/compiler/src/backend/publication.ts +++ b/packages/compiler/src/backend/publication.ts @@ -4,6 +4,7 @@ import type { IrExpr, IrModule, IrStmt, IrType } from "../ir/ir.js"; import { typeKey } from "../ir/ir.js"; import { everyStmtList } from "../ir/traverse.js"; +import { computeConstructionFacts } from "./immutability.js"; /** Array methods that write their receiver (the guarded ones). */ export const MUTATING_ARRAY_METHODS: ReadonlySet = new Set([ @@ -45,11 +46,19 @@ export class PublishedTypes { readonly records = new Set(); /** typeKeys of array, map and set types. */ readonly containers = new Set(); + /** Constructor stores into a `this` nothing else can reach yet + * (immutability.ts): never a published target, so never guarded. */ + privateStores: ReadonlySet = new Set(); classGuarded(className: string): boolean { return this.classes.has(className); } + /** Whether a class field store needs the guard. */ + fieldStoreGuarded(s: IrStmt): boolean { + return s.kind === "fieldSet" && this.classes.has(s.className) && !this.privateStores.has(s); + } + recordGuarded(shapeId: string): boolean { return this.records.has(shapeId); } @@ -83,6 +92,7 @@ export function computePublishedTypes(mod: IrModule): PublishedTypes | null { const records = new Map((mod.records ?? []).map((r) => [r.id, r])); const unions = new Map((mod.unions ?? []).map((u) => [u.id, u])); const out = new PublishedTypes(); + out.privateStores = computeConstructionFacts(mod).privateStores; const seen = new Set(); const stack = [...roots]; const addHierarchy = (className: string): void => { @@ -142,6 +152,7 @@ export function computePublishedTypes(mod: IrModule): PublishedTypes | null { export function writesPublished(published: PublishedTypes, node: IrExpr | IrStmt): boolean { switch (node.kind) { case "fieldSet": + return published.fieldStoreGuarded(node); case "fieldIncDec": return published.classGuarded(node.className); case "recordSet": diff --git a/packages/compiler/src/backend/runtime-abi.ts b/packages/compiler/src/backend/runtime-abi.ts index cdbfbacc5..a8b30c680 100644 --- a/packages/compiler/src/backend/runtime-abi.ts +++ b/packages/compiler/src/backend/runtime-abi.ts @@ -2,8 +2,8 @@ * of the link contract: a program object keeps this symbol undefined and the * matching runtime defines it, so incompatible manual links fail before the * program can start. */ -export const RUNTIME_ABI_VERSION = 12 as const; -export const RUNTIME_ABI_MARKER = "scr_runtime_abi_v12" as const; +export const RUNTIME_ABI_VERSION = 13 as const; +export const RUNTIME_ABI_MARKER = "scr_runtime_abi_v13" as const; /** Object consumption is useful today, but the complete scr_* surface may * still change before 1.0. The versioned marker prevents accidental mixing; diff --git a/packages/compiler/src/backend/runtime-pack-targets.test.ts b/packages/compiler/src/backend/runtime-pack-targets.test.ts index 8939fd4cc..7fd8dc415 100644 --- a/packages/compiler/src/backend/runtime-pack-targets.test.ts +++ b/packages/compiler/src/backend/runtime-pack-targets.test.ts @@ -52,7 +52,7 @@ async function fixture(target: NativeTargetSpec, workers = false) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 12, marker: "scr_runtime_abi_v12" }, + runtime_abi: { version: 13, marker: "scr_runtime_abi_v13" }, compiler: { command: "fixture", identity: "fixture", target: target.llvmTriple }, macros: { executable: [], excluded: ["SCR_LIB"], sanitizer: "external-toolchain-required" }, flavors: { diff --git a/packages/compiler/src/backend/runtime-pack.test.ts b/packages/compiler/src/backend/runtime-pack.test.ts index e71cacd8a..42a30cf2c 100644 --- a/packages/compiler/src/backend/runtime-pack.test.ts +++ b/packages/compiler/src/backend/runtime-pack.test.ts @@ -113,7 +113,7 @@ async function fixture(target: NativeTargetSpec = MACOS_ARM64_TARGET) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 12, marker: "scr_runtime_abi_v12" }, + runtime_abi: { version: 13, marker: "scr_runtime_abi_v13" }, compiler: { command: "clang", identity: "fixture clang", diff --git a/packages/compiler/src/contracts/check.ts b/packages/compiler/src/contracts/check.ts new file mode 100644 index 000000000..23559eb22 --- /dev/null +++ b/packages/compiler/src/contracts/check.ts @@ -0,0 +1,1516 @@ +/* Contract types (@scriptc/types), the IR side. The frontend collects the + * written annotations (frontend/contract-types.ts) keyed by the source + * locations the lowering stamps on IR functions, bindings and classes; this + * pass binds them to IR names and checks each contract against every write + * in the whole program: + * + * - NoThrow: the function is outside the may-throw fixpoint + * (backend/may-throw.ts), or the diagnostic names the throwing path. + * - Int32: every value stored into the slot is an int32 by construction, + * proven by the same integer range analysis the int32 storage uses, + * assuming every Int32 slot holds an int32 (sound by induction: every + * write is checked under that assumption). + * - Immutable: no mutation can reach a value that may come from an + * Immutable slot, values stored into Immutable slots are fresh (nothing + * else references them), and such values never escape to code the IR + * cannot see. Module constants built from fresh literals become immortal. + * + * Verified facts land on the IR as `contracts` (IrContracts). */ +import type { ScrDiagnostic } from "../diagnostics/diagnostic.js"; +import type { + IrClassDef, + IrContracts, + IrExpr, + IrFunction, + IrModule, + IrStmt, + IrType, + SrcLoc, +} from "../ir/ir.js"; +import { isRefCounted, typeKey } from "../ir/ir.js"; +import { everyExprChild, everyStmtChild } from "../ir/traverse.js"; +import { + analyzeIntegerRanges, + INT32_RANGE, + integerArithmeticRange, + withinInt32, + type IntegerRange, + type IntegerRanges, + type IntegerSlotFacts, +} from "../ir/integer-ranges.js"; +import { findInitializerBindings, withInitializerBindings } from "../ir/initializer-bindings.js"; +import { unshareNodes } from "../ir/unshare.js"; +import { dynamicallyStoredFamilies, functionCallFacts, Int32Slots } from "../ir/int32-slots.js"; +import { computeMayThrow, type MayThrowReason } from "../backend/may-throw.js"; +import { SourceLocations } from "../backend/source-locations.js"; +import { + contractLocKey, + type ContractAnnotations, + type ContractNote, +} from "../frontend/contract-types.js"; + +/** The largest array index: 2^32 - 2 (ECMA-262 array index). */ +const MAX_ARRAY_INDEX = 2 ** 32 - 2; + +export interface ContractCheckResult { + diagnostics: ScrDiagnostic[]; + contracts: IrContracts | null; +} + +/** Walk every expression and statement of a function body, parents first. */ +function walk( + body: readonly IrStmt[], + visit: { expr?: (e: IrExpr) => void; stmt?: (s: IrStmt) => void }, +): void { + const expr = (e: IrExpr): boolean => { + visit.expr?.(e); + return everyExprChild(e, expr, stmt); + }; + const stmt = (s: IrStmt): boolean => { + visit.stmt?.(s); + return everyStmtChild(s, expr, stmt); + }; + for (const s of body) stmt(s); +} + +function baseName(file: string): string { + const slash = Math.max(file.lastIndexOf("/"), file.lastIndexOf("\\")); + return slash >= 0 ? file.slice(slash + 1) : file; +} + +export function checkContracts( + mod: IrModule, + annotations: ContractAnnotations, + sourceTexts: ReadonlyMap, +): ContractCheckResult { + // Range proofs are keyed by node identity: check the module emission sees. + const checker = new ContractChecker(unshareNodes(mod), annotations, sourceTexts); + return checker.run(); +} + +class ContractChecker { + readonly diagnostics: ScrDiagnostic[] = []; + private readonly reported = new Set(); + private readonly positions: SourceLocations; + readonly functions = new Map(); + readonly classes = new Map(); + private readonly fnByLoc = new Map(); + private readonly localsByLoc = new Map(); + private readonly globalsByLoc = new Map(); + private readonly classesByLoc = new Map(); + private readonly contracts: IrContracts = {}; + /** Whether any verified fact was recorded. */ + private recorded = false; + + constructor( + readonly mod: IrModule, + readonly notes: ContractAnnotations, + readonly sources: ReadonlyMap, + ) { + this.positions = new SourceLocations(sources); + for (const fn of mod.functions) { + this.functions.set(fn.name, fn); + // Synthetic dynamic-class helpers (%dyn.*) carry the location of the + // code that first needed them, which is not their declaration. + if (!fn.name.startsWith("%dyn.")) push(this.fnByLoc, contractLocKey(fn.loc), fn); + for (const local of fn.locals) + if (local.source) + push(this.localsByLoc, contractLocKey(local.source.loc), { fn, localId: local.id }); + } + for (const g of mod.globals ?? []) + if (g.source) push(this.globalsByLoc, contractLocKey(g.source.loc), g.id); + for (const cls of mod.classes ?? []) { + this.classes.set(cls.name, cls); + push(this.classesByLoc, contractLocKey(cls.loc), cls); + } + } + + /* ── reporting ── */ + + where(loc: SrcLoc | null): string { + if (loc === null) return "?"; + const pos = this.positions.position(loc); + return pos ? `${baseName(pos.file)}:${pos.line}:${pos.column}` : baseName(loc.file); + } + + text(loc: SrcLoc, max = 60): string { + const source = this.sources.get(loc.file); + if (source === undefined || loc.end <= loc.start) return ""; + const raw = source.slice(loc.start, loc.end).replace(/\s+/g, " ").trim(); + return raw.length > max ? `${raw.slice(0, max - 3)}...` : raw; + } + + report(code: `SC${number}`, loc: SrcLoc, message: string, hint: string): void { + const key = `${code}\0${contractLocKey(loc)}\0${message}`; + if (this.reported.has(key)) return; + this.reported.add(key); + this.diagnostics.push({ code, loc, message, hint }); + } + + displayName(fnName: string): string { + const fn = this.functions.get(fnName); + const method = /^%(.*)\.([^.]+)$/.exec(fnName); + if (method && !fnName.startsWith("%fn") && !fnName.startsWith("%init")) { + const cls = this.classes.get(method[1]!); + const owner = cls?.jsName ?? method[1]!; + return `${owner}.${method[2]}`; + } + if (fn?.sourceName !== undefined && fn.sourceName !== "") return fn.sourceName; + if (fn !== undefined && /^%fn\d+$/.test(fnName)) return `the function at ${this.where(fn.loc)}`; + return fnName.replace(/^%/, ""); + } + + /** A short TypeScript-like spelling of an IR type, for messages. */ + typeText(t: IrType): string { + switch (t.kind) { + case "f64": + return "number"; + case "bool": + return "boolean"; + case "undefinedT": + return "undefined"; + case "nullT": + return "null"; + case "object": + return this.classes.get(t.className)?.jsName ?? t.className.replace(/^%(m\d+\.)?/, ""); + case "union": { + const def = this.mod.unions?.find((u) => u.id === t.unionId); + return def ? def.arms.map((a) => this.typeText(a)).join(" | ") : "a union"; + } + default: + return t.kind; + } + } + + /** Why a throwing parameter access exists although the source type looks + * safe: the frontend compiles a parameter as `T | undefined` (or null) + * when a caller can pass a missing value, typically a non-null asserted + * element read `xs[i]!`, so the TypeError Node raises inside the callee + * happens there too. Names the parameter and the first such call. */ + private widenedParams(fnName: string | undefined): string { + const fn = fnName === undefined ? undefined : this.functions.get(fnName); + if (fn === undefined) return ""; + const nullable = (t: IrType): boolean => + t.kind === "undefinedT" || + t.kind === "nullT" || + (t.kind === "union" && + this.mod.unions + ?.find((u) => u.id === t.unionId) + ?.arms.some((a) => a.kind === "undefinedT" || a.kind === "nullT") === true); + const params = fn.params.filter((p) => nullable(p.type)); + if (params.length === 0) return ""; + const p = params[0]!; + const index = fn.params.indexOf(p); + let site: SrcLoc | null = null; + for (const caller of this.mod.functions) { + if (site !== null) break; + walk(caller.body, { + expr: (e) => { + if (site !== null || e.kind !== "call" || e.callee !== fn.name) return; + const arg = e.args[index]; + if (arg !== undefined && nullable(arg.type)) site = arg.loc; + }, + }); + } + const name = p.name; + const because = site !== null ? `: the argument at ${this.where(site)} can be missing` : ""; + return ` (parameter '${name}' is compiled as ${this.typeText(p.type)}${because})`; + } + + /* ── binding annotations to IR ── */ + + bindingsOf(key: string): { fn: IrFunction | null; id: string }[] { + const locals = (this.localsByLoc.get(key) ?? []).map((l) => ({ fn: l.fn, id: l.localId })); + const globals = (this.globalsByLoc.get(key) ?? []).map((id) => ({ fn: null, id })); + return [...locals, ...globals]; + } + + functionsAt(key: string): readonly IrFunction[] { + return this.fnByLoc.get(key) ?? []; + } + + classesAt(key: string): readonly IrClassDef[] { + return this.classesByLoc.get(key) ?? []; + } + + run(): ContractCheckResult { + this.checkNoThrow(); + const int32 = new Int32Contracts(this); + int32.run(); + const immutable = new ImmutableContracts(this); + immutable.run(); + if (this.diagnostics.length > 0) return { diagnostics: this.diagnostics, contracts: null }; + const c = this.contracts; + return { diagnostics: [], contracts: this.recorded ? c : null }; + } + + record(field: keyof IrContracts, values: readonly string[]): void { + const list = [...new Set(values)].sort(); + if (list.length === 0) return; + this.contracts[field] = list; + this.recorded = true; + } + + /* ── NoThrow ── */ + + private checkNoThrow(): void { + const targets: { fn: IrFunction; note: ContractNote }[] = []; + for (const [key, list] of this.notes.functions) + for (const note of list) + if (note.marker === "NoThrow") + for (const fn of this.fnByLoc.get(key) ?? []) targets.push({ fn, note }); + if (targets.length === 0) return; + // Target-independent: the native stack guard (Linux, macOS) counts, so a + // contract holds on every platform. + const mt = computeMayThrow(this.mod, { stackChecks: true, explain: true }); + const proven: string[] = []; + for (const { fn, note } of targets) { + if (fn.async === true || fn.generator !== undefined) { + this.report( + "SC7001", + note.loc, + `'${note.name}' is declared NoThrow, but async functions and generators report errors through promises and resumption, which the contract does not cover`, + "remove NoThrow from async functions and generators", + ); + continue; + } + if (!mt.fns.has(fn.name)) { + proven.push(fn.name); + continue; + } + const steps: string[] = []; + const seen = new Set(); + let current: string | undefined = fn.name; + while (current !== undefined && !seen.has(current) && steps.length < 8) { + seen.add(current); + const reason: MayThrowReason | undefined = mt.why?.get(current); + if (reason === undefined) break; + if (reason.kind === "seed") { + steps.push(`${reason.what} at ${this.where(reason.loc)}${this.widenedParams(current)}`); + current = undefined; + } else if (reason.kind === "call") { + steps.push(`calls '${this.displayName(reason.callee)}' at ${this.where(reason.loc)}`); + current = reason.callee; + } else { + steps.push( + reason.target === "" + ? `calls a function value at ${this.where(reason.loc)} (dynamic callbacks may throw)` + : `calls a function value at ${this.where(reason.loc)}, and the function value '${this.displayName(reason.target)}' may throw`, + ); + current = reason.target === "" ? undefined : reason.target; + } + } + this.report( + "SC7001", + note.loc, + `'${note.name}' is declared NoThrow but may throw: ${steps.join(" → ")}`, + "remove the throwing operation from the path (or the recursion), or remove NoThrow; a surrounding try/catch does not discharge the contract in this version", + ); + } + this.record("noThrow", proven); + } +} + +/** The explicit int32 form of a written expression: `x++` and compound + * assignments become an assignment of the `| 0` result. */ +function int32Rewrite(text: string): string { + const step = /^(.+?)\s*(\+\+|--)$/.exec(text) ?? /^(\+\+|--)\s*(.+)$/.exec(text); + if (step) { + const target = step[1] === "++" || step[1] === "--" ? step[2]! : step[1]!; + const op = (step[1] === "++" || step[1] === "--" ? step[1] : step[2]!)[0]!; + return `${target} = (${target} ${op} 1) | 0`; + } + const compound = /^([^=]+?)\s*(\*\*|>>>|<<|>>|[-+*/%&|^])=\s*(.+)$/.exec(text); + if (compound) return `${compound[1]} = (${compound[1]} ${compound[2]} ${compound[3]}) | 0`; + const assignment = /^([^=]+?)\s*=\s*([^=].*)$/.exec(text); + if (assignment) return `${assignment[1]} = ${orZero(assignment[2]!)}`; + return orZero(text); +} + +/** `text | 0`, parenthesized unless `text` binds tighter than `|` for sure + * (a name, member chain, literal or call without nested parentheses). */ +function orZero(text: string): string { + return /^[\w$.]+(\([^()]*\))?$/.test(text) ? `${text} | 0` : `(${text}) | 0`; +} + +function push(map: Map, key: K, value: V): void { + const list = map.get(key); + if (list) list.push(value); + else map.set(key, [value]); +} + +/* ─────────────────────────────── Int32 ─────────────────────────────── */ + +class Int32Contracts { + private readonly slots: Int32Slots; + /** Field families, with the note that declared them. */ + private readonly fields = new Map(); + private readonly params = new Map(); // fn\0localId + private readonly returns = new Map(); // fn + private readonly locals = new Map(); // fn\0localId or \0globalId + + constructor(private readonly c: ContractChecker) { + this.slots = new Int32Slots(c.classes); + } + + run(): void { + if (!this.bind()) return; + if (this.fields.size + this.params.size + this.returns.size + this.locals.size === 0) return; + this.structural(); + this.writes(); + this.c.record("int32Fields", [...this.fields.keys()]); + this.c.record("int32Params", [...this.params.keys()]); + this.c.record("int32Returns", [...this.returns.keys()]); + this.c.record("int32Locals", [...this.locals.keys()]); + } + + private refuse(note: ContractNote, why: string, hint: string): void { + this.c.report( + "SC7003", + note.loc, + `the Int32 contract on '${note.name}' cannot be checked: ${why}`, + hint, + ); + } + + private bind(): boolean { + const c = this.c; + for (const [key, list] of c.notes.functions) + for (const note of list) { + if (note.marker !== "Int32") continue; + for (const fn of c.functionsAt(key)) { + if (fn.async === true || fn.generator !== undefined) { + this.refuse( + note, + "async functions and generators return promises or iterators", + "annotate the awaited value where it is stored instead", + ); + continue; + } + if (fn.returnType.kind !== "f64") { + this.refuse( + note, + "the result is not a plain number", + "write Int32 only on a number result", + ); + continue; + } + this.returns.set(fn.name, note); + } + } + for (const [key, note] of c.notes.bindings) { + if (note.marker !== "Int32") continue; + for (const b of c.bindingsOf(key)) { + const type = b.fn + ? b.fn.locals.find((l) => l.id === b.id)?.type + : c.mod.globals?.find((g) => g.id === b.id)?.type; + if (type?.kind !== "f64") { + this.refuse( + note, + "the binding is not a plain number (optional and union types are not int32 slots)", + "declare it as a required Int32", + ); + continue; + } + if (b.fn === null) { + this.locals.set(`\0${b.id}`, note); + continue; + } + this.locals.set(`${b.fn.name}\0${b.id}`, note); + if (b.fn.params.some((p) => p.localId === b.id)) + this.params.set(`${b.fn.name}\0${b.id}`, note); + } + } + for (const [key, note] of c.notes.fields) { + if (note.marker !== "Int32") continue; + const cut = key.lastIndexOf("\0"); + const field = key.slice(cut + 1); + for (const cls of c.classesAt(key.slice(0, cut))) { + const def = cls.fields.find((f) => f.name === field); + if (!def) { + this.refuse( + note, + `the compiled class has no field '${field}'`, + "annotate an ordinary instance field", + ); + continue; + } + if (def.type.kind !== "f64") { + this.refuse( + note, + "the field is not a plain number", + "declare the field as a required Int32", + ); + continue; + } + const family = this.slots.family(cls.name, field); + if (family !== null) this.fields.set(family, note); + } + } + // Captured bindings: every capture of an Int32 local shares its box. + this.propagateCaptures(); + return true; + } + + private propagateCaptures(): void { + const c = this.c; + for (let changed = true; changed;) { + changed = false; + for (const fn of c.mod.functions) + walk(fn.body, { + expr: (e) => { + if (e.kind !== "closure") return; + const lifted = c.functions.get(e.fnName); + e.captures.forEach((id, i) => { + const inner = lifted?.captures?.[i]; + if (!inner) return; + const outerKey = `${fn.name}\0${id}`; + const innerKey = `${lifted!.name}\0${inner.localId}`; + const outer = this.locals.get(outerKey); + const innerNote = this.locals.get(innerKey); + if (outer && !innerNote) { + this.locals.set(innerKey, outer); + changed = true; + } else if (innerNote && !outer) { + this.locals.set(outerKey, innerNote); + changed = true; + } + }); + }, + }); + } + } + + /** Slots whose writes the IR does not show. */ + private structural(): void { + const c = this.c; + const mod = c.mod; + if (this.fields.size > 0) { + const dynamic = dynamicallyStoredFamilies(mod, this.slots); + for (const [family, note] of this.fields) { + const owner = family.slice(0, family.indexOf("\0")); + let generic = false; + for ( + let cls = c.classes.get(owner); + cls; + cls = cls.base ? c.classes.get(cls.base) : undefined + ) + if ( + cls.runtime === true || + cls.genericOf !== undefined || + (cls.base && !c.classes.has(cls.base)) + ) + generic = true; + for (const cls of c.classes.values()) + if (cls.genericOf !== undefined && (cls.genericOf === owner || cls.name === owner)) + generic = true; + if (generic) + this.refuse( + note, + "the class is generic or extends a runtime-provided class", + "move the field to a non-generic class", + ); + else if (dynamic.has(family)) + this.refuse( + note, + "instances of the class reach dynamic code (any, unknown casts, islands) where a store to the field is not checked", + "keep instances of this class out of any-typed values, or remove Int32", + ); + } + } + if (this.params.size > 0) { + const children = new Map(); + for (const cls of c.classes.values()) if (cls.base) push(children, cls.base, cls.name); + const subtree = (name: string): string[] => { + const out: string[] = []; + const stack = [name]; + while (stack.length) { + const next = stack.pop()!; + out.push(next); + for (const child of children.get(next) ?? []) stack.push(child); + } + return out; + }; + const calls = functionCallFacts(mod, c.classes, subtree); + for (const [key, note] of this.params) { + const fnName = key.slice(0, key.indexOf("\0")); + if (calls.valueEscaped.has(fnName)) + this.refuse( + note, + `'${c.displayName(fnName)}' is used as a value (callback, class value or export), so its callers are not all visible`, + "wrap it in a function that takes a number and passes `x | 0`", + ); + else if (calls.runtimeVirtual(fnName)) + this.refuse( + note, + "the runtime calls this method", + "remove Int32 from runtime-dispatched methods", + ); + } + } + } + + private int32Facts(fnName: string): IntegerSlotFacts { + const params = new Map(); + for (const key of this.params.keys()) + if (key.startsWith(`${fnName}\0`)) params.set(key.slice(fnName.length + 1), INT32_RANGE); + return { + params, + field: (className, field) => { + const family = this.slots.family(className, field); + return family !== null && this.fields.has(family) ? INT32_RANGE : null; + }, + call: (callee) => (this.returns.has(callee) ? INT32_RANGE : null), + boxed: (localId) => (this.locals.has(`${fnName}\0${localId}`) ? INT32_RANGE : null), + locals: (localId) => + this.locals.has(`${fnName}\0${localId}`) || this.locals.has(`\0${localId}`) + ? INT32_RANGE + : null, + }; + } + + private writes(): void { + const c = this.c; + const methodImpls = new Map(); + for (const cls of c.classes.values()) + for (const m of cls.methods ?? []) push(methodImpls, m, `%${cls.name}.${m}`); + const bindings = findInitializerBindings(c.mod); + const fail = (note: ContractNote, value: IrExpr | null, at: SrcLoc, what: string): void => { + const shown = value ? c.text(value.loc) : ""; + c.report( + "SC7002", + at, + `${what} '${note.name}' (Int32) is not provably an int32${shown ? `: '${shown}'` : ""}`, + shown + ? `make the int32 conversion explicit, for example '${int32Rewrite(shown)}', so Node computes the same value` + : "make the int32 conversion explicit with '| 0', so Node computes the same value", + ); + }; + for (const fn of c.mod.functions) { + const numeric = withInitializerBindings(fn, bindings.get(fn.name) ?? []); + const ranges = analyzeIntegerRanges(numeric, this.int32Facts(fn.name)); + const int32 = (e: IrExpr): boolean => e.type.kind === "f64" && withinInt32(ranges.get(e)); + const localNote = (id: string): ContractNote | undefined => + this.locals.get(`${fn.name}\0${id}`) ?? this.locals.get(`\0${id}`); + const checkArgs = (callee: string, args: IrExpr[], offset: number, at: SrcLoc): void => { + const target = c.functions.get(callee); + if (!target) return; + target.params.forEach((param, i) => { + const note = this.params.get(`${callee}\0${param.localId}`); + if (!note) return; + const arg = args[i - offset]; + if (i < offset) return; + if (arg === undefined) fail(note, null, at, "a call passes no argument for"); + else if (!int32(arg)) fail(note, arg, arg.loc, "the argument for"); + }); + }; + const incDecStored = (e: IrExpr, prefix: boolean, op: "+" | "-"): boolean => { + const result = ranges.get(e); + if (!result) return false; + if (prefix) return withinInt32(result); + return withinInt32(integerArithmeticRange(op, result, { min: 1, max: 1 })); + }; + walk(fn.body, { + stmt: (s) => { + if (s.kind === "varDecl" || s.kind === "assign") { + const note = localNote(s.localId); + const value = s.kind === "varDecl" ? s.init : s.value; + if (note && value && !int32(value)) + fail(note, value, value.loc, "the value stored into"); + } else if ( + s.kind === "forOf" || + (s.kind === "tryCatch" && s.catchLocalId !== undefined) + ) { + const id = s.kind === "forOf" ? s.localId : s.catchLocalId!; + const note = localNote(id); + if (note) + fail( + note, + null, + s.loc, + s.kind === "forOf" + ? "a for-of loop element stored into" + : "a caught value stored into", + ); + } else if (s.kind === "fieldSet") { + const family = this.slots.family(s.className, s.field); + const note = family !== null ? this.fields.get(family) : undefined; + if (note && !int32(s.value)) fail(note, s.value, s.value.loc, "the value stored into"); + } else if (s.kind === "return") { + const note = this.returns.get(fn.name); + if (note && (!s.value || !int32(s.value))) + fail(note, s.value, s.value?.loc ?? s.loc, "the value returned from"); + } + }, + expr: (e) => { + if (e.kind === "assignExpr") { + const note = localNote(e.localId); + if (note && !int32(e.value)) fail(note, e.value, e.value.loc, "the value stored into"); + } else if (e.kind === "incDec") { + const note = localNote(e.localId); + if (note && !incDecStored(e, e.prefix, e.op)) + c.report( + "SC7002", + e.loc, + `'${c.text(e.loc)}' can step '${note.name}' (Int32) outside the int32 range`, + `bound the value by an Int32 comparison in the loop condition, or write '${note.name} = (${note.name} ${e.op} 1) | 0'`, + ); + } else if (e.kind === "fieldIncDec") { + const family = this.slots.family(e.className, e.field); + const note = family !== null ? this.fields.get(family) : undefined; + if (note) { + const target = c.text(e.obj.loc); + const field = `${target}.${e.field}`; + c.report( + "SC7002", + e.loc, + `'${c.text(e.loc)}' can step the Int32 field '${note.name}' outside the int32 range`, + `write '${field} = (${field} ${e.op} 1) | 0'`, + ); + } + } else if (e.kind === "call") checkArgs(e.callee, e.args, 0, e.loc); + else if (e.kind === "new") checkArgs(`%${e.className}.constructor`, e.args, 1, e.loc); + else if (e.kind === "virtualCall") + for (const impl of methodImpls.get(e.method) ?? []) checkArgs(impl, e.args, 0, e.loc); + }, + }); + } + } +} + +/* ───────────────────────────── Immutable ───────────────────────────── */ + +/** Read-only and searching array intrinsics: the receiver is not written, + * and arguments are compared or copied out, never stored. */ +const ARR_READS = new Set([ + "length", + "getNumber", + "indexEq", + "indexOf", + "includes", + "nextPresent", + "join", + "slice", + "flatCopy", + "flatOne", + "toReversed", + "toSpliced", + "toSortedPrimitive", + "concatSpread", +]); +const MAP_READS = new Set([ + "get", + "has", + "size", + "iterCount", + "iterLive", + "iterKey", + "iterValue", + "iterEnter", + "iterExit", + "clone", + "keySet", + "valueSet", +]); +const SET_READS = new Set([ + "has", + "size", + "iterCount", + "iterLive", + "iterKey", + "iterEnter", + "iterExit", + "clone", +]); +/** Element reads whose result can be part of the receiver's graph. */ +const MAP_ELEMENT_READS = new Set(["get", "iterKey", "iterValue"]); +const SET_ELEMENT_READS = new Set(["iterKey"]); +/** Copies: a fresh container holding the receiver's elements. */ +const ARR_COPIES = new Set([ + "slice", + "flatCopy", + "flatOne", + "toReversed", + "toSpliced", + "concatSpread", + "toSortedPrimitive", +]); +const COLLECTION_COPIES = new Set(["clone", "keySet", "valueSet"]); +/** Expression kinds whose result is the same value as their child. */ +const PASS_THROUGH = new Set([ + "upcast", + "downcast", + "unionWrap", + "unionNarrow", + "ternary", + "logical", + "nullish", + "orDefault", + "seqExpr", + "chainRecv", + "optChain", + "assignExpr", +]); +/** Observations: the value is inspected, never stored or written. */ +const OBSERVE = new Set([ + "toBool", + "strEq", + "unionEq", + "unionFuncEq", + "unionIsTag", + "unionDisc", + "instanceOf", + "instanceOfValue", + "dynScalarEq", + "fieldAbsent", + "recordHas", + "recordOvfHas", + "arrayHas", + "arrayState", + "jsonStringify", + "toString", + "strConcat", + "bin", + "unary", + "unionKeyGet", + "recordKeyGet", + "recordOvfKeys", +]); +/** Library calls that only read their arguments (console output). */ +const LIB_READS = /^(console\.|inspect\.|json\.stringify)/; + +class ImmutableContracts { + /** Annotated slots: storing into them requires a fresh or immutable value. */ + private readonly annotated = new Map(); + /** Slots that may hold an immutable value (annotated plus inferred). */ + private readonly mayHold = new Set(); + /** The first store that made an inferred slot hold an immutable value. */ + private readonly via = new Map(); + /** Functions whose results are fresh (factory functions). */ + private readonly freshFns = new Set(); + private readonly methodImpls = new Map(); + private readonly slots: Int32Slots; + /** freshLocalsOf results, valid once the factory set is final. */ + private readonly freshLocalsCache = new Map>(); + private factoriesFinal = false; + + constructor(private readonly c: ContractChecker) { + this.slots = new Int32Slots(c.classes); + for (const cls of c.classes.values()) + for (const m of cls.methods ?? []) push(this.methodImpls, m, `%${cls.name}.${m}`); + } + + private refuse(note: ContractNote, why: string, hint: string): void { + this.c.report( + "SC7005", + note.loc, + `the Immutable contract on '${note.name}' cannot be checked: ${why}`, + hint, + ); + } + + run(): void { + this.bind(); + if (this.annotated.size === 0) return; + for (const key of this.annotated.keys()) this.mayHold.add(key); + this.computeFreshFunctions(); + // Grow the may-hold set to a fixpoint, then report from the final pass. + for (let round = 0; round < 64; round++) { + const before = this.mayHold.size; + this.pass(false); + if (this.mayHold.size === before) break; + } + this.pass(true); + this.immortalGlobals(); + } + + private bind(): void { + const c = this.c; + for (const [key, note] of c.notes.bindings) { + if (note.marker !== "Immutable") continue; + for (const b of c.bindingsOf(key)) + this.annotated.set(b.fn ? `l:${b.fn.name}\0${b.id}` : `g:${b.id}`, note); + } + for (const [key, list] of c.notes.functions) + for (const note of list) + if (note.marker === "Immutable") + for (const fn of c.functionsAt(key)) this.annotated.set(`r:${fn.name}`, note); + for (const [key, note] of c.notes.fields) { + if (note.marker !== "Immutable") continue; + const cut = key.lastIndexOf("\0"); + const field = key.slice(cut + 1); + for (const cls of c.classesAt(key.slice(0, cut))) { + const family = this.slots.family(cls.name, field); + if (family === null) + this.refuse( + note, + `the compiled class has no field '${field}'`, + "annotate an ordinary instance field", + ); + else this.annotated.set(`f:${family}`, note); + } + } + } + + private localSlot(fn: IrFunction, id: string): string { + return id.startsWith("%g.") ? `g:${id}` : `l:${fn.name}\0${id}`; + } + private fieldSlot(className: string, field: string): string | null { + const family = this.slots.family(className, field); + return family === null ? null : `f:${family}`; + } + + /** A factory: every return is fresh, built from literals and locals that + * only it references. */ + private computeFreshFunctions(): void { + const c = this.c; + for (let changed = true; changed;) { + changed = false; + for (const fn of c.mod.functions) { + if (this.freshFns.has(fn.name) || fn.async || fn.generator || fn.captures?.length) continue; + if (!isRefCounted(fn.returnType) || fn.returnType.kind === "string") continue; + const freshLocals = this.freshLocalsOf(fn); + let returns = 0; + let ok = true; + walk(fn.body, { + stmt: (s) => { + if (s.kind !== "return") return; + returns++; + if (!s.value || !this.fresh(s.value, freshLocals)) ok = false; + }, + }); + if (ok && returns > 0) { + this.freshFns.add(fn.name); + changed = true; + } + } + } + this.factoriesFinal = true; + } + + /** Locals of `fn` that only ever hold fresh values and are used only as + * intrinsic receivers, field-write targets, element writes and returns: + * the value leaves the function only by `return`. */ + private freshLocalsOf(fn: IrFunction): Set { + const cached = this.factoriesFinal ? this.freshLocalsCache.get(fn.name) : undefined; + if (cached !== undefined) return cached; + const result = this.computeFreshLocals(fn); + if (this.factoriesFinal) this.freshLocalsCache.set(fn.name, result); + return result; + } + + private computeFreshLocals(fn: IrFunction): Set { + const candidates = new Set( + fn.locals.filter((l) => !l.boxed && isRefCounted(l.type)).map((l) => l.id), + ); + for (const p of fn.params) candidates.delete(p.localId); + const allowed = new Set(); + let ranges: IntegerRanges | undefined; + // An element write at a negative, fractional or too-large index adds an + // ordinary property instead, and publication refuses arrays that carry + // properties: only writes at provable array indexes keep a value fresh. + // Typed-array writes never add properties. + const arrayIndex = (index: IrExpr): boolean => { + ranges ??= analyzeIntegerRanges(fn); + const range = ranges.get(index); + return ( + range !== null && range !== undefined && range.min >= 0 && range.max <= MAX_ARRAY_INDEX + ); + }; + walk(fn.body, { + stmt: (s) => { + if (s.kind === "return" && s.value?.kind === "varRef") allowed.add(s.value); + if ((s.kind === "fieldSet" || s.kind === "recordSet") && s.obj.kind === "varRef") + allowed.add(s.obj); + if (s.kind === "bytesSet" && s.arr.kind === "varRef") allowed.add(s.arr); + if (s.kind === "arraySet" && s.arr.kind === "varRef" && arrayIndex(s.index)) + allowed.add(s.arr); + }, + expr: (e) => { + if ( + (e.kind === "arrIntrinsic" || e.kind === "mapIntrinsic" || e.kind === "setIntrinsic") && + e.receiver.kind === "varRef" + ) + allowed.add(e.receiver); + if ((e.kind === "arrayGet" || e.kind === "arrayHas") && e.arr.kind === "varRef") + allowed.add(e.arr); + if ((e.kind === "fieldGet" || e.kind === "recordGet") && e.obj.kind === "varRef") + allowed.add(e.obj); + }, + }); + for (let changed = true; changed;) { + changed = false; + walk(fn.body, { + stmt: (s) => { + const value = s.kind === "varDecl" ? s.init : s.kind === "assign" ? s.value : undefined; + const target = s.kind === "varDecl" || s.kind === "assign" ? s.localId : ""; + if (value && candidates.has(target) && !this.fresh(value, candidates)) { + candidates.delete(target); + changed = true; + } + if (s.kind === "forOf" && candidates.delete(s.localId)) changed = true; + }, + expr: (e) => { + if (e.kind === "varRef" && candidates.has(e.localId) && !allowed.has(e)) { + candidates.delete(e.localId); + changed = true; + } + if ((e.kind === "assignExpr" || e.kind === "incDec") && candidates.delete(e.localId)) + changed = true; + }, + }); + } + return candidates; + } + + /** A value nothing else references: a literal, a fresh construction or + * factory result, a primitive, or a value that is already immutable. */ + private fresh( + e: IrExpr, + freshLocals: ReadonlySet, + derived?: (e: IrExpr) => boolean, + ): boolean { + if (!isRefCounted(e.type) || e.type.kind === "string") return true; + if (derived?.(e)) return true; + switch (e.kind) { + case "strLit": + case "unitLit": + return true; + case "varRef": + return freshLocals.has(e.localId); + case "arrayLit": + return e.elems.every((x) => this.fresh(x, freshLocals, derived)); + case "recordLit": + return e.fields.every((f) => this.fresh(f.value, freshLocals, derived)); + case "mapNew": + return (e.seed ?? []).every( + (p) => + this.fresh(p.key, freshLocals, derived) && this.fresh(p.value, freshLocals, derived), + ); + case "setNew": + return e.seed === undefined || this.fresh(e.seed, freshLocals, derived); + case "new": + return ( + this.constructorKeepsThis(e.className) && + e.args.every((a) => this.fresh(a, freshLocals, derived)) + ); + case "call": + return ( + this.freshFns.has(e.callee) && e.args.every((a) => this.fresh(a, freshLocals, derived)) + ); + case "upcast": + case "downcast": + case "unionWrap": + case "unionNarrow": + return this.fresh(e.value, freshLocals, derived); + case "ternary": + return ( + this.fresh(e.then, freshLocals, derived) && this.fresh(e.else_, freshLocals, derived) + ); + default: + return false; + } + } + + /** The constructor chain uses `this` only to read and write its own + * fields: the new object is referenced from nowhere else. */ + private constructorKeepsThis(className: string): boolean { + const c = this.c; + for ( + let cls = c.classes.get(className); + cls; + cls = cls.base ? c.classes.get(cls.base) : undefined + ) { + if (cls.runtime === true) return false; + const ctor = c.functions.get(`%${cls.name}.constructor`); + if (!ctor) continue; + const self = ctor.params[0]?.localId; + if (self === undefined) return false; + const allowed = new Set(); + walk(ctor.body, { + stmt: (s) => { + if (s.kind === "fieldSet" && s.obj.kind === "varRef") allowed.add(s.obj); + }, + expr: (e) => { + if (e.kind === "fieldGet" && e.obj.kind === "varRef") allowed.add(e.obj); + if ( + e.kind === "call" && + e.callee === `%${cls.base}.constructor` && + e.args[0]?.kind === "varRef" + ) + allowed.add(e.args[0]); + }, + }); + let ok = true; + walk(ctor.body, { + expr: (e) => { + if (e.kind === "varRef" && e.localId === self && !allowed.has(e)) ok = false; + if (e.kind === "closure" && e.captures.includes(self)) ok = false; + }, + }); + if (!ok) return false; + } + return true; + } + + /** One pass over the program: derived values, stores, escapes and + * mutations. With `report`, violations become diagnostics. */ + private pass(report: boolean): void { + const c = this.c; + for (const fn of c.mod.functions) { + const derivedMemo = new Map(); + const freshLocals = this.freshLocalsOf(fn); + const derived = (e: IrExpr): boolean => { + if (!isRefCounted(e.type) || e.type.kind === "string") return false; + const memo = derivedMemo.get(e); + if (memo !== undefined) return memo; + derivedMemo.set(e, false); + const result = this.derivedExpr(fn, e, derived); + derivedMemo.set(e, result); + return result; + }; + const hold = (slot: string | null, value: IrExpr, at: string): void => { + if (slot === null || !derived(value)) return; + if (!this.mayHold.has(slot)) { + this.mayHold.add(slot); + this.via.set(slot, at); + } + }; + const store = (slot: string | null, value: IrExpr, how?: string): void => { + if (slot === null) return; + const note = this.annotated.get(slot); + if (note && report && !this.fresh(value, freshLocals, derived)) { + c.report( + "SC7004", + value.loc, + `the value stored into '${note.name}' (Immutable) may be referenced elsewhere: '${c.text(value.loc)}' is not a fresh literal, construction or factory result`, + "build the value in place (a literal, `new`, or a function that returns what it builds), so no mutable reference to it remains", + ); + } + hold(slot, value, how ?? `stored at ${c.where(value.loc)}`); + }; + const mutate = (target: IrExpr, at: SrcLoc, what: string): void => { + if (!report || !derived(target)) return; + const shown = c.text(target.loc); + const origin = this.originOf(fn, target); + const subject = + origin === "" && shown !== "" && shown !== c.text(at) ? ` ('${shown}')` : ""; + c.report( + "SC7004", + at, + `${what} writes to a value that may be Immutable${subject}${origin}`, + "Immutable values cannot be written through any reference; copy the value before changing it", + ); + }; + const escape = (value: IrExpr, at: SrcLoc, what: string): void => { + if (!report || !derived(value)) return; + c.report( + "SC7005", + at, + `a value that may be Immutable escapes to ${what}, where writes are not checked: '${c.text(value.loc)}'${this.originOf(fn, value)}`, + "keep Immutable values in typed code, or copy the value before handing it out", + ); + }; + const args = (callee: string, list: IrExpr[], offset: number, at: SrcLoc): void => { + const target = c.functions.get(callee); + list.forEach((arg, i) => { + const param = target?.params[i + offset]; + if (!target || !param) + return escape(arg, arg.loc, `a call to '${c.displayName(callee)}'`); + store( + `l:${callee}\0${param.localId}`, + arg, + `passed to '${c.displayName(callee)}' at ${c.where(at)}`, + ); + }); + }; + walk(fn.body, { + stmt: (s) => { + switch (s.kind) { + case "varDecl": + if (s.init) store(this.localSlot(fn, s.localId), s.init); + break; + case "assign": + store(this.localSlot(fn, s.localId), s.value); + break; + case "return": + if (s.value) + store( + `r:${fn.name}`, + s.value, + `returned from '${c.displayName(fn.name)}' at ${c.where(s.loc)}`, + ); + break; + case "fieldSet": + mutate(s.obj, s.loc, `'${c.text(s.loc)}'`); + store(this.fieldSlot(s.className, s.field), s.value); + break; + case "recordSet": + mutate(s.obj, s.loc, `'${c.text(s.loc)}'`); + store(`s:${s.shapeId}\0${s.field}`, s.value); + break; + case "recordKeySet": + mutate(s.obj, s.loc, `'${c.text(s.loc)}'`); + escape(s.value, s.loc, "a dynamically keyed property"); + break; + case "recordKeyDelete": + mutate(s.obj, s.loc, `'${c.text(s.loc)}'`); + break; + case "arraySet": + mutate(s.arr, s.loc, `'${c.text(s.loc)}'`); + store(`e:${typeKey(s.arr.type)}`, s.value); + break; + case "arraySetLength": + case "arraySetUndefined": + case "arrayDelete": + case "bytesSet": + mutate(s.arr, s.loc, `'${c.text(s.loc)}'`); + break; + case "forOf": { + const slot = this.localSlot(fn, s.localId); + const elems = + this.mayHold.has(`e:${typeKey(s.iterable.type)}`) || + this.mayHold.has(`se:${typeKey(s.iterable.type)}`); + if ((elems || derived(s.iterable)) && !this.mayHold.has(slot)) { + this.mayHold.add(slot); + this.via.set(slot, `iterated at ${c.where(s.loc)}`); + } + break; + } + case "throw": + escape(s.value, s.loc, "a throw"); + break; + } + }, + expr: (e) => { + switch (e.kind) { + case "assignExpr": + store(this.localSlot(fn, e.localId), e.value); + return; + case "call": + return args(e.callee, e.args, 0, e.loc); + case "new": + return args(`%${e.className}.constructor`, e.args, 1, e.loc); + case "virtualCall": + for (const impl of this.methodImpls.get(e.method) ?? []) args(impl, e.args, 0, e.loc); + return; + case "fieldIncDec": + return mutate(e.obj, e.loc, `'${c.text(e.loc)}'`); + case "arrIntrinsic": + if (ARR_COPIES.has(e.method)) + this.copyElements(e.receiver, e.type, derived(e.receiver), c.where(e.loc)); + if (!ARR_READS.has(e.method)) mutate(e.receiver, e.loc, `'${c.text(e.loc)}'`); + for (const a of e.args) { + if (e.method === "indexOf" || e.method === "includes" || e.method === "indexEq") + continue; + store(`e:${typeKey(e.receiver.type)}`, a); + } + return; + case "mapIntrinsic": + if (COLLECTION_COPIES.has(e.method)) + this.copyElements(e.receiver, e.type, derived(e.receiver), c.where(e.loc)); + if (!MAP_READS.has(e.method)) mutate(e.receiver, e.loc, `'${c.text(e.loc)}'`); + if (e.method === "set") { + if (e.args[0]) store(`mk:${typeKey(e.receiver.type)}`, e.args[0]); + if (e.args[1]) store(`mv:${typeKey(e.receiver.type)}`, e.args[1]); + } + return; + case "setIntrinsic": + if (COLLECTION_COPIES.has(e.method)) + this.copyElements(e.receiver, e.type, derived(e.receiver), c.where(e.loc)); + if (!SET_READS.has(e.method)) mutate(e.receiver, e.loc, `'${c.text(e.loc)}'`); + if (e.method === "add" && e.args[0]) + store(`se:${typeKey(e.receiver.type)}`, e.args[0]); + return; + case "arrayLit": + for (const x of e.elems) store(`e:${typeKey(e.type)}`, x); + return; + case "recordLit": + if (e.type.kind === "record") + for (const f of e.fields) store(`s:${e.type.shapeId}\0${f.name}`, f.value); + return; + case "mapNew": + for (const p of e.seed ?? []) { + store(`mk:${typeKey(e.type)}`, p.key); + store(`mv:${typeKey(e.type)}`, p.value); + } + return; + case "closure": { + const lifted = c.functions.get(e.fnName); + e.captures.forEach((id, i) => { + const inner = lifted?.captures?.[i]; + const outer = this.localSlot(fn, id); + if (!inner) return; + const innerSlot = `l:${lifted!.name}\0${inner.localId}`; + if (this.mayHold.has(outer) && !this.mayHold.has(innerSlot)) { + this.mayHold.add(innerSlot); + this.via.set(innerSlot, `captured at ${c.where(e.loc)}`); + } + }); + return; + } + case "libCall": + if (!LIB_READS.test(e.fn)) + for (const a of e.args) escape(a, a.loc, `the library call ${e.fn}`); + return; + case "callValue": + for (const a of e.args) escape(a, a.loc, "a call through a function value"); + if (e.receiver) escape(e.receiver, e.receiver.loc, "a call through a function value"); + return; + } + if (PASS_THROUGH.has(e.kind) || OBSERVE.has(e.kind)) return; + if (e.kind === "fieldGet" || e.kind === "recordGet" || e.kind === "arrayGet") return; + // Any other parent: a derived child goes somewhere this pass does + // not follow (dynamic conversions, islands, runtime helpers). + everyExprChild( + e, + (child) => { + escape(child, child.loc, describeSink(e)); + return true; + }, + () => true, + ); + }, + }); + } + } + + /** A copy of a container whose elements may be immutable: the copy's + * element slots may hold them too (the copy itself is fresh). */ + private copyElements( + receiver: IrExpr, + result: IrType, + receiverDerived: boolean, + where: string, + ): void { + const at = `copied at ${where}`; + const rk = typeKey(receiver.type); + const sources = [`e:${rk}`, `mk:${rk}`, `mv:${rk}`, `se:${rk}`]; + if (!receiverDerived && !sources.some((slot) => this.mayHold.has(slot))) return; + const key = typeKey(result); + for (const slot of [`e:${key}`, `se:${key}`, `mk:${key}`, `mv:${key}`]) + if (!this.mayHold.has(slot)) { + this.mayHold.add(slot); + this.via.set(slot, at); + } + } + + private originOf(fn: IrFunction, e: IrExpr): string { + let root = e; + for (let steps = 0; steps < 16; steps++) { + if (root.kind === "fieldGet" || root.kind === "recordGet") root = root.obj; + else if (root.kind === "arrayGet") root = root.arr; + else if ( + root.kind === "upcast" || + root.kind === "downcast" || + root.kind === "unionWrap" || + root.kind === "unionNarrow" || + root.kind === "assignExpr" + ) + root = root.value; + else if (root.kind === "varRef") { + // Compiler temporaries (no source binding): follow their initializer. + const id = root.localId; + const local = fn.locals.find((l) => l.id === id); + if (local === undefined || local.source !== undefined) break; + let init: IrExpr | null = null; + walk(fn.body, { + stmt: (s) => { + if (s.kind === "varDecl" && s.localId === id && s.init) init ??= s.init; + }, + }); + if (init === null) break; + root = init; + } else break; + } + if (root.kind === "varRef") { + const slot = this.localSlot(fn, root.localId); + const note = this.annotated.get(slot); + if (note) return ` (from '${note.name}')`; + const via = this.via.get(slot); + if (via) { + const local = fn.locals.find((l) => l.id === root.localId); + return ` ('${local?.name ?? root.localId}' may be an Immutable value ${via})`; + } + } + return ""; + } + + /** Whether `e` may evaluate to (part of) an Immutable value. */ + private derivedExpr(fn: IrFunction, e: IrExpr, derived: (e: IrExpr) => boolean): boolean { + switch (e.kind) { + case "varRef": + return this.mayHold.has(this.localSlot(fn, e.localId)); + case "fieldGet": { + const slot = this.fieldSlot(e.className, e.field); + return (slot !== null && this.mayHold.has(slot)) || derived(e.obj); + } + case "recordGet": + return ( + this.mayHold.has( + `s:${e.obj.type.kind === "record" ? e.obj.type.shapeId : ""}\0${e.field}`, + ) || derived(e.obj) + ); + case "arrayGet": + return this.mayHold.has(`e:${typeKey(e.arr.type)}`) || derived(e.arr); + case "mapIntrinsic": + return ( + MAP_ELEMENT_READS.has(e.method) && + (this.mayHold.has(`mv:${typeKey(e.receiver.type)}`) || + this.mayHold.has(`mk:${typeKey(e.receiver.type)}`) || + derived(e.receiver)) + ); + case "setIntrinsic": + return ( + SET_ELEMENT_READS.has(e.method) && + (this.mayHold.has(`se:${typeKey(e.receiver.type)}`) || derived(e.receiver)) + ); + case "call": + return this.mayHold.has(`r:${e.callee}`); + case "virtualCall": + return (this.methodImpls.get(e.method) ?? []).some((impl) => this.mayHold.has(`r:${impl}`)); + case "ternary": + return derived(e.then) || derived(e.else_); + case "logical": + case "nullish": + return derived(e.left) || derived(e.right); + case "seqExpr": + return derived(e.result); + case "assignExpr": + return derived(e.value); + case "upcast": + case "downcast": + case "unionWrap": + case "unionNarrow": + return derived(e.value); + default: { + if (!PASS_THROUGH.has(e.kind)) return false; + let any = false; + everyExprChild( + e, + (child) => { + any ||= derived(child); + return !any; + }, + () => true, + ); + return any; + } + } + } + + /** Module constants with an Immutable annotation, written once from a + * fresh value of a publishable type: the backend makes them immortal. */ + private immortalGlobals(): void { + const c = this.c; + if (c.mod.lib !== undefined || c.diagnostics.length > 0) return; + const out: string[] = []; + for (const g of c.mod.globals ?? []) { + if ( + g.mutable || + g.tdz === true || + g.initFlag !== undefined || + !this.annotated.has(`g:${g.id}`) + ) + continue; + if (!this.publishable(g.type, new Set())) continue; + let writes = 0; + let fresh = true; + for (const fn of c.mod.functions) { + const freshLocals = this.freshLocalsOf(fn); + walk(fn.body, { + stmt: (s) => { + if ((s.kind === "assign" || s.kind === "varDecl") && s.localId === g.id) { + writes++; + const value = s.kind === "assign" ? s.value : s.init; + if (!value || !this.fresh(value, freshLocals)) fresh = false; + } + }, + expr: (e) => { + if (e.kind === "assignExpr" && e.localId === g.id) writes++; + }, + }); + } + if (writes === 1 && fresh) out.push(g.id); + } + c.record("immortalGlobals", out); + } + + /** Static types the publication walkers handle without a refusal. */ + private publishable(t: IrType, seen: Set): boolean { + const c = this.c; + switch (t.kind) { + case "f64": + case "bool": + case "string": + case "undefinedT": + case "nullT": + return true; + case "array": + case "set": + return this.publishable(t.elem, seen); + case "map": + return this.publishable(t.key, seen) && this.publishable(t.value, seen); + case "record": { + const key = `r:${t.shapeId}`; + if (seen.has(key)) return true; + seen.add(key); + const shape = c.mod.records?.find((r) => r.id === t.shapeId); + return ( + !!shape && !shape.indexValue && shape.fields.every((f) => this.publishable(f.type, seen)) + ); + } + case "union": { + const key = `u:${t.unionId}`; + if (seen.has(key)) return true; + seen.add(key); + const def = c.mod.unions?.find((u) => u.id === t.unionId); + return !!def && def.arms.every((arm) => this.publishable(arm, seen)); + } + case "object": { + const key = `o:${t.className}`; + if (seen.has(key)) return true; + seen.add(key); + // Subclasses can stand behind a base-typed reference. + for (const cls of c.classes.values()) { + let under = false; + for ( + let x: IrClassDef | undefined = cls; + x; + x = x.base ? c.classes.get(x.base) : undefined + ) + if (x.name === t.className) under = true; + if (!under) continue; + for ( + let x: IrClassDef | undefined = cls; + x; + x = x.base ? c.classes.get(x.base) : undefined + ) + if (x.runtime === true || x.localCaptures !== undefined) return false; + if (!cls.fields.every((f) => f.name.startsWith("%") || this.publishable(f.type, seen))) + return false; + } + return true; + } + default: + return false; + } + } +} + +function describeSink(e: IrExpr): string { + switch (e.kind) { + case "dynFrom": + case "dynObjLit": + case "dynArrLit": + return "dynamic (any or unknown) code"; + case "jsOp": + case "jsMarshal": + case "jsExit": + return "the JavaScript island"; + case "intrinsic": + return `the runtime (${e.name})`; + default: + return `an operation scriptc does not follow (${e.kind})`; + } +} diff --git a/packages/compiler/src/executable/prepare.ts b/packages/compiler/src/executable/prepare.ts index ccb02660b..e62055818 100644 --- a/packages/compiler/src/executable/prepare.ts +++ b/packages/compiler/src/executable/prepare.ts @@ -8,6 +8,7 @@ import { } from "../diagnostics/diagnostic.js"; import type { IrModule, SrcLoc } from "../ir/ir.js"; import { validateModule } from "../ir/validate.js"; +import { checkContracts } from "../contracts/check.js"; import { fenceSpeculativeWasiFunctions, moduleWasiUnavailableSurface, @@ -89,6 +90,12 @@ export function prepareExecutableModule( } } sourceTexts = fe.sourceTexts(); + if (lowered.contracts) { + const checked = checkContracts(lowered.module, lowered.contracts, sourceTexts); + timing("contracts"); + if (checked.diagnostics.length > 0) return fail(checked.diagnostics); + if (checked.contracts) lowered.module.contracts = checked.contracts; + } } finally { fe.dispose(); timing("frontend-dispose"); diff --git a/packages/compiler/src/frontend/contract-types.ts b/packages/compiler/src/frontend/contract-types.ts new file mode 100644 index 000000000..7c622fdee --- /dev/null +++ b/packages/compiler/src/frontend/contract-types.ts @@ -0,0 +1,203 @@ +/* Contract types (@scriptc/types): written annotations scriptc checks as + * extra contracts. The package is types only (`export type` aliases that + * TypeScript erases), so Node.js never loads it; scriptc recognizes the + * aliases by import provenance, like threads-import.ts recognizes the + * @scriptc/threads exports. TypeScript drops alias identity from inferred + * types, so only annotations the program WRITES count: parameter, return, + * variable and class field types. The IR-side checks live in + * ir/contract-check.ts. */ +import type { ScrDiagnostic } from "../diagnostics/diagnostic.js"; +import type { SrcLoc } from "../ir/ir.js"; +import { locOf } from "./program.js"; +import * as ts from "./ts7/adapter.js"; + +export const CONTRACT_TYPES_MODULE = "@scriptc/types"; + +export type ContractMarker = "Int32" | "NoThrow" | "Immutable"; +const MARKERS: ReadonlySet = new Set(["Int32", "NoThrow", "Immutable"]); + +/** One written contract: what it promises and where the annotation is. */ +export interface ContractNote { + marker: ContractMarker; + /** The annotation (the marker's type reference). */ + loc: SrcLoc; + /** The annotated declaration's name, for messages. */ + name: string; +} + +/** Contracts keyed by the declaration they annotate. Keys are SrcLoc keys + * (contractLocKey) of the nodes the lowering stamps on the IR: function + * declarations (IrFunction.loc), binding names (IrLocal/IrGlobal + * source.loc), and classes (IrClassDef.loc) plus the field name. */ +export interface ContractAnnotations { + /** NoThrow and result markers (Int32, Immutable) by function. */ + functions: Map; + /** Parameters and variables by their name's location. */ + bindings: Map; + /** Instance fields by `${class key}\0${field name}`. */ + fields: Map; + diagnostics: ScrDiagnostic[]; + /** Number of annotations found (for timing and tests). */ + count: number; +} + +export function contractLocKey(loc: SrcLoc): string { + return `${loc.file}\0${loc.start}\0${loc.end}`; +} + +/** The marker a type reference names when its name is a named or namespace + * import binding of @scriptc/types (`import type { Int32 } from + * "@scriptc/types"`, `import type * as sc from "@scriptc/types"`). */ +function markerOf(checker: ts.TypeChecker, ref: ts.TypeReferenceNode): ContractMarker | null { + const name = ref.typeName; + let ident: ts.Identifier; + let member: string; + if (ts.isIdentifier(name)) { + if (!MARKERS.has(name.text)) return null; + ident = name; + member = name.text; + } else if (ts.isQualifiedName(name) && ts.isIdentifier(name.left)) { + if (!MARKERS.has(name.right.text)) return null; + ident = name.left; + member = name.right.text; + } else return null; + const symbol = checker.getSymbolAtLocation(ident); + const decl = symbol ? checker.declarationsOf(symbol)[0] : undefined; + if (decl === undefined) return null; + let importDecl: ts.Node | undefined; + if (ts.isImportSpecifier(decl) && ident === name) { + importDecl = decl.parent?.parent?.parent; + member = decl.propertyName?.text ?? decl.name.text; + } else if (ts.isNamespaceImport(decl) && ident !== name) importDecl = decl.parent?.parent; + else return null; + if ( + importDecl === undefined || + !ts.isImportDeclaration(importDecl) || + !ts.isStringLiteral(importDecl.moduleSpecifier) || + importDecl.moduleSpecifier.text !== CONTRACT_TYPES_MODULE + ) + return null; + return MARKERS.has(member) ? (member as ContractMarker) : null; +} + +function nameText(node: ts.Node | undefined): string { + if (node === undefined) return ""; + if (ts.isIdentifier(node) || ts.isPrivateIdentifier(node)) return node.text; + return node.getText(); +} + +function contractDiag( + code: `SC${number}`, + loc: SrcLoc, + message: string, + hint: string, +): ScrDiagnostic { + return { code, loc, message, hint }; +} + +/** Collect every contract annotation in the program's own TypeScript + * modules. Files that do not mention the package cannot import a marker + * (re-exports are not followed), so they are skipped without a walk. */ +export function collectContractAnnotations( + checker: ts.TypeChecker, + files: readonly ts.SourceFile[], +): ContractAnnotations { + const out: ContractAnnotations = { + functions: new Map(), + bindings: new Map(), + fields: new Map(), + diagnostics: [], + count: 0, + }; + const kinds = new Set([ts.SyntaxKind.TypeReference]); + for (const sf of files) { + if (sf.isDeclarationFile || !sf.text.includes(CONTRACT_TYPES_MODULE)) continue; + ts.walkPreorder( + sf, + (node) => { + if (!ts.isTypeReferenceNode(node)) return; + const marker = markerOf(checker, node); + if (marker === null) return; + out.count++; + place(out, checker, node, marker); + }, + kinds, + ); + } + return out; +} + +function unsupported(out: ContractAnnotations, node: ts.Node, marker: ContractMarker): void { + const where = + marker === "NoThrow" + ? "NoThrow wraps a function's written return type" + : marker === "Int32" + ? "Int32 is checked on parameters, variables, class instance fields and function results" + : "Immutable is checked on parameters, variables, class instance fields and function results"; + out.diagnostics.push( + contractDiag( + "SC7006", + locOf(node), + `the ${marker} contract is not checked in this position (${where})`, + marker === "NoThrow" + ? "write it as the function's return type annotation: function f(): NoThrow" + : `write ${marker} directly as the annotation of the declaration; type aliases, interface members and types nested in other types (arrays, unions, type arguments) are not followed`, + ), + ); +} + +function place( + out: ContractAnnotations, + checker: ts.TypeChecker, + ref: ts.TypeReferenceNode, + marker: ContractMarker, +): void { + let node: ts.Node = ref; + let parent = ref.parent; + // NoThrow / NoThrow>: the inner marker is the result + // contract of the function the NoThrow annotates. + if (marker !== "NoThrow" && parent !== undefined && ts.isTypeReferenceNode(parent)) { + const wrapper = markerOf(checker, parent); + if (wrapper === "NoThrow" && parent.typeArguments?.[0] === ref) { + node = parent; + parent = parent.parent; + } + } + const note = (name: string): ContractNote => ({ marker, loc: locOf(ref), name }); + if (parent === undefined) return unsupported(out, ref, marker); + if (ts.isFunctionLike(parent) && parent.type === node) { + if (!ts.isFunctionLikeDeclaration(parent)) return unsupported(out, ref, marker); + const key = contractLocKey(locOf(parent)); + const list = out.functions.get(key) ?? []; + list.push(note(ts.isConstructorDeclaration(parent) ? "constructor" : nameText(parent.name))); + out.functions.set(key, list); + return; + } + if (marker === "NoThrow") return unsupported(out, ref, marker); + if ( + (ts.isParameter(parent) || ts.isVariableDeclaration(parent)) && + parent.type === node && + ts.isIdentifier(parent.name) + ) { + out.bindings.set(contractLocKey(locOf(parent.name)), note(parent.name.text)); + return; + } + if (ts.isPropertyDeclaration(parent) && parent.type === node) { + const cls = parent.parent; + const isStatic = + ts.getModifiers(parent)?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword) === true; + if ( + !isStatic && + cls !== undefined && + (ts.isClassDeclaration(cls) || ts.isClassExpression(cls)) && + (ts.isIdentifier(parent.name) || ts.isPrivateIdentifier(parent.name)) + ) { + out.fields.set( + `${contractLocKey(locOf(cls))}\0${parent.name.text}`, + note(`${nameText(cls.name)}.${parent.name.text}`), + ); + return; + } + } + unsupported(out, ref, marker); +} 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 7db085f22..2a972b8ea 100644 --- a/packages/compiler/src/frontend/lowering/lower-calls.ts +++ b/packages/compiler/src/frontend/lowering/lower-calls.ts @@ -176,6 +176,7 @@ import { completeArgs, } from "./call-arguments.js"; import { isThisParameter, type ParamShape } from "./call-signatures.js"; +import { checkedArmExtraction } from "./coercions/unions.js"; import { requireObjLitGenericReceiver, objLitGenericFnNodeOf, @@ -8996,8 +8997,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 2bae9c82e..078c13ea9 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"; @@ -1073,6 +1074,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); @@ -1123,7 +1131,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") { @@ -3662,6 +3672,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; @@ -3708,6 +3722,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, @@ -3745,6 +3761,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, @@ -3779,6 +3803,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: { @@ -3795,6 +3823,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, @@ -3805,6 +3835,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 184ffc8a4..b7fd026cd 100644 --- a/packages/compiler/src/frontend/lowering/lowerer.ts +++ b/packages/compiler/src/frontend/lowering/lowerer.ts @@ -71,12 +71,14 @@ 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"; import { StringIndexBounds } from "./string-index-bounds.js"; import { NanCodedReads } from "./nan-coded-reads.js"; import { RuntimeOptionalLocals } from "./runtime-optional-locals.js"; +import { collectContractAnnotations, type ContractAnnotations } from "../contract-types.js"; import { sanitizeUnregisteredClassTypes } from "./sanitize-class-types.js"; import { UnregisteredClassTypes } from "./unregistered-class-types.js"; import type { WidthLift } from "./width-lift.js"; @@ -726,6 +728,9 @@ export interface LowerResult { /** Present iff diagnostics is empty. */ module: IrModule | null; diagnostics: ScrDiagnostic[]; + /** The program's written contract types (@scriptc/types), keyed by the + * source locations the IR carries; absent when it writes none. */ + contracts?: ContractAnnotations; /** JS statements whose compile fences DEFERRED to runtime (runtimeFence * statements in the module) — off the build, on the coverage report. */ runtimeFences: ScrDiagnostic[]; @@ -1038,6 +1043,17 @@ export function lowerToIr( const divergences = scanDivergences(resultLowerer, moduleOrder); timing("divergence-scan", { found: divergences.length }); if (divergences.length > 0) result = { ...result, divergences }; + // Contract types (@scriptc/types): written annotations, checked against + // the IR by the compile pipeline (contracts/check.ts). + const contracts = collectContractAnnotations(program.getTypeChecker(), moduleOrder); + timing("contract-annotations", { found: contracts.count }); + if (contracts.diagnostics.length > 0) + result = { + ...result, + module: null, + diagnostics: [...result.diagnostics, ...contracts.diagnostics], + }; + else if (contracts.count > 0) result = { ...result, contracts }; if (options.coverage !== true) return result; const remainder = new Lowerer(program, entry, moduleOrder, dynamic, { frontendServices: options.frontendServices, @@ -1883,6 +1899,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(); @@ -5690,6 +5710,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 @@ -6059,6 +6080,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. @@ -7043,6 +7065,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..577356fc6 --- /dev/null +++ b/packages/compiler/src/frontend/lowering/narrowing-stability.test.ts @@ -0,0 +1,155 @@ +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); +}); + +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 new file mode 100644 index 000000000..a1585a24b --- /dev/null +++ b/packages/compiler/src/frontend/lowering/narrowing-stability.ts @@ -0,0 +1,1194 @@ +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") { + if (!this.argumentSlotIsGeneric(node)) return null; + const contextual = checker.getContextualType(node); + if (contextual === undefined) return null; + if ( + !(contextual.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) && + !checker.isTypeAssignableTo(declared, contextual) + ) { + // 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; + } + + /** 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 { + 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, 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 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( + 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( + 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/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/src/frontend/type-mapper.ts b/packages/compiler/src/frontend/type-mapper.ts index 3d7f263b6..bbf2a8e07 100644 --- a/packages/compiler/src/frontend/type-mapper.ts +++ b/packages/compiler/src/frontend/type-mapper.ts @@ -1201,6 +1201,10 @@ function mapTypeInner(type: ts.Type, ctx: TypeMapperCtx): IrType | null { ) { return { kind: "object", className: "%Error" }; } + // Immutable (@scriptc/types) is a deep-readonly view: the value is + // still the T it maps. + const immutableSource = immutableSourceType(type, ctx); + if (immutableSource !== null) return mapType(immutableSource, ctx); if (resolveTypeParam && type.flags & ts.TypeFlags.TypeParameter) { const bound = resolveTypeParam(type); if (bound) { @@ -4534,6 +4538,43 @@ function mapBrandedPrimitiveIntersection(widened: ts.Type, ctx: TypeMapperCtx): return primitive && markerParts > 0 ? primitive : null; } +/** The declaration file of @scriptc/types (installed, pnpm-linked or the + * workspace package). */ +const CONTRACT_TYPES_FILE = /[\\/](?:@scriptc[\\/]types|packages[\\/]types)[\\/]index\.d\.ts$/; + +/** `Immutable` over a class, interface or object literal type resolves to + * a mapped type declared in @scriptc/types; TypeScript drops the alias, but + * homomorphic mapped members keep their original declarations. The source + * type is the non-generic declaration that declares every member (the most + * derived class or interface). Null for every other type. */ +function immutableSourceType(type: ts.Type, ctx: TypeMapperCtx): ts.Type | null { + if (!isMappedShape(type)) return null; + const { checker } = ctx; + const symbol = type.getSymbol(); + const decl = symbol ? checker.declarationsOf(symbol)[0] : undefined; + if (decl === undefined || !CONTRACT_TYPES_FILE.test(decl.getSourceFile().fileName)) return null; + const props = checker.getPropertiesOfType(type); + const seen = new Set(); + for (const prop of props) { + const owner = checker.declarationsOf(prop)[0]?.parent; + if (owner === undefined || seen.has(owner)) continue; + seen.add(owner); + let source: ts.Type | null = null; + if (ts.isTypeLiteralNode(owner)) source = checker.getTypeFromTypeNode(owner); + else if ( + (ts.isClassDeclaration(owner) || ts.isInterfaceDeclaration(owner)) && + owner.name !== undefined && + (owner.typeParameters?.length ?? 0) === 0 + ) { + const ownerSymbol = checker.getSymbolAtLocation(owner.name); + if (ownerSymbol) source = checker.getDeclaredTypeOfSymbol(ownerSymbol); + } + if (source !== null && checker.getPropertiesOfType(source).length === props.length) + return source; + } + return null; +} + /** True for MAPPED-type results — `Partial`, `Record<"a", n>`, * whatever `Pick`/`Omit` reduce to. Their shape is computed by the checker, * not declared anywhere: the only declaration behind them is the utility diff --git a/packages/compiler/src/ir/int32-slots.ts b/packages/compiler/src/ir/int32-slots.ts index 2baf80819..ffd6ae468 100644 --- a/packages/compiler/src/ir/int32-slots.ts +++ b/packages/compiler/src/ir/int32-slots.ts @@ -54,6 +54,14 @@ export class Int32Slots { readonly provenWrites = new Set(); /** Disqualified candidates and the first reason, for tests. */ readonly reasons = new Map(); + /** Slots an Int32 contract pins (`field:`, `param:`, `ret:`, `box:` keys): + * the contract check proved every write, so they are never dropped. */ + private readonly pinned = new Set(); + /** Int32 contract locals (`function\0localId`) and globals (`\0id`). */ + private readonly int32Locals = new Set(); + /** Drops the analysis attempted on pinned slots. The contract check and + * this analysis use the same range proofs, so this stays empty. */ + readonly pinViolations: string[] = []; constructor(private readonly classes: ReadonlyMap = new Map()) {} @@ -89,7 +97,8 @@ export class Int32Slots { this.fields.size === 0 && this.returns.size === 0 && this.paramFacts.size === 0 && - this.boxes.size === 0 + this.boxes.size === 0 && + this.int32Locals.size === 0 ) return {}; const result: IntegerSlotFacts = { @@ -97,6 +106,11 @@ export class Int32Slots { call: (callee) => (this.returns.has(callee) ? INT32_RANGE : null), boxed: (localId) => (this.hasBox(this.boxGroup(fnName, localId)) ? INT32_RANGE : null), }; + if (this.int32Locals.size > 0) + result.locals = (localId) => + this.int32Locals.has(`${fnName}\0${localId}`) || this.int32Locals.has(`\0${localId}`) + ? INT32_RANGE + : null; const params = this.paramFacts.get(fnName); if (params) result.params = params; return result; @@ -108,11 +122,27 @@ export class Int32Slots { /* ── construction (analyzeInt32Slots only) ── */ + pin(key: string): void { + this.pinned.add(key); + } + isPinnedField(family: string): boolean { + return this.pinned.has(`field:${family}`); + } + addInt32Local(key: string): void { + this.int32Locals.add(key); + } + private refusePinned(key: string): boolean { + if (!this.pinned.has(key)) return false; + this.pinViolations.push(key); + return true; + } + addBox(group: string, members: readonly string[]): void { this.boxes.add(group); for (const member of members) this.boxGroupOf.set(member, group); } dropBox(group: string): boolean { + if (this.refusePinned(`box:${group}`)) return false; return this.boxes.delete(group); } hasBox(group: string | null): boolean { @@ -123,6 +153,7 @@ export class Int32Slots { this.fields.add(family); } dropField(family: string): boolean { + if (this.refusePinned(`field:${family}`)) return false; return this.fields.delete(family); } hasFamily(family: string): boolean { @@ -134,6 +165,7 @@ export class Int32Slots { params.set(localId, INT32_RANGE); } dropParam(fnName: string, localId: string): boolean { + if (this.refusePinned(`param:${fnName}\0${localId}`)) return false; const params = this.paramFacts.get(fnName); if (!params?.delete(localId)) return false; if (params.size === 0) this.paramFacts.delete(fnName); @@ -146,6 +178,7 @@ export class Int32Slots { this.returns.add(fnName); } dropReturn(fnName: string): boolean { + if (this.refusePinned(`ret:${fnName}`)) return false; return this.returns.delete(fnName); } hasReturn(fnName: string): boolean { @@ -337,15 +370,12 @@ export function dynamicFieldStores( return { all: dynWritesAll, names: dynWritten }; } -export function analyzeInt32Slots(mod: IrModule): Int32Slots { +/** The f64 class field families a runtime store through a live dynamic view + * can write: the class reaches checked-dynamic code (directly or through + * another exposed type), and some dynamic store in the program can name the + * field. */ +export function dynamicallyStoredFamilies(mod: IrModule, slots: Int32Slots): Set { const classes = new Map((mod.classes ?? []).map((c) => [c.name, c])); - const slots = new Int32Slots(classes); - if (mod.lib) return slots; - const reason = (key: string, why: string): void => { - if (!slots.reasons.has(key)) slots.reasons.set(key, why); - }; - - /* ── candidate fields ── */ const children = new Map(); for (const cls of classes.values()) if (cls.base) { @@ -363,33 +393,6 @@ export function analyzeInt32Slots(mod: IrModule): Int32Slots { } return out; }; - const genericFamilies = new Set(); - for (const cls of classes.values()) - if (cls.genericOf !== undefined) { - genericFamilies.add(cls.name); - genericFamilies.add(cls.genericOf); - } - const plainClass = (cls: IrClassDef): boolean => { - for (let c: IrClassDef | undefined = cls; c; c = c.base ? classes.get(c.base) : undefined) { - if (c.runtime || genericFamilies.has(c.name)) return false; - if (c.base && !classes.has(c.base)) return false; - } - return true; - }; - const dropFamily = (family: string, why: string): void => { - reason(`field:${family}`, why); - slots.dropField(family); - }; - for (const cls of classes.values()) - for (const field of cls.fields) { - if (field.type.kind !== "f64" || field.name.startsWith("%")) continue; - const family = slots.family(cls.name, field.name)!; - if (plainClass(cls)) { - if (!slots.reasons.has(`field:${family}`)) slots.addField(family); - } else dropFamily(family, "runtime-provided or generic class"); - } - - /* ── dynamic, reflective and runtime exposure ── */ const records = new Map((mod.records ?? []).map((r) => [r.id, r])); const unions = new Map((mod.unions ?? []).map((u) => [u.id, u])); const exposedClasses = new Set(); @@ -463,6 +466,7 @@ export function analyzeInt32Slots(mod: IrModule): Int32Slots { if (s.kind === "throw") expose(s.value.type); }, }); + const families = new Set(); for (const cls of classes.values()) { if (!exposeAll && !exposedClasses.has(cls.name)) continue; for (const field of cls.fields) @@ -471,12 +475,27 @@ export function analyzeInt32Slots(mod: IrModule): Int32Slots { !field.name.startsWith("%") && (dynWritesAll || dynWritten.has(field.name)) ) - dropFamily(slots.family(cls.name, field.name)!, "dynamic stores can name the field"); + families.add(slots.family(cls.name, field.name)!); } + return families; +} - /* ── functions: escapes, parameter and return candidates ── */ +/** How functions can be reached besides direct calls: as values (closures, + * the entry, constructors behind class values: `valueEscaped`), through + * virtual dispatch (`virtualTargets`), or as vtable entries the runtime + * calls (`runtimeVirtual`: methods of runtime-rooted hierarchies). */ +export function functionCallFacts( + mod: IrModule, + classes: ReadonlyMap, + subtree: (className: string) => string[], +): { + valueEscaped: Set; + virtualTargets: Set; + runtimeVirtual: (name: string) => boolean; +} { const functions = new Map(mod.functions.map((fn) => [fn.name, fn])); const escaped = new Set(); + const virtualTargets = new Set(); const seenObjects = new Set(); const scan = ( value: unknown, @@ -520,9 +539,9 @@ export function analyzeInt32Slots(mod: IrModule): Int32Slots { walkFunction(fn, { expr: (e) => { if (e.kind !== "virtualCall") return; - for (const name of subtree(e.className)) escaped.add(`%${name}.${e.method}`); + for (const name of subtree(e.className)) virtualTargets.add(`%${name}.${e.method}`); for (let c = classes.get(e.className); c; c = c.base ? classes.get(c.base) : undefined) - escaped.add(`%${c.name}.${e.method}`); + virtualTargets.add(`%${c.name}.${e.method}`); }, }); // A class value can reach `new` through its construct thunk; one that @@ -563,8 +582,91 @@ export function analyzeInt32Slots(mod: IrModule): Int32Slots { if (e.kind === "classRef" && !testedOnly.has(e)) escaped.add(`%${e.className}.constructor`); }, }); - const virtual = (name: string): boolean => + const runtimeVirtual = (name: string): boolean => runtimePrefixes.some((prefix) => name.startsWith(prefix)); + return { valueEscaped: escaped, virtualTargets, runtimeVirtual }; +} + +export function analyzeInt32Slots(mod: IrModule): Int32Slots { + const classes = new Map((mod.classes ?? []).map((c) => [c.name, c])); + const slots = new Int32Slots(classes); + if (mod.lib) return slots; + const reason = (key: string, why: string): void => { + if (!slots.reasons.has(key)) slots.reasons.set(key, why); + }; + // Int32 contracts (ir/contract-check.ts proved every write): pinned + // candidates the fixpoint below never drops, plus local facts. + const contracts = mod.contracts; + for (const family of contracts?.int32Fields ?? []) { + slots.pin(`field:${family}`); + slots.addField(family); + } + for (const key of contracts?.int32Params ?? []) { + const cut = key.indexOf("\0"); + slots.pin(`param:${key}`); + slots.addParam(key.slice(0, cut), key.slice(cut + 1)); + } + for (const fnName of contracts?.int32Returns ?? []) { + slots.pin(`ret:${fnName}`); + slots.addReturn(fnName); + } + for (const key of contracts?.int32Locals ?? []) slots.addInt32Local(key); + + /* ── candidate fields ── */ + const children = new Map(); + for (const cls of classes.values()) + if (cls.base) { + const list = children.get(cls.base); + if (list) list.push(cls.name); + else children.set(cls.base, [cls.name]); + } + const subtree = (name: string): string[] => { + const out: string[] = []; + const stack = [name]; + while (stack.length) { + const next = stack.pop()!; + out.push(next); + for (const child of children.get(next) ?? []) stack.push(child); + } + return out; + }; + const genericFamilies = new Set(); + for (const cls of classes.values()) + if (cls.genericOf !== undefined) { + genericFamilies.add(cls.name); + genericFamilies.add(cls.genericOf); + } + const plainClass = (cls: IrClassDef): boolean => { + for (let c: IrClassDef | undefined = cls; c; c = c.base ? classes.get(c.base) : undefined) { + if (c.runtime || genericFamilies.has(c.name)) return false; + if (c.base && !classes.has(c.base)) return false; + } + return true; + }; + const dropFamily = (family: string, why: string): void => { + reason(`field:${family}`, why); + slots.dropField(family); + }; + for (const cls of classes.values()) + for (const field of cls.fields) { + if (field.type.kind !== "f64" || field.name.startsWith("%")) continue; + const family = slots.family(cls.name, field.name)!; + if (plainClass(cls)) { + if (!slots.reasons.has(`field:${family}`)) slots.addField(family); + } else dropFamily(family, "runtime-provided or generic class"); + } + + /* ── dynamic, reflective and runtime exposure ── */ + for (const family of dynamicallyStoredFamilies(mod, slots)) { + if (slots.isPinnedField(family)) continue; + dropFamily(family, "dynamic stores can name the field"); + } + + /* ── functions: escapes, parameter and return candidates ── */ + const functions = new Map(mod.functions.map((fn) => [fn.name, fn])); + const calls = functionCallFacts(mod, classes, subtree); + const escaped = new Set([...calls.valueEscaped, ...calls.virtualTargets]); + const virtual = calls.runtimeVirtual; const paramKey = (fnName: string, localId: string): string => `param:${fnName}\0${localId}`; const dropParam = (fnName: string, localId: string, why: string): boolean => { diff --git a/packages/compiler/src/ir/integer-ranges.ts b/packages/compiler/src/ir/integer-ranges.ts index 876f18c79..5e840bddf 100644 --- a/packages/compiler/src/ir/integer-ranges.ts +++ b/packages/compiler/src/ir/integer-ranges.ts @@ -76,6 +76,9 @@ export interface IntegerSlotFacts { field?: (className: string, field: string) => IntegerRange | null; call?: (callee: string) => IntegerRange | null; boxed?: (localId: string) => IntegerRange | null; + /** Locals and globals an Int32 contract covers (ir/contract-check.ts): + * every write anywhere is proven int32, so every read is one. */ + locals?: (localId: string) => IntegerRange | null; } /** Structured local dataflow. Calls cannot write uncaptured local slots, @@ -101,8 +104,10 @@ export function analyzeIntegerRanges(fn: IrFunction, slots: IntegerSlotFacts = { const loopLocals = new Map(fn.locals.filter((l) => !captures.has(l.id)).map((l) => [l.id, l])); // A captured binding has no local dataflow: only a proof that covers // every write of the shared box anywhere applies to its reads. - const boxedRange = (localId: string): IntegerRange | null => - eligible.has(localId) ? null : (slots.boxed?.(localId) ?? null); + const boxedRange = (localId: string): IntegerRange | null => { + const boxed = eligible.has(localId) ? null : (slots.boxed?.(localId) ?? null); + return boxed ?? slots.locals?.(localId) ?? null; + }; const slotRange = (e: IrExpr): IntegerRange | null => e.type.kind !== "f64" ? null @@ -292,7 +297,11 @@ export function analyzeIntegerRanges(fn: IrFunction, slots: IntegerSlotFacts = { ? { min: bound.value, max: bound.value } : ranges.get(bound); if (!boundRange) return; - const previous = facts.get(ref.localId); + // An Int32 contract local holds an int32 even where the dataflow has + // no fact for it (loop headers, after unknown regions). + const previous = + facts.get(ref.localId) ?? + (eligible.has(ref.localId) ? (slots.locals?.(ref.localId) ?? undefined) : undefined); if (!previous) return; if (!truth) op = @@ -584,8 +593,20 @@ export function analyzeIntegerRanges(fn: IrFunction, slots: IntegerSlotFacts = { if (s.cond) refine(s.cond, true, inside); body(s.body, inside); // Continue can bypass any body assignment. The update therefore - // starts from header invariants rather than the body's exit facts. - if (s.update) body([s.update], new Map(loop)); + // starts from header invariants rather than the body's exit facts, + // plus what the condition proved about bindings the body never + // writes (they still hold the values the condition tested). + if (s.update) { + const entry = new Map(loop); + if (s.cond) { + const refined = new Map(loop); + refine(s.cond, true, refined); + const written = new Set(); + for (const node of s.body) for (const id of writes(node)) written.add(id); + for (const [id, range] of refined) if (!written.has(id)) entry.set(id, range); + } + body([s.update], entry); + } havoc(facts, [s], facts); break; } diff --git a/packages/compiler/src/ir/ir.ts b/packages/compiler/src/ir/ir.ts index f7ac00459..4b687f438 100644 --- a/packages/compiler/src/ir/ir.ts +++ b/packages/compiler/src/ir/ir.ts @@ -983,6 +983,29 @@ export interface IrModule { * emissions stay conformance-identical by construction. Absent on every * executable build (the backends emit main() exactly as always). */ lib?: IrLibSection; + /** Contract types (@scriptc/types) the frontend verified against every + * write in the program (ir/contract-check.ts). Backends may rely on them + * unconditionally. Absent when the program writes no contract. */ + contracts?: IrContracts; +} + +/** Verified contract facts, keyed by IR names. */ +export interface IrContracts { + /** Int32 class field families: `${topmost declaring class}\0${field}`. */ + int32Fields?: string[]; + /** Int32 parameters: `${function}\0${localId}`. */ + int32Params?: string[]; + /** Functions whose every return is an int32. */ + int32Returns?: string[]; + /** Int32 locals (`${function}\0${localId}`, including every capture of a + * captured binding) and module globals (`\0${globalId}`). */ + int32Locals?: string[]; + /** Functions that cannot throw (NoThrow). */ + noThrow?: string[]; + /** Immutable module constants built from fresh literals: the backend + * makes their graphs immortal once initialized, and reads through them + * need no reference counting. */ + immortalGlobals?: string[]; } export type IrFfiValueParamClass = diff --git a/packages/compiler/src/ir/serialize.ts b/packages/compiler/src/ir/serialize.ts index 9455191d4..ade5c50f9 100644 --- a/packages/compiler/src/ir/serialize.ts +++ b/packages/compiler/src/ir/serialize.ts @@ -6,7 +6,7 @@ * already close to it). The compact encoding is therefore produced as ordered * text parts and decoded from bytes one function at a time; neither direction * materializes the complete document as a single string. */ -import type { IrFunction, IrModule } from "./ir.js"; +import type { IrExpr, IrFunction, IrModule, IrStmt } from "./ir.js"; // Version 15 expands the native Error prefix with filesystem metadata. // Older modules embed incompatible subclass offsets and must be rejected. @@ -99,6 +99,16 @@ export function deserializeModule(json: string): IrModule { return checkedVersion(JSON.parse(json, decodeNumber) as IrModule); } +/** A node as it reads back from the compact encoding: a fresh object, as + * is every node inside it. */ +export function reparseExpr(node: IrExpr): IrExpr { + return JSON.parse(JSON.stringify(node, encodeNumber), decodeNumber) as IrExpr; +} + +export function reparseStmt(node: IrStmt): IrStmt { + return JSON.parse(JSON.stringify(node, encodeNumber), decodeNumber) as IrStmt; +} + const QUOTE = 0x22; const BACKSLASH = 0x5c; const COMMA = 0x2c; diff --git a/packages/compiler/src/ir/unshare.test.ts b/packages/compiler/src/ir/unshare.test.ts new file mode 100644 index 000000000..d8a6346a8 --- /dev/null +++ b/packages/compiler/src/ir/unshare.test.ts @@ -0,0 +1,124 @@ +import { expect, test } from "vitest"; +import { emitLlvmModule } from "../backend/llvm/emitter.js"; +import { analyzeIntegerRanges } from "./integer-ranges.js"; +import { F64, VOID, type IrExpr, type IrModule, type IrStmt } from "./ir.js"; +import { deserializeModule, serializeModule } from "./serialize.js"; +import { everyStmtList } from "./traverse.js"; +import { unshareNodes } from "./unshare.js"; +import { validateModule } from "./validate.js"; + +const loc = { file: "unshare.ts", start: 0, end: 1 }; +const num = (value: number): IrExpr => ({ + kind: "numLit", + value, + type: F64, + loc, +}); +const add = (left: IrExpr, right: IrExpr): IrExpr => ({ + kind: "bin", + op: "+", + left, + right, + type: F64, + loc, +}); + +/** One varRef object read at two sites: `x` is unknown at the first and + * exactly 5 at the second, as lowering helpers that reuse a read produce; + * and one `p + 2` expression stored at two sites. */ +function sharedRead(): { mod: IrModule; read: IrExpr } { + const read: IrExpr = { kind: "varRef", localId: "x", type: F64, loc }; + const twice = add({ kind: "varRef", localId: "p", type: F64, loc }, num(2)); + const body: IrStmt[] = [ + { + kind: "varDecl", + localId: "x", + init: { kind: "varRef", localId: "p", type: F64, loc }, + loc, + }, + { kind: "varDecl", localId: "a", init: add(read, num(1)), loc }, + { kind: "assign", localId: "x", value: num(5), loc }, + { kind: "varDecl", localId: "b", init: add(read, num(1)), loc }, + // A repeated node with children: its leaves repeat with it. + { kind: "varDecl", localId: "c", init: twice, loc }, + { kind: "assign", localId: "c", value: twice, loc }, + { + kind: "return", + value: add( + { kind: "varRef", localId: "a", type: F64, loc }, + { + kind: "varRef", + localId: "b", + type: F64, + loc, + }, + ), + loc, + }, + ]; + const mod: IrModule = { + irVersion: 15, + sourceFile: loc.file, + entry: "main", + functions: [ + { name: "main", loc, params: [], locals: [], returnType: VOID, body: [] }, + { + name: "f", + loc, + params: [{ name: "p", localId: "p", type: F64 }], + locals: ["p", "x", "a", "b", "c"].map((id) => ({ + id, + name: id, + type: F64, + mutable: true, + })), + returnType: F64, + body, + }, + ], + }; + return { mod, read }; +} + +function nodes(mod: IrModule): (IrExpr | IrStmt)[] { + const out: (IrExpr | IrStmt)[] = []; + const visit = (node: IrExpr | IrStmt): boolean => (out.push(node), true); + for (const fn of mod.functions) everyStmtList(fn.body, { expr: visit, stmt: visit }); + return out; +} + +test("every occurrence gets its own node without mutating the input", () => { + const { mod, read } = sharedRead(); + const before = serializeModule(mod); + const tree = unshareNodes(mod); + expect(serializeModule(mod)).toBe(before); + expect(serializeModule(tree)).toBe(before); + const all = nodes(tree); + expect(new Set(all).size).toBe(all.length); + expect(all).not.toContain(read); + // The entry function had no shared node and is kept as it is. + expect(tree.functions[0]).toBe(mod.functions[0]); + expect(unshareNodes(tree)).toBe(tree); +}); + +test("ranges are per occurrence once nodes are unshared", () => { + const { mod, read } = sharedRead(); + // Keyed by identity, the shared read holds the join of both sites. + expect(analyzeIntegerRanges(mod.functions[1]!).get(read)).toBeNull(); + const fn = unshareNodes(mod).functions[1]!; + const reads = nodes({ ...mod, functions: [fn] }).filter( + (node) => node.kind === "varRef" && node.localId === "x", + ); + const ranges = analyzeIntegerRanges(fn); + expect(reads.map((node) => ranges.get(node as IrExpr) ?? null)).toEqual([ + null, + { min: 5, max: 5 }, + ]); +}); + +test("emission matches the module read back from its serialized form", () => { + const { mod } = sharedRead(); + expect(validateModule(mod)).toEqual([]); + const restored = deserializeModule(serializeModule(mod, true)); + expect(emitLlvmModule(mod)).toBe(emitLlvmModule(restored)); +}); diff --git a/packages/compiler/src/ir/unshare.ts b/packages/compiler/src/ir/unshare.ts new file mode 100644 index 000000000..36dd6176f --- /dev/null +++ b/packages/compiler/src/ir/unshare.ts @@ -0,0 +1,60 @@ +import type { IrExpr, IrFunction, IrModule, IrStmt } from "./ir.js"; +import { reparseExpr, reparseStmt } from "./serialize.js"; +import { everyExprChild, everyStmtChild, mapExprChildren, mapStmtChildren } from "./traverse.js"; + +/** Give every occurrence of an executable node its own object. + * + * Lowering helpers may place one node at several sites (a binding's varRef + * read in a loop condition and in its body, a shared `break`). Analyses key + * their facts by node identity (integer ranges, int32 write proofs, borrow + * and lifetime facts), so a shared node carries one fact for all of its + * sites: integer ranges keep the join, which loses what one site proves. A + * serialized module gives every occurrence its own node; this makes the + * in-memory module equivalent, so analyses and emission behave the same on + * a module lowered in memory and on one read back from its artifact. + * Functions without a repeated node are kept as they are; the input is + * never mutated. */ +export function unshareNodes(mod: IrModule): IrModule { + const seen = new Set(); + const repeated = new Set(); + const affected = new Set(); + let current: IrFunction | null = null; + // A repeated node marks the function holding the later occurrence. Its + // subtree is walked again, so every node under it is repeated as well. + const visit = (node: IrExpr | IrStmt): void => { + if (!seen.has(node)) seen.add(node); + else { + repeated.add(node); + affected.add(current!); + } + }; + const findExpr = (node: IrExpr): boolean => { + visit(node); + return everyExprChild(node, findExpr, findStmt); + }; + const findStmt = (node: IrStmt): boolean => { + visit(node); + return everyStmtChild(node, findExpr, findStmt); + }; + for (const fn of mod.functions) { + current = fn; + for (const node of fn.body) findStmt(node); + } + if (affected.size === 0) return mod; + // Rebuilding a function copies every node that has children; a repeated + // childless node reads back as a fresh object at each of its sites there. + const expr = (node: IrExpr): IrExpr => { + const copy = mapExprChildren(node, expr, stmt); + return copy !== node || !repeated.has(node) ? copy : reparseExpr(node); + }; + const stmt = (node: IrStmt): IrStmt => { + const copy = mapStmtChildren(node, expr, stmt); + return copy !== node || !repeated.has(node) ? copy : reparseStmt(node); + }; + return { + ...mod, + functions: mod.functions.map((fn) => + affected.has(fn) ? { ...fn, body: fn.body.map(stmt) } : fn, + ), + }; +} diff --git a/packages/compiler/src/library/prepare.ts b/packages/compiler/src/library/prepare.ts index fbd04bb95..88106433c 100644 --- a/packages/compiler/src/library/prepare.ts +++ b/packages/compiler/src/library/prepare.ts @@ -55,6 +55,7 @@ import { } from "../ir/ir.js"; import { moduleLibAsyncSurface, moduleLibNondeterministicSurface } from "./ir-policy.js"; import { validateModule } from "../ir/validate.js"; +import { checkContracts } from "../contracts/check.js"; /** The marshalling-class fit over IR types (design §4.2 + the ratified * integer plumbing classes): number is every f64-backed class, bool/string @@ -609,6 +610,12 @@ export function prepareLibrary( const fenced = evaluateLibraryFences(mod, profile); if (fenced.length > 0) return fail(fenced); mod.lib = resolved.lib; + if (lowered.contracts) { + const checked = checkContracts(mod, lowered.contracts, sourceTexts); + timing("contracts"); + if (checked.diagnostics.length > 0) return fail(checked.diagnostics); + if (checked.contracts) mod.contracts = checked.contracts; + } if (buildPlatform === "wasi") { fenceSpeculativeWasiFunctions(mod); const unavailable = moduleWasiUnavailableSurface(mod); diff --git a/packages/compiler/test/bytes-element-emission.test.ts b/packages/compiler/test/bytes-element-emission.test.ts index 08da691ee..80e3e0ecb 100644 --- a/packages/compiler/test/bytes-element-emission.test.ts +++ b/packages/compiler/test/bytes-element-emission.test.ts @@ -314,7 +314,10 @@ test("canonical byte loops keep their induction variable and indices integral", expect(ll).toContain("alloca i64 ; integer induction index"); expect(ll).toContain("icmp ult i64"); - expect(ll).not.toContain("bytes.index.valid"); + // The proven in-bounds index needs no element check at all. Do not assert + // on `fptosi double` here: the fixture's inline ToUint32 coercion of the + // running sum legitimately uses it. + expect(ll).not.toContain("bytes.index"); }); test("a body mutation keeps the byte loop on the general f64 path", () => { diff --git a/packages/compiler/test/call-lifetimes.test.ts b/packages/compiler/test/call-lifetimes.test.ts index dde71c67c..646e901c9 100644 --- a/packages/compiler/test/call-lifetimes.test.ts +++ b/packages/compiler/test/call-lifetimes.test.ts @@ -329,11 +329,15 @@ console.log(alias(new Item()).value, snapshot(new Item()).value); // The rebound parameter keeps borrowing (its new value lives in an owner // slot), but the alias saved before the rebinding must own its value. // `new Item()` calls the borrowed constructor body, so no retain transfers - // the fresh instance into it: the saved alias and the returned value. + // the fresh instance into it. The saved alias retains once, and `return + // saved` moves that owned scope entry into the result instead of retaining + // it again and releasing the local at scope exit: the only releases are the + // rebound parameter's owner slot (before the store and at exit). const snapshot = body(llvm, "sc_bf_snapshot"); - expect(snapshot.match(/@sc_retain_Item/g)).toHaveLength(2); + expect(snapshot.match(/@sc_retain_Item/g)).toHaveLength(1); expect(snapshot).toContain("@sc_bf__x25_Item_constructor"); - expect(snapshot).toContain("@sc_release_Item"); + expect(snapshot.match(/@sc_release_Item/g)).toHaveLength(2); + expect(snapshot).toMatch(/(%t\d+) = load ptr, ptr %sc_l_saved_0\n[^]*ret ptr \1\n/); }); test("unchanged captured parameters are boxed when a closure first needs them", async () => { diff --git a/packages/compiler/test/native-codegen-integration.test.ts b/packages/compiler/test/native-codegen-integration.test.ts index d85579558..49fd801b6 100644 --- a/packages/compiler/test/native-codegen-integration.test.ts +++ b/packages/compiler/test/native-codegen-integration.test.ts @@ -312,7 +312,7 @@ ${[0, 1, 2, 3, 4, 5].map((index) => ` call void @add${index}(i64 ${index + 2})` expect(await symbols(helperObject, ["-u"])).toEqual(await symbols(clangObject, ["-u"])); expect(await symbols(helperObject, ["-gU"])).toEqual(await symbols(clangObject, ["-gU"])); expect(await symbols(helperObject, ["-gU"])).toEqual(["0000000000000000 T _main"]); - expect(await symbols(helperObject, ["-u"])).toContain("_scr_runtime_abi_v12"); + expect(await symbols(helperObject, ["-u"])).toContain("_scr_runtime_abi_v13"); const clangExe = join(dir, "clang-program"); const linkDriver = join(dir, "clang-driver.c"); @@ -646,7 +646,7 @@ ${[0, 1, 2, 3, 4, 5].map((index) => ` call void @add${index}(i64 ${index + 2})` .split("\n"); expect(undefinedSymbols).toContain("_sf_scale"); expect(undefinedSymbols).toContain("_sf_callback_mix"); - expect(undefinedSymbols).toContain("_scr_runtime_abi_v12"); + expect(undefinedSymbols).toContain("_scr_runtime_abi_v13"); }); test("helper and clang object paths retain the same outbound FFI C ABI", async () => { diff --git a/packages/compiler/test/string-and-array-lifetimes.test.ts b/packages/compiler/test/string-and-array-lifetimes.test.ts index 4f59d8bbc..183a1a426 100644 --- a/packages/compiler/test/string-and-array-lifetimes.test.ts +++ b/packages/compiler/test/string-and-array-lifetimes.test.ts @@ -217,15 +217,39 @@ test("a throwing later source argument releases the retained snapshot on its exc const module = await lower(` class Item { value = 7; } function read(item: Item, ignored: number): number { return item.value + ignored; } +function fail(items: Item[]): number { items.pop(); throw new Error("failed"); } +function work(items: Item[]): number { return read(items[0], fail(items)); } +try { console.log(work([new Item()])); } catch {} +`); + // The later argument removes the element, so the snapshot must own it. + const work = body(emitLlvmModule(module), "sc_bf_work"); + const failure = work.indexOf("@sc_bf_fail"); + expect(failure).toBeGreaterThan(0); + expect(work.slice(0, failure)).toContain("@sc_retain_Item"); + expect(work.slice(failure)).toMatch(PENDING_CHECK); + const exceptionEdge = work.slice(failure, work.indexOf("@sc_bf_read")); + expect(exceptionEdge).toContain("@sc_release_Item"); + expect(work).not.toContain("@scr_union_release"); +}); + +test("a throwing later source argument that writes no element leaves the snapshot borrowed", async () => { + const module = await lower(` +class Item { value = 7; } +function read(item: Item, ignored: number): number { return item.value + ignored; } function fail(): number { throw new Error("failed"); } function work(items: Item[]): number { return read(items[0], fail()); } try { console.log(work([new Item()])); } catch {} `); + // Neither the callee nor the later argument writes an array element (the + // Error constructor's stores into its own fresh object do not count), so + // the borrowed parameter's array keeps the element alive and no edge, + // normal or exceptional, owes a release. const work = body(emitLlvmModule(module), "sc_bf_work"); const failure = work.indexOf("@sc_f_fail"); expect(failure).toBeGreaterThan(0); expect(work.slice(failure)).toMatch(PENDING_CHECK); - expect(work.slice(failure)).toContain("@sc_release_Item"); + expect(work).not.toContain("@sc_retain_Item"); + expect(work).not.toContain("@sc_release_Item"); expect(work).not.toContain("@scr_union_release"); }); 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 2c3a31530..000000000 --- a/packages/compiler/test/ts7/baselines/order-parity.json +++ /dev/null @@ -1,15894 +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-nan-coded-reads.ts": { - "order": [ - "/tests/corpus/typed-array-nan-coded-reads.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/4598-live-array-ref-element-access.ts": { - "order": [ - "/tests/corpus/4598-live-array-ref-element-access.ts" - ], - "diags": [] - }, - "/tests/corpus/native-worker-arena-reuse.ts": { - "order": [ - "/tests/corpus/native-worker-arena-reuse.ts" - ], - "diags": [] - }, - "/tests/corpus/4596-tdz-nullable-forward-capture.ts": { - "order": [ - "/tests/corpus/4596-tdz-nullable-forward-capture.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/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-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/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/string-char-code-integer-loops.ts": { - "order": [ - "/tests/corpus/string-char-code-integer-loops.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/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/4671-scoped-array-read-borrows.ts": { - "order": [ - "/tests/corpus/4671-scoped-array-read-borrows.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/4598-publish-constructor-stores.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4598-publish-constructor-stores.ts.json new file mode 100644 index 000000000..7852d2bf5 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4598-publish-constructor-stores.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4598-publish-constructor-stores.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4599-construction-only-field-borrows.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4599-construction-only-field-borrows.ts.json new file mode 100644 index 000000000..032d5a0c1 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4599-construction-only-field-borrows.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4599-construction-only-field-borrows.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4600-construction-only-fields-dynamic-writes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4600-construction-only-fields-dynamic-writes.ts.json new file mode 100644 index 000000000..3d60affd3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4600-construction-only-fields-dynamic-writes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4600-construction-only-fields-dynamic-writes.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/4630-contract-int32.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4630-contract-int32.ts.json new file mode 100644 index 000000000..7015d87d3 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4630-contract-int32.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4630-contract-int32.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4630-reference-write-call-arguments.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4630-reference-write-call-arguments.ts.json new file mode 100644 index 000000000..150de69d4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4630-reference-write-call-arguments.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4630-reference-write-call-arguments.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4631-contract-nothrow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4631-contract-nothrow.ts.json new file mode 100644 index 000000000..7fa843eb8 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4631-contract-nothrow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4631-contract-nothrow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4631-reference-write-aliases.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4631-reference-write-aliases.ts.json new file mode 100644 index 000000000..1a3ec8157 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4631-reference-write-aliases.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4631-reference-write-aliases.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4632-contract-immutable.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4632-contract-immutable.ts.json new file mode 100644 index 000000000..80cbcaeae --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4632-contract-immutable.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4632-contract-immutable.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4632-reference-write-loops-and-walks.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4632-reference-write-loops-and-walks.ts.json new file mode 100644 index 000000000..01069d0c0 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4632-reference-write-loops-and-walks.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4632-reference-write-loops-and-walks.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4633-reference-write-callbacks-returns.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4633-reference-write-callbacks-returns.ts.json new file mode 100644 index 000000000..baa78ce49 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4633-reference-write-callbacks-returns.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4633-reference-write-callbacks-returns.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4634-optional-element-borrowed-returns.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4634-optional-element-borrowed-returns.ts.json new file mode 100644 index 000000000..8260148ce --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4634-optional-element-borrowed-returns.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4634-optional-element-borrowed-returns.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/4691-publish-constructor-self-alias.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4691-publish-constructor-self-alias.ts.json new file mode 100644 index 000000000..15f8fea3c --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4691-publish-constructor-self-alias.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4691-publish-constructor-self-alias.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4692-borrowed-result-mutating-callees.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4692-borrowed-result-mutating-callees.ts.json new file mode 100644 index 000000000..af24efa51 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/4692-borrowed-result-mutating-callees.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/4692-borrowed-result-mutating-callees.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-char-code-integer-loops.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-char-code-integer-loops.ts.json new file mode 100644 index 000000000..f6a4a62d4 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/corpus/string-char-code-integer-loops.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/corpus/string-char-code-integer-loops.ts" + ], + "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/contract-immutable.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/contract-immutable.ts.json new file mode 100644 index 000000000..b0b7fb5cf --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/contract-immutable.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/contract-immutable.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/contract-int32-escapes.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/contract-int32-escapes.ts.json new file mode 100644 index 000000000..6599c31dd --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/contract-int32-escapes.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/contract-int32-escapes.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/contract-int32.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/contract-int32.ts.json new file mode 100644 index 000000000..e2fd8f354 --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/contract-int32.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/contract-int32.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/contract-nothrow.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/contract-nothrow.ts.json new file mode 100644 index 000000000..8be0da8bb --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/contract-nothrow.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/contract-nothrow.ts" + ], + "diags": [] +} diff --git a/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/contract-positions.ts.json b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/contract-positions.ts.json new file mode 100644 index 000000000..40073027d --- /dev/null +++ b/packages/compiler/test/ts7/baselines/order-parity/tests/diagnostics/contract-positions.ts.json @@ -0,0 +1,6 @@ +{ + "order": [ + "/tests/diagnostics/contract-positions.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/packages/runtime-darwin-arm64/scripts/build.mjs b/packages/runtime-darwin-arm64/scripts/build.mjs index b062b5980..45a96f84e 100644 --- a/packages/runtime-darwin-arm64/scripts/build.mjs +++ b/packages/runtime-darwin-arm64/scripts/build.mjs @@ -316,7 +316,7 @@ async function build() { package: packageManifest.name, version: packageManifest.version, target: RUNTIME_PACK_MATRIX.target, - runtime_abi: { version: 12, marker: "scr_runtime_abi_v12" }, + runtime_abi: { version: 13, marker: "scr_runtime_abi_v13" }, compiler: { command: compiler, identity: compilerVersion, diff --git a/packages/runtime-pack-common/scripts/build.mjs b/packages/runtime-pack-common/scripts/build.mjs index e0752938e..74f1a12ee 100644 --- a/packages/runtime-pack-common/scripts/build.mjs +++ b/packages/runtime-pack-common/scripts/build.mjs @@ -403,7 +403,7 @@ async function build() { package: packageManifest.name, version: packageManifest.version, target: matrix.target, - runtime_abi: { version: 12, marker: "scr_runtime_abi_v12" }, + runtime_abi: { version: 13, marker: "scr_runtime_abi_v13" }, compiler: { command: compiler, identity: compilerVersion, diff --git a/packages/runtime/src/scr_alloc.c b/packages/runtime/src/scr_alloc.c index 32352d9dd..f713f6127 100644 --- a/packages/runtime/src/scr_alloc.c +++ b/packages/runtime/src/scr_alloc.c @@ -67,13 +67,232 @@ static void *scr_sa_map(size_t span) { return p; } +/* Pre-faulting (Linux executables). First touch of a fresh slice page costs + * a fault and a page clear on the allocating thread. With pre-faulting the + * bump limits advance in steps, and each step asks a helper thread to fault + * in the memory just ahead of it (MADV_POPULATE_WRITE: the kernel commits + * zeroed pages as for a write, without storing anything, so it cannot race + * with the owner's carving). The owner still faults any page the helper has + * not reached; the fast paths are unchanged. Small-page prefixes advance in + * SCR_SA_PF_STEP chunks and fault one chunk ahead; huge-page ranges advance + * in half huge pages and fault the next huge page once the bump is in the + * second half of the current one, so a slice keeps at most about one step + * of untouched committed memory. Nothing is faulted ahead before a slice + * reaches SCR_SA_PF_START: a lightly used class commits nothing extra. + * SCR_SA_PREFAULT=0 turns it off. Library archives run on embedder threads + * and keep the plain policy. */ +#if defined(SCR_SA_THP) && !defined(SCR_LIB) +#ifndef MADV_POPULATE_WRITE +#define MADV_POPULATE_WRITE 23 /* Linux 5.14 */ +#endif +#define SCR_SA_PREFAULT 1 +#define SCR_SA_PF_STEP ((size_t)256 << 10) +#define SCR_SA_PF_START ((size_t)1 << 20) +#define SCR_SA_PF_HUGE_STEP (SCR_SA_HUGE_PAGE / 2) +#include +#include +#include +#include + +typedef struct { + char *lo, *hi; +} ScrSaPfRange; +#define SCR_SA_PF_RING 64u +static pthread_mutex_t scr_sa_pf_lock = PTHREAD_MUTEX_INITIALIZER; +static pthread_cond_t scr_sa_pf_cond = PTHREAD_COND_INITIALIZER; +static ScrSaPfRange scr_sa_pf_ring[SCR_SA_PF_RING]; +static unsigned scr_sa_pf_head, scr_sa_pf_tail; /* under the lock */ +static bool scr_sa_pf_started, scr_sa_pf_waiting; +/* 0 = not decided yet, 1 = on, -1 = off (environment, no thread, or a + * kernel without MADV_POPULATE_WRITE). */ +static _Atomic(int) scr_sa_pf_state; + +static void scr_sa_pf_populate(char *lo, char *hi) { + if (madvise(lo, (size_t)(hi - lo), MADV_POPULATE_WRITE) != 0 && errno == EINVAL) + atomic_store_explicit(&scr_sa_pf_state, -1, memory_order_relaxed); +} + +/* The system allocator's heap (glibc): blocks above SCR_SA_MAX come from + * malloc, whose main arena grows by brk. Once the heap has grown by + * SCR_SA_PF_HEAP_MIN since the helper first looked, the helper gives malloc + * a larger top pad (SCR_SA_PF_TOP_PAD), so every extension runs that far + * ahead of use, and faults in each new extension as soon as it sees the + * break move. Smaller heaps keep glibc's defaults (a top pad also fixes + * glibc's otherwise dynamic mmap threshold), so a small program commits + * nothing extra. The helper checks after every request and then polls while + * the program keeps allocating (SCR_SA_PF_POLL_NS, up to SCR_SA_PF_POLLS + * times without growth before it sleeps until the next request), so an idle + * program does not wake it. Only the helper reads the break; a stale read + * only delays a fault-in, and a shrunk break (malloc trimming its top) + * restarts the watermarks there. Past the threshold the pad costs at most + * SCR_SA_PF_TOP_PAD of committed memory beyond what malloc would have; + * SCR_SA_PREFAULT_HEAP=0 keeps glibc's defaults and no polling. */ +#if defined(__GLIBC__) +#include +#include +#include +#define SCR_SA_PF_HEAP 1 +#define SCR_SA_PF_HEAP_MIN ((size_t)32 << 20) +#define SCR_SA_PF_TOP_PAD ((size_t)16 << 20) +#define SCR_SA_PF_POLL_NS 1000000L +#define SCR_SA_PF_POLLS 64u +static int scr_sa_pf_heap_mode; /* 0 off, 1 on; decided before the helper starts */ +static uintptr_t scr_sa_pf_page; /* likewise */ +static char *scr_sa_pf_brk0, *scr_sa_pf_brk; /* helper only: first and last break seen */ +static bool scr_sa_pf_heap_big; /* helper only: past SCR_SA_PF_HEAP_MIN */ + +/* Faults in the heap's growth since the last check; true if it grew. */ +static bool scr_sa_pf_heap(void) { + char *cur = sbrk(0); + if (cur == (char *)-1) return false; + char *seen = scr_sa_pf_brk; + scr_sa_pf_brk = cur; + if (!seen || cur < scr_sa_pf_brk0) scr_sa_pf_brk0 = cur; + if (!seen || cur <= seen) return false; + if (!scr_sa_pf_heap_big) { + if ((size_t)(cur - scr_sa_pf_brk0) < SCR_SA_PF_HEAP_MIN) return true; + scr_sa_pf_heap_big = true; + (void)mallopt(M_TOP_PAD, (int)SCR_SA_PF_TOP_PAD); + } + scr_sa_pf_populate((char *)((uintptr_t)seen & ~(scr_sa_pf_page - 1)), cur); + return true; +} +#endif + +static void *scr_sa_pf_main(void *arg) { + (void)arg; +#ifdef SCR_SA_PF_HEAP + unsigned idle = SCR_SA_PF_POLLS; +#endif + pthread_mutex_lock(&scr_sa_pf_lock); + for (;;) { + while (scr_sa_pf_head == scr_sa_pf_tail) { + scr_sa_pf_waiting = true; +#ifdef SCR_SA_PF_HEAP + if (scr_sa_pf_heap_mode && idle < SCR_SA_PF_POLLS) { + struct timespec t; + clock_gettime(CLOCK_MONOTONIC, &t); + t.tv_nsec += SCR_SA_PF_POLL_NS; + if (t.tv_nsec >= 1000000000L) { + t.tv_sec++; + t.tv_nsec -= 1000000000L; + } + int rc = pthread_cond_timedwait(&scr_sa_pf_cond, &scr_sa_pf_lock, &t); + scr_sa_pf_waiting = false; + if (rc != 0 && scr_sa_pf_head == scr_sa_pf_tail) { + pthread_mutex_unlock(&scr_sa_pf_lock); + idle = scr_sa_pf_heap() ? 0 : idle + 1; + pthread_mutex_lock(&scr_sa_pf_lock); + } + continue; + } +#endif + pthread_cond_wait(&scr_sa_pf_cond, &scr_sa_pf_lock); + scr_sa_pf_waiting = false; + } + ScrSaPfRange r = scr_sa_pf_ring[scr_sa_pf_tail++ % SCR_SA_PF_RING]; + pthread_mutex_unlock(&scr_sa_pf_lock); + scr_sa_pf_populate(r.lo, r.hi); +#ifdef SCR_SA_PF_HEAP + if (scr_sa_pf_heap_mode) { + (void)scr_sa_pf_heap(); + idle = 0; + } +#endif + pthread_mutex_lock(&scr_sa_pf_lock); + } + return NULL; +} + +static bool scr_sa_pf_on(void) { + int s = atomic_load_explicit(&scr_sa_pf_state, memory_order_relaxed); + if (s == 0) { + const char *v = getenv("SCR_SA_PREFAULT"); + s = v && v[0] == '0' ? -1 : 1; + atomic_store_explicit(&scr_sa_pf_state, s, memory_order_relaxed); + } + return s > 0; +} + +/* Asks the helper to fault in [lo, hi) (page aligned). Dropped when the + * ring is full: the owner then faults those pages itself. */ +static void scr_sa_prefault(char *lo, char *hi) { + if (hi <= lo || !scr_sa_pf_on()) return; + pthread_mutex_lock(&scr_sa_pf_lock); + if (!scr_sa_pf_started) { + scr_sa_pf_started = true; +#ifdef SCR_SA_PF_HEAP + /* Nobody waits on the condition yet: give it the monotonic clock for + * the helper's polls (no polls without it). */ + const char *v = getenv("SCR_SA_PREFAULT_HEAP"); + long page = sysconf(_SC_PAGESIZE); + pthread_condattr_t ca; + if (!(v && v[0] == '0') && page > 0 && pthread_condattr_init(&ca) == 0) { + if (pthread_condattr_setclock(&ca, CLOCK_MONOTONIC) == 0) { + pthread_cond_destroy(&scr_sa_pf_cond); + pthread_cond_init(&scr_sa_pf_cond, &ca); + scr_sa_pf_page = (uintptr_t)page; + scr_sa_pf_heap_mode = 1; + } + pthread_condattr_destroy(&ca); + } +#endif + /* The helper takes no signals: they stay with the program's threads. */ + pthread_attr_t attr; + pthread_t helper; + sigset_t all, old; + sigfillset(&all); + bool ok = pthread_attr_init(&attr) == 0; + if (ok) { + bool masked = pthread_sigmask(SIG_SETMASK, &all, &old) == 0; + ok = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) == 0 && + pthread_attr_setstacksize(&attr, (size_t)64 << 10) == 0 && + pthread_create(&helper, &attr, scr_sa_pf_main, NULL) == 0; + if (masked) (void)pthread_sigmask(SIG_SETMASK, &old, NULL); + pthread_attr_destroy(&attr); + } + if (!ok) atomic_store_explicit(&scr_sa_pf_state, -1, memory_order_relaxed); + } + if (atomic_load_explicit(&scr_sa_pf_state, memory_order_relaxed) > 0 && + scr_sa_pf_head - scr_sa_pf_tail < SCR_SA_PF_RING) { + scr_sa_pf_ring[scr_sa_pf_head++ % SCR_SA_PF_RING] = (ScrSaPfRange){lo, hi}; + if (scr_sa_pf_waiting) pthread_cond_signal(&scr_sa_pf_cond); + } + pthread_mutex_unlock(&scr_sa_pf_lock); +} +#endif + /* The next bump limit of a class slice [start, end) whose limit is lim * (< end): its small-page prefix ends at SCR_SA_HUGE_AFTER, where the rest - * of the slice switches to huge pages. */ + * of the slice switches to huge pages. With pre-faulting, limits advance in + * steps (see above). */ static char *scr_sa_extend(char *start, char *lim, char *end) { #ifdef SCR_SA_THP - if ((size_t)(lim - start) < SCR_SA_HUGE_AFTER && (size_t)(end - start) > SCR_SA_HUGE_AFTER) - return start + SCR_SA_HUGE_AFTER; + char *sw = start + SCR_SA_HUGE_AFTER; + bool tiered = (size_t)(end - start) > SCR_SA_HUGE_AFTER; +#ifdef SCR_SA_PREFAULT + if (scr_sa_pf_on()) { + if (!tiered) return end; + if (lim < sw) { + char *next = lim + SCR_SA_PF_STEP < sw ? lim + SCR_SA_PF_STEP : sw; + if (next == sw) { + /* The last small-page chunk: switch the rest now, so the first huge + * page can be faulted ahead like every later one. */ + (void)madvise(sw, (size_t)(end - sw), MADV_HUGEPAGE); + scr_sa_prefault(sw, sw + SCR_SA_HUGE_PAGE < end ? sw + SCR_SA_HUGE_PAGE : end); + } else if ((size_t)(next - start) >= SCR_SA_PF_START) { + scr_sa_prefault(next, next + SCR_SA_PF_STEP < sw ? next + SCR_SA_PF_STEP : sw); + } + return next; + } + char *next = lim + SCR_SA_PF_HUGE_STEP < end ? lim + SCR_SA_PF_HUGE_STEP : end; + /* Entering the second half of a huge page: fault the next one. */ + if (((uintptr_t)next & (SCR_SA_HUGE_PAGE - 1)) == 0 && next < end) + scr_sa_prefault(next, next + SCR_SA_HUGE_PAGE < end ? next + SCR_SA_HUGE_PAGE : end); + return next; + } +#endif + if ((size_t)(lim - start) < SCR_SA_HUGE_AFTER && tiered) return sw; if (lim > start) (void)madvise(lim, (size_t)(end - lim), MADV_HUGEPAGE); #else (void)start; @@ -82,6 +301,111 @@ 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 */ +/* The page size is stored before scr_sa_heap_lo is published (the CAS is a + * release), and every thread loads scr_sa_heap_lo, then scr_sa_heap_hi, with + * acquire before reading it; each scr_sa_heap_hi update is an RMW by a thread + * that already sees it, so any thread that wins the advice CAS sees a nonzero + * page size. A zero read still skips the advice rather than align to 0. + * These loads run only on blocks too large for the small allocator, next to + * a glibc malloc call: plain loads on x86-64, LDAR (or LDAPR) on arm64. */ + +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_acquire); + 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_acquire); + 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 page = atomic_load_explicit(&scr_sa_heap_page, memory_order_relaxed); + if (page) { + uintptr_t from = hi & ~(page - 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 +871,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 +886,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..58b9da0b8 100644 --- a/packages/runtime/src/scr_alloc.test.c +++ b/packages/runtime/src/scr_alloc.test.c @@ -121,20 +121,24 @@ static void vm_flags(const void *p, char *out, size_t cap) { } #endif -/* A class slice carves contiguously from its start, across the point where +/* A class slice carves contiguously from its start, across the points where * its limit is raised; on Linux the slices are huge-page aligned, the first - * 8 MiB of a slice stay on small pages and the rest may use huge pages. */ + * 8 MiB of a slice stay on small pages and the rest may use huge pages, and + * a helper thread faults in memory ahead of the limit. Every fresh block + * still reads as zero, wherever the limit steps and whoever faulted it. */ static void check_slice_growth(void) { - enum { SZ = 496, AFTER = 8 << 20 }; + enum { SZ = 496, AFTER = 8 << 20, PAST = 3 * (2 << 20) + (1 << 20) }; unsigned char *first = scr_mem_alloc(SZ), *prev = first; assert(owned(first)); uintptr_t start = scr_sa.base + ((uintptr_t)((SZ - 1) / SCR_SA_STEP) << scr_sa.shift); assert((uintptr_t)first == start); /* a class nothing else has touched */ - size_t blocks = AFTER / SZ + 64; + size_t blocks = (AFTER + PAST) / SZ; for (size_t i = 1; i < blocks; i++) { unsigned char *p = scr_mem_alloc(SZ); assert(p == prev + SZ); + for (size_t k = 0; k < SZ; k += 16) assert(p[k] == 0); p[0] = (unsigned char)i; /* commit the pages */ + p[SZ - 1] = (unsigned char)i; prev = p; } #ifdef __linux__ @@ -154,6 +158,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 +348,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__ diff --git a/packages/runtime/src/scr_array.c b/packages/runtime/src/scr_array.c index 8a419e8ee..6cf69bed8 100644 --- a/packages/runtime/src/scr_array.c +++ b/packages/runtime/src/scr_array.c @@ -132,7 +132,7 @@ static void scr_elem_release(const ScrArr *a, uint64_t slot) { if (a->elem == SCR_ELEM_STR) scr_str_release((ScrStr *)p); else if (a->elem == SCR_ELEM_ARR) scr_arr_release((ScrArr *)p); else if (a->elem == SCR_ELEM_BYTES) scr_bytes_release((ScrBytes *)p); - else if (a->elem == SCR_ELEM_REF) a->elem_release(p); + else if (a->elem == SCR_ELEM_REF) a->ops->release(p); } static uint64_t scr_elem_retain_slot(const ScrArr *a, uint64_t slot) { @@ -142,7 +142,7 @@ static uint64_t scr_elem_retain_slot(const ScrArr *a, uint64_t slot) { if (a->elem == SCR_ELEM_STR) p = scr_str_retain((ScrStr *)p); else if (a->elem == SCR_ELEM_ARR) p = scr_arr_retain((ScrArr *)p); else if (a->elem == SCR_ELEM_BYTES) p = scr_bytes_retain((ScrBytes *)p); - else p = a->elem_retain(p); + else p = a->ops->retain(p); return scr_slot_from_ptr(p); } @@ -275,33 +275,77 @@ static void scr_arr_sparse_drop_prefix(ScrArr *a, size_t count) { x->sparse_len -= count; } +/* Bytes per dense slot: the 8-byte value and its state byte. */ +#define SCR_ARR_SLOT_BYTES (sizeof(uint64_t) + sizeof(uint8_t)) +/* Appends to an array smaller than this grow straight to it. */ +#define SCR_ARR_MIN_GROWTH ((size_t)4) + +/* How a dense allocation is sized. */ +typedef enum { + SCR_ARR_GROW_APPEND, /* geometric headroom for further appends */ + SCR_ARR_GROW_SPAN, /* a densified sparse tail: exact above the cutoff */ + SCR_ARR_GROW_EXACT, /* construction with a known element count */ +} ScrArrGrow; + +/* The small-object allocator rounds blocks up to SCR_SA_STEP bytes, so an + * exactly sized array can use the whole block for slots: a one-element + * literal keeps a 16-byte block rather than reserving 4 slots in a 48-byte + * one. Growth keeps its own sequence (4, 8, 16, ...): rounding it as well + * moves array storage into other size classes and measured slower. */ +static size_t scr_arr_block_cap(size_t cap) { +#if SCR_SMALL_ALLOC + size_t bytes = cap * SCR_ARR_SLOT_BYTES; + if (bytes <= SCR_SA_MAX) { + size_t block = (bytes + SCR_SA_STEP - 1) / SCR_SA_STEP * SCR_SA_STEP; + return block / SCR_ARR_SLOT_BYTES; + } +#endif + return cap; +} + /* Grow dense storage to cover at least [0, need). Callers decide whether the * range is populated enough (scr_arr_dense_ok); this only allocates. Sparse * entries below the new capacity move into the packed slots, preserving the * invariant every reader (including emitted code) relies on: indices below - * cap live in dense storage and sparse entries all lie at or above cap. */ -static void scr_arr_grow_dense_to(ScrArr *a, size_t need, bool exact) { + * cap live in dense storage and sparse entries all lie at or above cap. New + * capacity always starts as holes; slot payloads past len stay unwritten. */ +static void scr_arr_grow_dense_to(ScrArr *a, size_t need, ScrArrGrow mode) { if (need <= a->cap) return; if (need > SCR_ARR_MAX_LENGTH) scr_arr_oom(); - size_t cap = a->cap ? a->cap : 4; - while (cap < need) { - /* Double below the cutoff; grow by half above it to bound overshoot. */ - size_t step = cap < SCR_ARR_DENSE_LIMIT ? cap : cap / 2; - cap = cap > SCR_ARR_MAX_LENGTH - step ? SCR_ARR_MAX_LENGTH : cap + step; + size_t cap; + if (mode == SCR_ARR_GROW_EXACT) { + cap = scr_arr_block_cap(need); + } else { + cap = a->cap < SCR_ARR_MIN_GROWTH ? SCR_ARR_MIN_GROWTH : a->cap; + while (cap < need) { + /* Double below the cutoff; grow by half above it to bound overshoot. */ + size_t step = cap < SCR_ARR_DENSE_LIMIT ? cap : cap / 2; + cap = cap > SCR_ARR_MAX_LENGTH - step ? SCR_ARR_MAX_LENGTH : cap + step; + } + if (need <= SCR_ARR_DENSE_LIMIT && cap > SCR_ARR_DENSE_LIMIT) cap = SCR_ARR_DENSE_LIMIT; + /* Densifying an arbitrary sparse tail sizes to the populated span; only + * appends benefit from geometric headroom. */ + if (mode == SCR_ARR_GROW_SPAN && need > SCR_ARR_DENSE_LIMIT) cap = need; + } + if (cap > SIZE_MAX / SCR_ARR_SLOT_BYTES) scr_arr_oom(); + if (!a->data && SCR_AX(a)->sparse_len == 0) { + /* First storage: nothing to copy, move or absorb. */ + uint64_t *data = scr_mem_alloc(cap * SCR_ARR_SLOT_BYTES); + if (!data) scr_arr_oom(); + a->data = data; + a->present = (uint8_t *)(data + cap); + memset(a->present, SCR_ARR_HOLE, cap); + a->cap = cap; + return; } - if (need <= SCR_ARR_DENSE_LIMIT && cap > SCR_ARR_DENSE_LIMIT) cap = SCR_ARR_DENSE_LIMIT; - /* Densifying an arbitrary sparse tail sizes to the populated span; only - * appends benefit from geometric headroom. */ - if (exact && need > SCR_ARR_DENSE_LIMIT) cap = need; /* Values and states share one allocation. Move the old states before * publishing the larger capacity: their previous location is now part * of the value area. Existing data and state pointers keep their ABI. */ - if (cap > SIZE_MAX / (sizeof(uint64_t) + sizeof(uint8_t))) scr_arr_oom(); - uint64_t *data = scr_mem_realloc(a->data, cap * (sizeof(uint64_t) + sizeof(uint8_t))); + uint64_t *data = scr_mem_realloc(a->data, cap * SCR_ARR_SLOT_BYTES); if (!data) scr_arr_oom(); uint8_t *present = (uint8_t *)(data + cap); if (a->cap) memmove(present, (uint8_t *)(data + a->cap), a->cap); - memset(present + a->cap, 0, cap - a->cap); + memset(present + a->cap, SCR_ARR_HOLE, cap - a->cap); a->data = data; a->present = present; a->cap = cap; @@ -314,7 +358,7 @@ static void scr_arr_grow_dense_to(ScrArr *a, size_t need, bool exact) { } static void scr_arr_grow_dense(ScrArr *a, size_t need) { - scr_arr_grow_dense_to(a, need, false); + scr_arr_grow_dense_to(a, need, SCR_ARR_GROW_APPEND); } /* Is the top of the dense prefix populated like an append or forward fill? @@ -360,7 +404,7 @@ static void scr_arr_grow_for_index(ScrArr *a, size_t index) { if (SCR_AX(a)->sparse_len > 0 && SCR_AX(a)->sparse[SCR_AX(a)->sparse_len - 1].index >= need) { need = SCR_AX(a)->sparse[SCR_AX(a)->sparse_len - 1].index + 1; } - if (scr_arr_dense_ok(a, need, 1)) scr_arr_grow_dense_to(a, need, true); + if (scr_arr_dense_ok(a, need, 1)) scr_arr_grow_dense_to(a, need, SCR_ARR_GROW_SPAN); } static uint8_t scr_arr_state_at_storage(const ScrArrStorage *s, size_t index, @@ -617,13 +661,12 @@ ScrArr *scr_arr_new(ScrElemKind elem, size_t initial_cap) { a->len = 0; a->cap = 0; a->elem = elem; - a->elem_retain = NULL; - a->elem_release = NULL; - a->elem_trace = NULL; + a->cyc = 0; + a->ops = NULL; a->data = NULL; a->present = NULL; a->ext = NULL; - if (initial_cap > 0) scr_arr_grow_dense(a, initial_cap); + if (initial_cap > 0) scr_arr_grow_dense_to(a, initial_cap, SCR_ARR_GROW_EXACT); #ifdef SCR_RC_AUDIT scr_live_arrays++; #endif @@ -649,7 +692,7 @@ void scr_arr_swap_indexed_ext(ScrArr *a, ScrArr *b) { } /* Collector trace of a cycle-capable array: every element is a headered - * child (elem_trace non-NULL means the element TYPE carries a header, and + * child (`cyc` means the element TYPE carries a header, and * arrays are monomorphic), so trace visits all of them and the teardown * below releases none — the complement contract in scr_runtime.h. */ void scr_arr_trace_v(void *a0, ScrTraceVisit visit, void *ctx) { @@ -693,11 +736,10 @@ static void scr_arr_gc_free(void *a0) { scr_cyc_free_inline(a); } -ScrArr *scr_arr_new_ref(void *(*elem_retain)(void *), - void (*elem_release)(void *), - ScrTraceFn elem_trace, size_t initial_cap) { +ScrArr *scr_arr_new_ops(const ScrArrOps *ops, size_t initial_cap) { ScrArr *a; - if (elem_trace) { + bool cyc = ops->trace != NULL; + if (cyc) { static const ScrCycType cyc_type = { &scr_arr_trace_v, &scr_arr_gc_free, SCR_CYC_KIND_ARRAY }; a = scr_cyc_alloc_inline(sizeof(ScrArr), &cyc_type); } else { @@ -708,13 +750,12 @@ ScrArr *scr_arr_new_ref(void *(*elem_retain)(void *), a->len = 0; a->cap = 0; a->elem = SCR_ELEM_REF; - a->elem_retain = elem_retain; - a->elem_release = elem_release; - a->elem_trace = elem_trace; + a->cyc = cyc; + a->ops = ops; a->data = NULL; a->present = NULL; a->ext = NULL; - if (initial_cap > 0) scr_arr_grow_dense(a, initial_cap); + if (initial_cap > 0) scr_arr_grow_dense_to(a, initial_cap, SCR_ARR_GROW_EXACT); #ifdef SCR_RC_AUDIT scr_live_arrays++; #endif @@ -755,7 +796,7 @@ static void scr_arr_destroy(void *object) { } } } - if (a->elem_trace) { + if (a->cyc) { scr_arr_gc_free(a); } else { scr_mem_free(a->data); @@ -771,9 +812,9 @@ static void scr_arr_destroy(void *object) { void scr_arr_release(ScrArr *a) { if (!a || a->rc == SIZE_MAX) return; /* NULL: an uninitialized `let` local */ if (--a->rc == 0) { - if (a->elem_trace) scr_cyc_dead(a); + if (a->cyc) scr_cyc_dead(a); scr_rc_destroy(a, scr_arr_destroy); - } else if (a->elem_trace) { + } else if (a->cyc) { scr_cyc_released(a); /* possible cycle root; may collect */ } } @@ -1169,7 +1210,7 @@ void *scr_arr_get_ref(ScrArr *a, double i) { if (!p) return NULL; if (a->elem == SCR_ELEM_STR) scr_str_retain((ScrStr *)p); else if (a->elem == SCR_ELEM_BYTES) scr_bytes_retain((ScrBytes *)p); - else if (a->elem == SCR_ELEM_REF) p = a->elem_retain(p); + else if (a->elem == SCR_ELEM_REF) p = a->ops->retain(p); else scr_arr_retain((ScrArr *)p); return p; } @@ -1586,7 +1627,7 @@ ScrArr *scr_arr_splice(ScrArr *a, double start, double deleteCount) { size_t hint = scr_arr_is_dense(a) || n <= SCR_ARR_DENSE_LIMIT ? n : SCR_ARR_DENSE_LIMIT; ScrArr *out = a->elem == SCR_ELEM_REF - ? scr_arr_new_ref(a->elem_retain, a->elem_release, a->elem_trace, hint ? hint : 1) + ? scr_arr_new_ops(a->ops, hint ? hint : 1) : scr_arr_new(a->elem, hint ? hint : 1); out->len = n; size_t old_len = a->len; @@ -1655,7 +1696,7 @@ ScrArr *scr_arr_splice_insert(ScrArr *a, double start, double deleteCount, ScrArr *snapshot = items == a ? scr_arr_slice(a, 0, INFINITY) : NULL; if (snapshot) items = snapshot; ScrArr *removed = a->elem == SCR_ELEM_REF - ? scr_arr_new_ref(a->elem_retain, a->elem_release, a->elem_trace, n) + ? scr_arr_new_ops(a->ops, n) : scr_arr_new(a->elem, n); if (n) { memcpy(removed->data, a->data + from, n * sizeof(*a->data)); @@ -1699,7 +1740,7 @@ void scr_arr_splice_drop(ScrArr *a, double start, double deleteCount, size_t cou bool refs = scr_elem_is_ref(a->elem); if (!scr_arr_is_dense(a) || !scr_arr_dense_ok(a, next_len, count)) { ScrArr *items = a->elem == SCR_ELEM_REF - ? scr_arr_new_ref(a->elem_retain, a->elem_release, a->elem_trace, count) + ? scr_arr_new_ops(a->ops, count) : scr_arr_new(a->elem, count); scr_arr_push_many(items, count, slots); scr_arr_release(scr_arr_splice_insert(a, start, deleteCount, items)); @@ -1768,10 +1809,10 @@ ScrArr *scr_arr_flat_copy(const ScrArr *a, ScrArr *out, bool flatten) { static bool scr_arr_ref_eq(const ScrArr *a, uint64_t slot, void *v) { void *p = scr_slot_to_ptr(slot); if (a->elem == SCR_ELEM_STR) return scr_str_eq((ScrStr *)p, (ScrStr *)v); - if (a->elem == SCR_ELEM_REF && a->elem_retain == scr_dyn_retain_v) { + if (a->elem == SCR_ELEM_REF && a->ops->retain == scr_dyn_retain_v) { return scr_dyn_strict_eq((ScrDyn *)p, (ScrDyn *)v); } - if (a->elem == SCR_ELEM_REF && a->elem_retain == scr_closure_retain_v) + if (a->elem == SCR_ELEM_REF && a->ops->retain == scr_closure_retain_v) return scr_closure_identity_equal((ScrClosure *)p, (ScrClosure *)v); return p == v; } @@ -1825,7 +1866,7 @@ bool scr_arr_includes_bool(ScrArr *a, bool v) { } bool scr_arr_includes_ref(ScrArr *a, void *v) { - if (a->elem == SCR_ELEM_REF && a->elem_retain == scr_dyn_retain_v) { + if (a->elem == SCR_ELEM_REF && a->ops->retain == scr_dyn_retain_v) { const ScrDyn *needle = (const ScrDyn *)v; if (needle->kind == SCR_DYN_NUM && needle->v.num != needle->v.num) { for (size_t i = 0; i < a->cap && i < a->len; i++) { @@ -1888,7 +1929,7 @@ ScrArr *scr_arr_slice(ScrArr *a, double start, double end) { size_t hint = to <= a->cap || n <= SCR_ARR_DENSE_LIMIT ? n : SCR_ARR_DENSE_LIMIT; ScrArr *out = a->elem == SCR_ELEM_REF - ? scr_arr_new_ref(a->elem_retain, a->elem_release, a->elem_trace, hint ? hint : 1) + ? scr_arr_new_ops(a->ops, hint ? hint : 1) : scr_arr_new(a->elem, hint ? hint : 1); out->len = n; if (to <= a->cap) { @@ -2158,7 +2199,7 @@ void scr_arr_sort_values(ScrArr *a, double count, ScrClosure *f, uint32_t arity) if (a->elem == SCR_ELEM_STR) c.retain = scr_sort_retain_str; else if (a->elem == SCR_ELEM_ARR) c.retain = scr_sort_retain_arr; else if (a->elem == SCR_ELEM_BYTES) c.retain = scr_sort_retain_bytes; - else if (a->elem == SCR_ELEM_REF) c.retain = a->elem_retain; + else if (a->elem == SCR_ELEM_REF) c.retain = a->ops->retain; else scr_trap("scriptc: invalid comparator sort element kind\n"); } uint64_t *src = malloc(n * sizeof(*src)); diff --git a/packages/runtime/src/scr_async.c b/packages/runtime/src/scr_async.c index 37644f705..c445711cc 100644 --- a/packages/runtime/src/scr_async.c +++ b/packages/runtime/src/scr_async.c @@ -1342,7 +1342,7 @@ static void scr_promise_all_settle(ScrAllState *st, ScrPromise *result, size_t i if (st->values) { scr_promise_fulfill_ref(result, scr_arr_retain(st->values), scr_arr_retain_v, scr_arr_release_v, - st->values->elem_trace ? scr_arr_trace_v : NULL); + st->values->cyc ? scr_arr_trace_v : NULL); } else { scr_promise_fulfill_void(result); } @@ -1460,7 +1460,7 @@ ScrPromise *scr_promise_all(ScrArr *ps, ScrArr *values, if (st->values) { scr_promise_fulfill_ref(result, scr_arr_retain(st->values), scr_arr_retain_v, scr_arr_release_v, - st->values->elem_trace ? scr_arr_trace_v : NULL); + st->values->cyc ? scr_arr_trace_v : NULL); } else { scr_promise_fulfill_void(result); } diff --git a/packages/runtime/src/scr_async_dyn.c b/packages/runtime/src/scr_async_dyn.c index 675c2ae3b..e63b6e1a7 100644 --- a/packages/runtime/src/scr_async_dyn.c +++ b/packages/runtime/src/scr_async_dyn.c @@ -888,9 +888,12 @@ static void scr_dyn_all_result(ScrPromise *destination, ScrPromise *source) { scr_promise_fulfill_ref(destination, result, scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v); } +static const ScrArrOps scr_promise_arr_ops = { scr_promise_retain_v, scr_promise_release_v, scr_promise_trace_v }; +static const ScrArrOps scr_dyn_arr_ops = { scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v }; + ScrPromise *scr_dyn_promise_all(const ScrDyn *entries) { - ScrArr *promises = scr_arr_new_ref(scr_promise_retain_v, scr_promise_release_v, scr_promise_trace_v, entries->v.arr.len); - ScrArr *values = scr_arr_new_ref(scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v, entries->v.arr.len); + ScrArr *promises = scr_arr_new_ops(&scr_promise_arr_ops, entries->v.arr.len); + ScrArr *values = scr_arr_new_ops(&scr_dyn_arr_ops, entries->v.arr.len); for (size_t i = 0; i < entries->v.arr.len; i++) { ScrDyn *value = entries->v.arr.items[i]; ScrPromise *source; diff --git a/packages/runtime/src/scr_bytes_io.c b/packages/runtime/src/scr_bytes_io.c index 1454d3086..1e2cc8a13 100644 --- a/packages/runtime/src/scr_bytes_io.c +++ b/packages/runtime/src/scr_bytes_io.c @@ -6,6 +6,9 @@ * exact source lists). */ #include "scr_runtime.h" +static const ScrArrOps scr_bytes_io_str_ops = { scr_str_retain_v, scr_str_release_v, NULL }; +static const ScrArrOps scr_bytes_io_bytes_ops = { scr_bytes_retain_v, scr_bytes_release_v, NULL }; + #include #include #include @@ -337,7 +340,7 @@ static void scr_fs_symlink_checked_core(const ScrDyn *target, const ScrDyn *dest ScrStr *source = !scr_exc_pending() ? scr_dyn_string_coerce_js(target) : NULL; ScrStr *absolute = NULL; if (link && source && !scr_exc_pending()) { - ScrArr *parts = scr_arr_new_ref(scr_str_retain_v, scr_str_release_v, NULL, 3); + ScrArr *parts = scr_arr_new_ops(&scr_bytes_io_str_ops, 3); scr_arr_push_ref(parts, scr_str_retain(link)); scr_arr_push_ref(parts, scr_str_new("..", 2)); scr_arr_push_ref(parts, scr_str_retain(source)); @@ -658,7 +661,7 @@ static ScrArr *scr_fs_cb_vectors(const ScrDyn *buffers) { scr_dyn_release(snapshot); return NULL; } - ScrArr *out = scr_arr_new_ref(scr_bytes_retain_v, scr_bytes_release_v, NULL, array->v.arr.len); + ScrArr *out = scr_arr_new_ops(&scr_bytes_io_bytes_ops, array->v.arr.len); for (size_t i = 0; i < array->v.arr.len; i++) { const ScrDyn *buffer = array->v.arr.items[i]; if (!scr_dyn_bytes_is(buffer, SCR_BYTES_U8)) { diff --git a/packages/runtime/src/scr_console.c b/packages/runtime/src/scr_console.c index bc558318d..360f4f2ad 100644 --- a/packages/runtime/src/scr_console.c +++ b/packages/runtime/src/scr_console.c @@ -125,7 +125,7 @@ static void scr_enable_utf8_console_output(void) { } #endif -void scr_runtime_abi_v12(void) {} +void scr_runtime_abi_v13(void) {} void scr_init(void) { #ifdef SCR_WORKERS diff --git a/packages/runtime/src/scr_copying.c b/packages/runtime/src/scr_copying.c index 3ff0b5a68..063536b8f 100644 --- a/packages/runtime/src/scr_copying.c +++ b/packages/runtime/src/scr_copying.c @@ -23,8 +23,7 @@ static bool copying_elem_is_ref(ScrElemKind kind) { static ScrArr *copying_arr_new_like(const ScrArr *a, size_t cap) { ScrArr *out = a->elem == SCR_ELEM_REF - ? scr_arr_new_ref(a->elem_retain, a->elem_release, - a->elem_trace, cap ? cap : 1) + ? scr_arr_new_ops(a->ops, cap ? cap : 1) : scr_arr_new(a->elem, cap ? cap : 1); out->len = cap; return out; @@ -36,7 +35,7 @@ static uint64_t copying_arr_retain_slot(const ScrArr *a, uint64_t slot) { if (a->elem == SCR_ELEM_STR) p = scr_str_retain((ScrStr *)p); else if (a->elem == SCR_ELEM_ARR) p = scr_arr_retain((ScrArr *)p); else if (a->elem == SCR_ELEM_BYTES) p = scr_bytes_retain((ScrBytes *)p); - else p = a->elem_retain(p); + else p = a->ops->retain(p); return copying_slot_from_ptr(p); } diff --git a/packages/runtime/src/scr_events_emitter.c b/packages/runtime/src/scr_events_emitter.c index c95c1722d..ae9cdb4dd 100644 --- a/packages/runtime/src/scr_events_emitter.c +++ b/packages/runtime/src/scr_events_emitter.c @@ -791,9 +791,11 @@ ScrArr *scr_emitter_event_names(ScrEmitter *em) { * The once wrapper is runtime-internal here, so BOTH forms answer the * original listeners (SEMANTICS.md documents the rawListeners * divergence). */ +static const ScrArrOps scr_ee_closure_arr_ops = { &scr_closure_retain_v, &scr_closure_release_v, + &scr_closure_trace_v }; + ScrArr *scr_emitter_listeners(ScrEmitter *em, ScrStr *name) { - ScrArr *out = scr_arr_new_ref(&scr_closure_retain_v, &scr_closure_release_v, - &scr_closure_trace_v, 0); + ScrArr *out = scr_arr_new_ops(&scr_ee_closure_arr_ops, 0); ScrEeBucket *b = em->reg ? scr_ee_bucket_find(em->reg, name->data, name->len) : NULL; if (b) { for (size_t i = 0; i < b->n; i++) { diff --git a/packages/runtime/src/scr_island.c b/packages/runtime/src/scr_island.c index d32dec4df..4d23370e8 100644 --- a/packages/runtime/src/scr_island.c +++ b/packages/runtime/src/scr_island.c @@ -11095,8 +11095,8 @@ ScrArr *scr_jsval_exit_jsval_arr(ScrJsval *v) { int64_t len = 0; JS_ToInt64(isl_ctx, &len, lv); JS_FreeValue(isl_ctx, lv); - ScrArr *out = scr_arr_new_ref(&scr_jsval_retain_v, &scr_jsval_release_v, NULL, - len > 0 ? (size_t)len : 0); + static const ScrArrOps jsval_ops = { &scr_jsval_retain_v, &scr_jsval_release_v, NULL }; + ScrArr *out = scr_arr_new_ops(&jsval_ops, len > 0 ? (size_t)len : 0); for (int64_t i = 0; i < len; i++) { JSValue e = JS_GetPropertyUint32(isl_ctx, v->v, (uint32_t)i); /* getters run */ if (JS_IsException(e)) { diff --git a/packages/runtime/src/scr_json.test.c b/packages/runtime/src/scr_json.test.c index 4887489f3..463d6d2d1 100644 --- a/packages/runtime/src/scr_json.test.c +++ b/packages/runtime/src/scr_json.test.c @@ -391,7 +391,8 @@ static void test_item_release(void *ptr) { static ScrArr *test_tags_new(size_t cap) { return scr_arr_new(SCR_ELEM_STR, cap); } static ScrArr *test_list_new(size_t cap) { - return scr_arr_new_ref(test_item_retain, test_item_release, NULL, cap); + static const ScrArrOps item_ops = { test_item_retain, test_item_release, NULL }; + return scr_arr_new_ops(&item_ops, cap); } static void test_arr_release(void *ptr) { scr_arr_release(ptr); } diff --git a/packages/runtime/src/scr_lib.c b/packages/runtime/src/scr_lib.c index 65165ed67..0e4ce71ce 100644 --- a/packages/runtime/src/scr_lib.c +++ b/packages/runtime/src/scr_lib.c @@ -4702,7 +4702,8 @@ int scr_fs_symlink_infer(ScrStr *absolute) { void scr_fs_symlink(ScrStr *target, ScrStr *destination, int kind) { #ifdef _WIN32 - ScrArr *parts = scr_arr_new_ref(scr_str_retain_v, scr_str_release_v, NULL, 3); + static const ScrArrOps str_ops = { scr_str_retain_v, scr_str_release_v, NULL }; + ScrArr *parts = scr_arr_new_ops(&str_ops, 3); scr_arr_push_ref(parts, scr_str_retain(destination)); scr_arr_push_ref(parts, scr_str_new("..", 2)); scr_arr_push_ref(parts, scr_str_retain(target)); @@ -7545,12 +7546,12 @@ ScrArr *scr_set_to_arr_str(const ScrMap *s) { return out; } -ScrArr *scr_set_to_arr_ref(const ScrMap *s) { - ScrArr *out = scr_arr_new_ref(s->key_retain, s->key_release, s->key_trace, s->nlive); +ScrArr *scr_set_to_arr_ref(const ScrMap *s, const ScrArrOps *ops) { + ScrArr *out = scr_arr_new_ops(ops, s->nlive); if (scr_set_to_arr_sparse(s, out)) return out; for (size_t i = 0; i < s->nentries; i++) { if (!s->entries[i].hash) continue; - s->key_retain((void *)(uintptr_t)s->entries[i].key); + ops->retain((void *)(uintptr_t)s->entries[i].key); out->data[out->len] = s->entries[i].key; out->present[out->len++] = SCR_ARR_VALUE; } diff --git a/packages/runtime/src/scr_map.c b/packages/runtime/src/scr_map.c index 7bfa805ca..84adf177f 100644 --- a/packages/runtime/src/scr_map.c +++ b/packages/runtime/src/scr_map.c @@ -425,10 +425,10 @@ void *scr_map_get_span_ref(const ScrMap *m, const char *bytes, size_t length) { static void scr_map_rebuild_buckets(ScrMap *m, size_t nbuckets) { bool compact = scr_map_compact_buckets(nbuckets); size_t bytes = nbuckets * (compact ? sizeof(uint32_t) : sizeof(size_t)); - void *buckets = malloc(bytes); + void *buckets = scr_mem_alloc(bytes); if (!buckets) scr_map_oom(); memset(buckets, compact ? 0 : 0xff, bytes); - free(m->buckets); + scr_mem_free(m->buckets); m->buckets = buckets; m->nbuckets = nbuckets; size_t mask = nbuckets - 1; @@ -467,7 +467,7 @@ static size_t scr_map_dense_limit(size_t live) { } static void scr_map_dense_alloc(ScrMap *m, size_t n) { - uint32_t *dense = realloc(m->dense, n * sizeof *dense); + uint32_t *dense = scr_mem_realloc(m->dense, n * sizeof *dense); if (!dense) scr_map_oom(); m->dense = dense; m->ndense = n; @@ -485,7 +485,7 @@ static __attribute__((noinline)) void scr_map_enter_dense(ScrMap *m, double inco if (!scr_map_dense_slot(scr_map_slot_to_f64(m->entries[e].key), limit, &i)) return; if (i > top) top = i; } - free(m->buckets); + scr_mem_free(m->buckets); m->buckets = NULL; m->nbuckets = 0; scr_map_dense_alloc(m, scr_map_dense_size(top)); @@ -505,7 +505,7 @@ static __attribute__((noinline)) bool scr_map_grow_dense(ScrMap *m, double k, si /* Switch to the bucket table; cached entry hashes are already complete. */ static __attribute__((noinline)) void scr_map_leave_dense(ScrMap *m) { - free(m->dense); + scr_mem_free(m->dense); m->dense = NULL; m->ndense = 0; if (m->nentries < SCR_MAP_LINEAR_LIMIT) return; @@ -549,7 +549,7 @@ static void scr_map_compact(ScrMap *m, bool reindex) { if (!dense) return; if (reindex) { if (w == 0) { - free(m->dense); + scr_mem_free(m->dense); m->dense = NULL; m->ndense = 0; return; @@ -571,7 +571,7 @@ static void scr_map_grow_entries(ScrMap *m) { if (cap > SIZE_MAX / 2 / sizeof(ScrMapEntry)) scr_map_oom(); cap *= 2; } - ScrMapEntry *entries = realloc(m->entries, cap * sizeof *entries); + ScrMapEntry *entries = scr_mem_realloc(m->entries, cap * sizeof *entries); if (!entries) scr_map_oom(); m->entries = entries; m->ecap = cap; @@ -651,9 +651,9 @@ static void scr_map_gcfree(void *o) { if (!m->key_trace) scr_map_release_key(m, m->entries[e].key); if (!m->val_trace) scr_map_release_val(m, m->entries[e].val); } - free(m->entries); - free(m->buckets); - free(m->dense); + scr_mem_free(m->entries); + scr_mem_free(m->buckets); + scr_mem_free(m->dense); #ifdef SCR_RC_AUDIT scr_live_maps--; #endif @@ -666,6 +666,12 @@ ScrMap *scr_map_new(ScrMapKeyKind key_kind, ScrMapValKind val_kind, return scr_map_new_typed(key_kind, val_kind, NULL, NULL, NULL, val_retain, val_release, val_trace); } +/* Map construction inlines into its callers; keeping the header allocation + * out of line keeps those call sites as small as the libc call they had. */ +static __attribute__((noinline)) ScrMap *scr_map_alloc_plain(void) { + return scr_mem_calloc(sizeof(ScrMap)); +} + ScrMap *scr_map_new_typed(ScrMapKeyKind key_kind, ScrMapValKind val_kind, void *(*key_retain)(void *), void (*key_release)(void *), ScrTraceFn key_trace, @@ -677,7 +683,7 @@ ScrMap *scr_map_new_typed(ScrMapKeyKind key_kind, ScrMapValKind val_kind, static const ScrCycType cyc_type = { &scr_map_trace, &scr_map_gcfree, SCR_CYC_KIND_MAP }; m = scr_cyc_alloc(sizeof *m, &cyc_type); } else { - m = calloc(1, sizeof *m); + m = scr_map_alloc_plain(); if (!m) scr_map_oom(); } m->rc = 1; @@ -710,14 +716,14 @@ static void scr_map_destroy(void *object) { scr_map_release_key(m, m->entries[e].key); scr_map_release_val(m, m->entries[e].val); } - free(m->entries); - free(m->buckets); - free(m->dense); + scr_mem_free(m->entries); + scr_mem_free(m->buckets); + scr_mem_free(m->dense); #ifdef SCR_RC_AUDIT scr_live_maps--; #endif if (m->key_trace || m->val_trace) scr_cyc_free(m); - else free(m); + else scr_mem_free(m); } void scr_map_release(ScrMap *m) { @@ -771,7 +777,7 @@ void scr_map_clear(ScrMap *m) { * after the clear append past them and ARE visited (Node-exact). */ m->nentries = 0; if (m->ecap > SCR_MAP_CLEAR_KEEP && m->ecap / 8 > walked) { - free(m->entries); + scr_mem_free(m->entries); m->entries = NULL; m->ecap = 0; } @@ -779,13 +785,13 @@ void scr_map_clear(ScrMap *m) { /* Without either index, a map is a linear scan; dead entries kept for an * active iteration are skipped by every later rebuild. */ if (m->ndense > SCR_MAP_CLEAR_KEEP && m->ndense / 32 > walked) { - free(m->dense); + scr_mem_free(m->dense); m->dense = NULL; m->ndense = 0; } if (m->nbuckets) { if (m->nbuckets > SCR_MAP_CLEAR_KEEP && m->nbuckets / 8 > walked) { - free(m->buckets); + scr_mem_free(m->buckets); m->buckets = NULL; m->nbuckets = 0; } else { @@ -1080,6 +1086,11 @@ bool scr_map_get_str_bool(const ScrMap *m, const ScrStr *key, bool *out) { return true; } +const ScrMapEntry *scr_map_entry_str(const ScrMap *m, const ScrStr *key) { + size_t e = scr_map_find_str(m, key); + return e == SCR_MAP_EMPTY ? NULL : &m->entries[e]; +} + void *scr_map_get_str_ref(const ScrMap *m, const ScrStr *key) { size_t e = scr_map_find_str(m, key); if (e == SCR_MAP_EMPTY) return NULL; @@ -1249,7 +1260,7 @@ ScrMap *scr_map_clone(const ScrMap *source, bool keys_only) { size_t count = source->nlive; if (!count) return out; if (count > SIZE_MAX / sizeof(ScrMapEntry) || count > SIZE_MAX / 2 / sizeof(size_t)) scr_map_oom(); - out->entries = malloc(count * sizeof(ScrMapEntry)); + out->entries = scr_mem_alloc(count * sizeof(ScrMapEntry)); if (!out->entries) scr_map_oom(); out->ecap = count; size_t top = 0; @@ -1313,7 +1324,8 @@ void scr_map_values_into(ScrMap *set, const ScrMap *source, bool checked) { } ScrArr *scr_set_to_arr_dyn(const ScrMap *map) { - ScrArr *out = scr_arr_new_ref(scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v, map->nlive); + static const ScrArrOps dyn_ops = { scr_dyn_retain_v, scr_dyn_release_v, scr_dyn_trace_v }; + ScrArr *out = scr_arr_new_ops(&dyn_ops, map->nlive); for (size_t i = 0; i < map->nentries; i++) { if (scr_map_iter_live(map, (double)i)) scr_arr_push_ref(out, scr_map_dyn_key(map, (double)i)); } diff --git a/packages/runtime/src/scr_publish.c b/packages/runtime/src/scr_publish.c index d48a348f5..265e08875 100644 --- a/packages/runtime/src/scr_publish.c +++ b/packages/runtime/src/scr_publish.c @@ -118,7 +118,7 @@ void scr_pub_arr(void *v, ScrPub *ctx, ScrPubFn elem) { scr_pub_refuse(ctx, "Cannot publish an array with non-index properties"); return; } - if (!scr_pub_mark(ctx, a, a->elem_trace != NULL, SCR_PUB_KIND_ARRAY)) return; + if (!scr_pub_mark(ctx, a, a->cyc != 0, SCR_PUB_KIND_ARRAY)) return; ScrPubFn fn = a->elem == SCR_ELEM_STR ? scr_pub_str_fn : a->elem == SCR_ELEM_REF ? elem : NULL; if (!fn) return; size_t dense = a->len < a->cap ? a->len : a->cap; diff --git a/packages/runtime/src/scr_runtime.h b/packages/runtime/src/scr_runtime.h index 7b8544211..7a52b2699 100644 --- a/packages/runtime/src/scr_runtime.h +++ b/packages/runtime/src/scr_runtime.h @@ -62,7 +62,7 @@ void scr_init(void); /* Program objects emitted by the bundled LLVM helper reference this symbol. * Its versioned spelling makes a mismatched manual runtime link fail before * the program can start. */ -void scr_runtime_abi_v12(void); +void scr_runtime_abi_v13(void); void scr_runtime_workers_v8(void); /* ── the trap funnel (scr_console.c; scr_library.c under -DSCR_LIB) ────── @@ -1564,8 +1564,8 @@ typedef enum { SCR_ELEM_BYTES, /* slots are ScrBytes* — released with the array */ /* Slots are void* to values the runtime cannot lay out itself — records, * class instances, unions, and cycle-capable inner arrays. The element - * type's RC entry points arrive at construction (scr_arr_new_ref) and are - * stored ONCE per array, the SCR_BOX_OBJ / map-value technique; every + * type's RC entry points arrive at construction (scr_arr_new_ops) as one + * constant descriptor per element type, stored once per array; every * array is still monomorphic (one element type, one set of entry points). */ SCR_ELEM_REF, } ScrElemKind; @@ -1576,21 +1576,32 @@ typedef enum { SCR_ARR_UNDEFINED = 2, } ScrArrState; +/* The RC entry points of an SCR_ELEM_REF array's element type: one constant + * per element type (emitted by the compiler, or static in the runtime), + * shared by every array of that type. retain/release are the type's `_v` + * adapters; trace is non-NULL exactly when the element type carries a cycle + * header. */ +typedef struct ScrArrOps { + void *(*retain)(void *); + void (*release)(void *); + ScrTraceFn trace; +} ScrArrOps; + typedef struct ScrArr { size_t rc; /* SIZE_MAX = immortal (unused for arrays; kept per convention) */ size_t len; size_t cap; /* dense capacity; sparse entries cover indices >= cap */ ScrElemKind elem; - /* SCR_ELEM_REF only; NULL for every other element kind. elem_trace is - * non-NULL exactly when the element type carries a cycle header: such - * arrays are CYCLE-CAPABLE (an element can point back at the array that - * owns it) and allocate with the hidden collector header — their trace - * visits every element, and the collector teardown frees only the slot - * storage (all elements are traced children). Arrays of acyclic ref - * elements and the historic element kinds keep the lean 1-word header. */ - void *(*elem_retain)(void *); - void (*elem_release)(void *); - ScrTraceFn elem_trace; + /* 1 exactly when ops->trace is non-NULL: the element type carries a cycle + * header, so the array is CYCLE-CAPABLE (an element can point back at the + * array that owns it) and allocates with the hidden collector header — + * its trace visits every element, and the collector teardown frees only + * the slot storage (all elements are traced children). Arrays of acyclic + * ref elements and the historic element kinds keep the lean 1-word + * header. Kept beside `elem` so the RC fast paths test it with one load. */ + uint32_t cyc; + /* SCR_ELEM_REF only; NULL for every other element kind. */ + const ScrArrOps *ops; uint64_t *data; uint8_t *present; /* one state per dense slot; heap arrays share data allocation */ /* Rarely used storage (sparse indices, noncanonical numeric properties, @@ -1608,11 +1619,15 @@ typedef struct ScrArrExt { size_t prop_cap; struct ScrDyn *metadata; /* heterogeneous named properties of match results */ } ScrArrExt; -/* The LLVM backend's inline retain/release read elem_trace through its - * mirrored %ScrArr type (field 6) to decide mark-live / candidate buffering - * exactly like scr_arr_retain and scr_arr_release. */ -_Static_assert(offsetof(ScrArr, elem_trace) == 3 * sizeof(size_t) + 3 * sizeof(void *), - "inline RC fast paths read ScrArr.elem_trace as %ScrArr field 6"); +/* The LLVM backend's inline retain/release read `cyc` through its mirrored + * %ScrArr type (field 4, i32) to decide mark-live / candidate buffering + * exactly like scr_arr_retain and scr_arr_release; its inline element reads + * use data (field 6) and present (field 7). */ +_Static_assert(sizeof(ScrElemKind) == sizeof(uint32_t), "ScrArr.elem is an i32 (%ScrArr field 3)"); +_Static_assert(offsetof(ScrArr, cyc) == 3 * sizeof(size_t) + sizeof(uint32_t), + "inline RC fast paths read ScrArr.cyc as %ScrArr field 4"); +_Static_assert(offsetof(ScrArr, data) == 3 * sizeof(size_t) + 2 * sizeof(uint32_t) + sizeof(void *), + "inline element reads use ScrArr.data as %ScrArr field 6"); typedef struct ScrArrSparseSlot { size_t index; @@ -1629,13 +1644,12 @@ typedef struct ScrArrProp { ScrArr *scr_arr_new(ScrElemKind elem, size_t initial_cap); /* returns +1 */ -/* SCR_ELEM_REF construction: retain/release must be non-NULL (the compiler - * passes the element type's `_v` adapters); trace is non-NULL iff the - * element type carries a cycle header (the array then allocates with the - * collector header — see the struct comment). Returns +1. */ -ScrArr *scr_arr_new_ref(void *(*elem_retain)(void *), - void (*elem_release)(void *), - ScrTraceFn elem_trace, size_t initial_cap); +/* SCR_ELEM_REF construction: `ops` must outlive the array (a constant; the + * compiler emits one per element type) and its retain/release must be + * non-NULL; ops->trace is non-NULL iff the element type carries a cycle + * header (the array then allocates with the collector header — see the + * struct comment). Returns +1. */ +ScrArr *scr_arr_new_ops(const ScrArrOps *ops, size_t initial_cap); static inline ScrArr *scr_arr_retain(ScrArr *a) { if (a->rc != SIZE_MAX) { @@ -1645,8 +1659,8 @@ static inline ScrArr *scr_arr_retain(ScrArr *a) { } /* Releases ref elements (SCR_ELEM_STR/ARR/BYTES/REF) recursively at rc == 0. - * NULL-tolerant (uninitialized locals). Cycle-capable arrays (elem_trace - * non-NULL) feed the candidate-root buffer like every headered type. */ + * NULL-tolerant (uninitialized locals). Cycle-capable arrays (`cyc`) feed + * the candidate-root buffer like every headered type. */ void scr_arr_release(ScrArr *a); void scr_arr_copy_metadata(ScrArr *a, struct ScrDyn *target); /* The array's out-of-line storage, allocated (zeroed) on first use. */ @@ -2032,6 +2046,10 @@ _Static_assert(sizeof(ScrMapEntry) == 24 && offsetof(ScrMapEntry, val) == 8, /* Entry for a number key, or NULL when absent. The pointer is valid until * the next mutation; generated code reads the value slot through it. */ const ScrMapEntry *scr_map_entry_f64(const ScrMap *m, double key); +/* Entry for a string key, or NULL when absent, on the same terms. Typed + * reference reads retain the value with its static type's retain instead + * of the collection's adapter. */ +const ScrMapEntry *scr_map_entry_str(const ScrMap *m, const ScrStr *key); /* Called once on a fresh UNION_VALUE collection, before its first insert. */ void scr_map_union_keys(ScrMap *map, const uint8_t *kinds); @@ -2148,12 +2166,12 @@ void scr_set_add_all(ScrMap *set, ScrArr *values); ScrArr *scr_set_to_arr_f64(const ScrMap *s); ScrArr *scr_set_to_arr_bool(const ScrMap *s); ScrArr *scr_set_to_arr_str(const ScrMap *s); -ScrArr *scr_set_to_arr_ref(const ScrMap *s); +ScrArr *scr_set_to_arr_ref(const ScrMap *s, const ScrArrOps *ops); ScrArr *scr_set_to_arr_dyn(const ScrMap *s); /* REF-element Set construction: a set-shaped map whose keys are refcounted * pointers under identity hashing (see SCR_MAP_KEY_REF above). The element - * type's `_v` adapters arrive once, the scr_arr_new_ref technique. */ + * type's `_v` adapters arrive once, as for arrays (scr_arr_new_ops). */ ScrMap *scr_set_new_ref(void *(*elem_retain)(void *), void (*elem_release)(void *)); /* The live STRING keys of a map in JS OWN-KEY ORDER (Object.keys/values/ diff --git a/packages/runtime/src/scr_stream.c b/packages/runtime/src/scr_stream.c index dc7647090..72eae91de 100644 --- a/packages/runtime/src/scr_stream.c +++ b/packages/runtime/src/scr_stream.c @@ -2329,7 +2329,8 @@ static ScrPromise *scr_sc_consume(ScrStream *s, int kind) { scr_promise_reject_pending(p); return p; } - ScrArr *chunks = scr_arr_new_ref(scr_bytes_retain_v, scr_bytes_release_v, NULL, 4); + static const ScrArrOps bytes_ops = { scr_bytes_retain_v, scr_bytes_release_v, NULL }; + ScrArr *chunks = scr_arr_new_ops(&bytes_ops, 4); ScrStreamErrInv fin_inv = kind == SCR_SC_TEXT ? &scr_sc_fin_text : kind == SCR_SC_JSON ? &scr_sc_fin_json : &scr_sc_fin_buffer; diff --git a/packages/runtime/test/test_array.c b/packages/runtime/test/test_array.c index f707b4486..0b3b0a576 100644 --- a/packages/runtime/test/test_array.c +++ b/packages/runtime/test/test_array.c @@ -396,11 +396,14 @@ static MockRec *mock_cyc_new(int value) { return r; } +static const ScrArrOps mock_ops = { &mock_retain, &mock_release, NULL }; +static const ScrArrOps mock_cyc_ops = { &mock_cyc_retain, &mock_cyc_release, &mock_trace }; + static void test_ref_elements(void) { #ifdef SCR_RC_AUDIT long arrays0 = scr_arr_live_count(); #endif - ScrArr *a = scr_arr_new_ref(&mock_retain, &mock_release, NULL, 0); + ScrArr *a = scr_arr_new_ops(&mock_ops, 0); scr_arr_push_ref(a, mock_new(1)); /* ownership moves in */ scr_arr_push_ref(a, mock_new(2)); check_f64(scr_arr_len(a), 2, "ref push grows"); @@ -446,7 +449,7 @@ static void test_ref_cycle(void) { long arrays0 = scr_arr_live_count(); #endif /* arr -> rec -> arr: drop the external references, then collect. */ - ScrArr *arr = scr_arr_new_ref(&mock_cyc_retain, &mock_cyc_release, &mock_trace, 0); + ScrArr *arr = scr_arr_new_ops(&mock_cyc_ops, 0); MockRec *rec = mock_cyc_new(7); rec->owner = (ScrArr *)scr_arr_retain(arr); /* rec points back at arr */ scr_arr_push_ref(arr, rec); /* arr owns rec */ @@ -466,7 +469,7 @@ static void test_ref_truncate_cycle(void) { /* The truncation release runs while the record points back at the array. * The array edge must be detached before mock_cyc_release can trigger the * cycle collector. */ - ScrArr *arr = scr_arr_new_ref(&mock_cyc_retain, &mock_cyc_release, &mock_trace, 0); + ScrArr *arr = scr_arr_new_ops(&mock_cyc_ops, 0); MockRec *rec = mock_cyc_new(8); rec->owner = (ScrArr *)scr_arr_retain(arr); scr_arr_push_ref(arr, rec); @@ -481,7 +484,7 @@ static void test_ref_truncate_cycle(void) { static void test_ref_trace_storage_boundaries(void) { long before = mock_live; - ScrArr *arr = scr_arr_new_ref(&mock_cyc_retain, &mock_cyc_release, &mock_trace, 4096); + ScrArr *arr = scr_arr_new_ops(&mock_cyc_ops, 4096); MockRec *dense = mock_cyc_new(1); MockRec *sparse = mock_cyc_new(2); MockRec *property = mock_cyc_new(3); @@ -1107,6 +1110,33 @@ static void test_comparator_sort(void) { scr_arr_release(wide); } +static void test_exact_construction(void) { + /* Construction reserves the requested slots (rounded up to the small + * allocator's block where it is live); appends past them grow + * geometrically, and every new slot starts as a hole. */ + ScrArr *one = scr_arr_new(SCR_ELEM_F64, 1); + check(one->cap >= 1 && one->cap < 4 && scr_arr_len(one) == 0 && !scr_arr_has(one, 0), + "one-slot construction keeps an exactly sized empty dense prefix"); + scr_arr_push_f64(one, 1); + size_t first_cap = one->cap; + for (int i = 2; i <= 6; i++) scr_arr_push_f64(one, i); + check(one->cap >= 6 && one->cap > first_cap && scr_arr_len(one) == 6, + "appends past an exact construction grow the dense prefix"); + for (int i = 0; i < 6; i++) check(scr_arr_get_number(one, i) == i + 1, "grown values kept"); + scr_arr_set_len(one, (double)one->cap + 3); + check(!scr_arr_has(one, 6) && !scr_arr_has(one, (double)one->cap - 1), + "spare capacity after growth from an exact size reads as holes"); + scr_arr_release(one); + + ScrArr *refs = scr_arr_new(SCR_ELEM_STR, 3); + scr_arr_push_ref(refs, scr_str_new("a", 1)); + scr_arr_set_ref(refs, 4, scr_str_new("e", 1)); + check(scr_arr_len(refs) == 5 && scr_arr_has(refs, 0) && !scr_arr_has(refs, 1) && + !scr_arr_has(refs, 3) && scr_arr_has(refs, 4), + "index write past an exact construction leaves holes between"); + scr_arr_release(refs); +} + int main(int argc, char **argv) { if (argc > 1) { ScrArr *a = scr_arr_new(SCR_ELEM_F64, 0); @@ -1135,6 +1165,7 @@ int main(int argc, char **argv) { test_numeric_read(); test_borrowed_ref_read(); test_bool(); + test_exact_construction(); test_dense_replacement(); test_unshift_reverse(); test_str_rc(); diff --git a/packages/runtime/test/test_map.c b/packages/runtime/test/test_map.c index 82c46b590..f9faffa59 100644 --- a/packages/runtime/test/test_map.c +++ b/packages/runtime/test/test_map.c @@ -126,6 +126,36 @@ static void test_string_keys(void) { scr_map_release(m); } +/* scr_map_entry_str: the entry of a string key, for generated code that + * reads the value slot and retains it with the value type's own retain. The + * lookup itself takes no reference, in linear and bucketed maps alike. */ +static void test_string_entries(void) { + ScrMap *m = scr_map_new(SCR_MAP_KEY_STR, SCR_MAP_VAL_REF, scr_str_retain_v, scr_str_release_v, NULL); + ScrStr *missing = S("missing"); + check(scr_map_entry_str(m, missing) == NULL, "empty map has no entry"); + char name[16]; + for (int i = 0; i < 40; i++) { + snprintf(name, sizeof name, "key%d", i); + ScrStr *k = S(name); + scr_map_set_str_ref(m, k, S(name)); /* value +1 moves in */ + scr_str_release(k); + ScrStr *probe = S("key0"); /* a different object with equal bytes */ + const ScrMapEntry *e = scr_map_entry_str(m, probe); + check(e != NULL, "entry found by content"); + ScrStr *v = (ScrStr *)(uintptr_t)e->val; + check(v->len == 4 && memcmp(v->data, "key0", 4) == 0, "entry value slot holds the value"); + check(v->rc == 1, "entry lookup takes no reference"); + scr_str_release(probe); + } + check(scr_map_entry_str(m, missing) == NULL, "absent key has no entry"); + ScrStr *k7 = S("key7"); + check(scr_map_delete_str(m, k7), "delete"); + check(scr_map_entry_str(m, k7) == NULL, "deleted key has no entry"); + scr_str_release(k7); + scr_str_release(missing); + scr_map_release(m); +} + /* String keys hash to 32 bits; heap strings cache the value in their header * and static strings (compiler literals, runtime one-character strings) * carry it precomputed. The vectors are shared with the compiler's @@ -558,6 +588,8 @@ static void test_value_keys_and_copies(void) { } #ifdef SCR_RC_AUDIT +static const ScrArrOps map_arr_ops = { scr_map_retain_v, scr_map_release_v, scr_map_trace_v }; + static void test_identity_cycles(void) { scr_collect_cycles(); long maps = scr_map_live_count(); @@ -566,7 +598,7 @@ static void test_identity_cycles(void) { long unions = scr_union_live_count(); for (int mode = 0; mode < 5; mode++) { for (int i = 0; i < 100; i++) { - ScrArr *key = scr_arr_new_ref(scr_map_retain_v, scr_map_release_v, scr_map_trace_v, 0); + ScrArr *key = scr_arr_new_ops(&map_arr_ops, 0); bool wrapped = mode >= 3; ScrMapValKind value_kind = mode == 0 ? SCR_MAP_VAL_F64 : SCR_MAP_VAL_REF; ScrTraceFn value_trace = mode == 2 ? scr_arr_trace_v : NULL; @@ -601,6 +633,7 @@ int main(void) { test_key_bytes(); test_string_bucket_collisions(); test_string_keys(); + test_string_entries(); test_same_value_zero(); test_span_keys(); test_string_hash_cache(); diff --git a/packages/types/README.md b/packages/types/README.md new file mode 100644 index 000000000..5436cee18 --- /dev/null +++ b/packages/types/README.md @@ -0,0 +1,25 @@ +# @scriptc/types + +Contract types for scriptc: type aliases with no meaning in TypeScript or Node.js that scriptc checks as extra promises. Import them with `import type`, which TypeScript erases, so Node.js never loads this package. + +```ts +import type { Immutable, Int32, NoThrow } from "@scriptc/types"; + +const KEYWORDS: Immutable> = new Map([["const", 1]]); + +class Token { + pos: Int32 = 0; +} + +function isLetter(ch: number): NoThrow { + return (ch >= 97 && ch <= 122) || (ch >= 65 && ch <= 90); +} +``` + +## Contracts + +- `NoThrow` on a function's return type: the function never throws. Callers need no exception checks. +- `Int32` on a parameter, variable, class instance field or function result: every stored value is a signed 32-bit integer by construction (an integer literal in range, a bitwise result such as `x | 0`, `Math.imul`, another `Int32`, or arithmetic scriptc can bound). The slot is stored as a 32-bit integer. +- `Immutable` on a parameter, variable, class instance field or function result: a deep read-only view, and no code writes to the value through any reference. A module constant built from literals becomes immortal data. + +scriptc proves each contract or rejects the program with a diagnostic (SC7001-SC7006) that explains why it does not hold. A program that compiles behaves exactly as under Node.js. See https://scriptc.dev/docs/contracts. diff --git a/packages/types/index.d.ts b/packages/types/index.d.ts new file mode 100644 index 000000000..28d26ec01 --- /dev/null +++ b/packages/types/index.d.ts @@ -0,0 +1,41 @@ +/* scriptc contract types. + * + * Type aliases with no runtime semantics: import them with `import type`, + * which TypeScript erases, so Node.js never loads this package and behaves + * exactly as without the annotations. scriptc recognizes the aliases where + * they are written (parameter, return, field, variable and property + * annotations) and checks each one as an extra contract: the program either + * compiles with identical behavior, plus the optimization the contract + * enables, or fails with a diagnostic that explains why the contract does + * not hold. */ + +/** A number that is always a signed 32-bit integer. Every value stored into + * an `Int32` slot (initializers, assignments, compound assignments, `++` and + * `--`, arguments and returns) must be an int32 by construction: an integer + * literal in range, a bitwise result such as `x | 0`, another `Int32` value, + * a string or array length, or arithmetic whose range scriptc can bound. + * scriptc then stores the slot as a 32-bit integer. */ +export type Int32 = number; + +/** Return-type wrapper: the function never throws. scriptc proves that no + * throw, throwing call or throwing operation can escape the function, or + * reports the path that can throw. Callers then need no exception checks + * after calls to it. */ +export type NoThrow = T; + +/** A deeply read-only view of `T`. TypeScript already rejects direct writes + * through it; scriptc also checks that no write reaches the value through + * any other path (methods that write `this`, aliases, casts, dynamic code). + * A module constant initialized from a literal or constructor becomes + * immortal data: never reference counted or collected. */ +export type Immutable = T extends (...args: never[]) => unknown + ? T + : T extends ReadonlyMap + ? ReadonlyMap, Immutable> + : T extends ReadonlySet + ? ReadonlySet> + : T extends readonly unknown[] + ? { readonly [I in keyof T]: Immutable } + : T extends object + ? { readonly [K in keyof T]: Immutable } + : T; diff --git a/packages/types/package.json b/packages/types/package.json new file mode 100644 index 000000000..b38d72760 --- /dev/null +++ b/packages/types/package.json @@ -0,0 +1,26 @@ +{ + "name": "@scriptc/types", + "version": "0.2.8", + "description": "Contract types for scriptc: type-only annotations (Int32, NoThrow, Immutable) that scriptc checks and optimizes, with no runtime semantics", + "license": "Apache-2.0", + "homepage": "https://scriptc.dev", + "repository": { + "type": "git", + "url": "git+https://github.com/vercel-labs/scriptc.git", + "directory": "packages/types" + }, + "type": "module", + "types": "index.d.ts", + "exports": { + ".": { + "types": "./index.d.ts" + } + }, + "files": [ + "index.d.ts", + "README.md" + ], + "engines": { + "node": ">=24.0.0" + } +} diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 1de030dbc..1f9f0cf64 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -14,6 +14,9 @@ importers: '@scriptc/threads': specifier: workspace:* version: link:packages/threads + '@scriptc/types': + specifier: workspace:* + version: link:packages/types '@types/node': specifier: ^24.0.0 version: 24.13.3 @@ -201,6 +204,8 @@ importers: packages/threads: {} + packages/types: {} + tests/fixtures/effect4: dependencies: '@effect/platform-node': diff --git a/scripts/sync-versions.mjs b/scripts/sync-versions.mjs index 8aba38c6b..6a3ad27d5 100644 --- a/scripts/sync-versions.mjs +++ b/scripts/sync-versions.mjs @@ -31,6 +31,7 @@ for (const pkg of [ "runtime-android-arm64", "compiler", "threads", + "types", "cli-darwin-arm64", "cli-darwin-x64", "cli-linux-x64-gnu", 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/corpus/4598-publish-constructor-stores.ts b/tests/corpus/4598-publish-constructor-stores.ts new file mode 100644 index 000000000..47f6c9f5e --- /dev/null +++ b/tests/corpus/4598-publish-constructor-stores.ts @@ -0,0 +1,145 @@ +import { publish } from "@scriptc/threads"; + +// Constructor stores into a `this` that nothing else can reach yet can never +// hit a published object, so scriptc drops their frozen-object guard. Every +// constructor below that lets `this` escape before or between its stores +// must keep the guard: the escaped object can be published before the +// constructor finishes, and Node.js then rejects the remaining stores. + +function attempt(label: string, f: () => void): void { + try { + f(); + console.log(`${label}: ok`); + } catch (e) { + console.log(`${label}: ${e instanceof TypeError ? "TypeError" : "other"}: ${(e as Error).message}`); + } +} + +// Private construction: plain field stores, a compound assignment (whose +// receiver is a temporary alias of `this`), then a self reference (which +// ends the private part: later reads of the field would hand `this` out). +class Plain { + flags = 1; + name: string; + self: Plain | undefined; + constructor(name: string, extra: number) { + this.name = name; + this.flags |= extra; + this.self = this; + } +} + +// The constructor publishes `this` before its last store. +class PublishesItself { + a: number; + b: number; + constructor() { + this.a = 1; + publish(this); + this.b = 2; + } +} + +// A base constructor registers `this`; the subclass constructor's store runs +// after a call that publishes everything registered. +const registry: Base[] = []; +class Base { + id: number; + constructor(id: number) { + this.id = id; + registry.push(this); + } +} +function publishRegistry(): number { + publish(registry); + return 7; +} +class Derived extends Base { + late: number; + constructor(id: number) { + super(id); + this.late = publishRegistry(); + } +} + +// `this` escapes through a closure created in the constructor. +let hook: (() => void) | undefined; +class Captured { + x: number; + y: number; + constructor() { + this.x = 1; + hook = () => { + publish(this); + }; + hook(); + this.y = 2; + } +} + +// `this` escapes as a method receiver. +class ViaMethod { + ready = false; + value = 0; + constructor() { + this.freeze(); + this.value = 5; + } + freeze(): void { + publish(this); + } +} + +attempt("plain", () => { + const p = new Plain("p", 6); + console.log(p.name, p.flags, p.self === p); + publish(p); + attempt("plain write after publish", () => { + p.flags = 9; + }); + attempt("plain compound after publish", () => { + p.flags |= 16; + }); + console.log(p.flags); +}); +attempt("publishes itself", () => { + new PublishesItself(); +}); +attempt("derived after base escape", () => { + new Derived(3); +}); +console.log(registry.length, registry[0]!.id); +attempt("captured", () => { + new Captured(); +}); +attempt("via method", () => { + new ViaMethod(); +}); + +// Many private constructions, published in bulk afterwards: every object +// stays writable until its own publish. +class Point { + x: number; + y: number; + next: Point | null; + constructor(x: number, y: number, next: Point | null) { + this.x = x; + this.y = y; + this.next = next; + } +} +let head: Point | null = null; +for (let i = 0; i < 1000; i++) head = new Point(i, i * 2, head); +let sum = 0; +for (let p = head; p !== null; p = p.next) { + p.y += 1; + sum += p.x + p.y; +} +console.log(sum); +publish(head); +attempt("point write after publish", () => { + head!.next!.x = 0; +}); +const fresh = new Point(1, 2, head); +fresh.x = 10; +console.log(fresh.x, fresh.next === head); diff --git a/tests/corpus/4599-construction-only-field-borrows.ts b/tests/corpus/4599-construction-only-field-borrows.ts new file mode 100644 index 000000000..f9e7f4bb4 --- /dev/null +++ b/tests/corpus/4599-construction-only-field-borrows.ts @@ -0,0 +1,149 @@ +// A field that is only ever written while its object is being constructed +// keeps its value for as long as the object lives, so scriptc reads it +// without taking a reference when the owner is an unchanged local. Each +// callee below drops every other reference it can reach before it uses the +// argument; fields that can be written later, and reads inside constructors +// (which may still write their own fields), must keep owning their values. + +class Item { + readonly name: string; + readonly tags: string[]; + constructor(name: string, tags: string[]) { + this.name = name; + this.tags = tags; + } +} + +class Holder { + readonly item: Item; + readonly next: Holder | null; + constructor(item: Item, next: Holder | null) { + this.item = item; + this.next = next; + } +} + +class Swappable { + item: Item; + constructor(item: Item) { + this.item = item; + } + swap(next: Item): void { + this.item = next; + } +} + +function describe(item: Item): string { + return `${item.name}[${item.tags.join(",")}]`; +} + +function useAfter(item: Item, drop: () => void): string { + drop(); + // Allocate so a freed item's memory would be reused. + const noise: Item[] = []; + for (let i = 0; i < 64; i++) noise.push(new Item(`noise${i}`, [`t${i}`])); + return describe(item) + ` (${noise.length})`; +} + +let global: Holder | null = new Holder(new Item("g", ["a", "b"]), null); + +// An unchanged local owns the holder while the callback drops the global. +function construction(): string { + const h = global!; + return useAfter(h.item, () => { + global = null; + }); +} + +// A chain of construction-only fields under one local root. +function chain(): string { + let list: Holder | null = null; + for (let i = 0; i < 4; i++) list = new Holder(new Item(`n${i}`, [`${i}`]), list); + global = list; + const root = global!; + return useAfter(root.next!.next!.item, () => { + global = null; + }); +} + +// A field the program writes after construction keeps its owner. +let swapper = new Swappable(new Item("old", ["x"])); +function swapGlobal(): void { + swapper.swap(new Item("new", ["y"])); +} +function written(): string { + const s = swapper; + const before = useAfter(s.item, swapGlobal); + return `${before} -> ${describe(s.item)}`; +} + +// A record field that is never written after the literal. +interface Pair { + left: Item; + right: Item; +} +let pairs: Pair[] = [{ left: new Item("l", ["1"]), right: new Item("r", ["2"]) }]; +function record(): string { + const p = pairs[0]!; + return useAfter(p.right, () => { + pairs = []; + }); +} + +// A stable alias of a construction-only field outlives later calls. +function alias(): string { + global = new Holder(new Item("alias", ["z"]), null); + const h = global; + const it = h.item; + global = null; + const noise: Holder[] = []; + for (let i = 0; i < 32; i++) noise.push(new Holder(new Item(`m${i}`, []), null)); + return `${describe(it)} ${noise.length}`; +} + +// A constructor reads its own field while a later operand replaces it. +function pair(a: Item, b: Item): string { + return `${describe(a)}+${describe(b)}`; +} +class Rebuilt { + current: Item; + label: string; + constructor(first: Item, second: Item) { + this.current = first; + this.label = pair(this.current, (this.current = second)); + } +} +function constructorRead(): string { + const r = new Rebuilt(new Item("first", ["f"]), new Item("second", ["s"])); + return `${r.label} now ${describe(r.current)}`; +} + +// A module constant can be read without a reference. +const TABLE: Item[] = [new Item("t0", ["k"]), new Item("t1", ["k", "l"])]; +function tableSize(items: Item[], drop: () => void): number { + drop(); + return items.length + items[1]!.tags.length; +} +function moduleConstant(): string { + return `${tableSize(TABLE, () => { + global = null; + })}`; +} + +console.log(construction()); +console.log(chain()); +console.log(written()); +console.log(record()); +console.log(alias()); +console.log(constructorRead()); +console.log(moduleConstant()); + +let total = 0; +for (let round = 0; round < 2000; round++) { + global = new Holder(new Item(`r${round}`, ["q"]), new Holder(new Item("inner", []), null)); + const h = global; + total += useAfter(h.next!.item, () => { + global = null; + }).length; +} +console.log(total); diff --git a/tests/corpus/4600-construction-only-fields-dynamic-writes.ts b/tests/corpus/4600-construction-only-fields-dynamic-writes.ts new file mode 100644 index 000000000..6114046f0 --- /dev/null +++ b/tests/corpus/4600-construction-only-fields-dynamic-writes.ts @@ -0,0 +1,62 @@ +// Untyped code can write a field that the typed program only assigns in its +// constructor: the class instance keeps its identity behind `any`, and the +// write lands in the native field. Once a program contains such a store, +// every field reachable from a value that crosses into untyped code must be +// treated as writable, so reads of it keep owning their values while a +// callee replaces them. + +class Item { + readonly name: string; + constructor(name: string) { + this.name = name; + } +} + +class Holder { + readonly item: Item; + readonly label: string; + constructor(item: Item, label: string) { + this.item = item; + this.label = label; + } +} + +function replace(target: any, value: any): void { + target.item = value; +} + +let shared = new Holder(new Item("before"), "h"); + +function useAfter(item: Item, drop: () => void): string { + drop(); + const noise: Item[] = []; + for (let i = 0; i < 64; i++) noise.push(new Item(`noise${i}`)); + return `${item.name} (${noise.length})`; +} + +function viaAny(): string { + const h = shared; + const seen = useAfter(h.item, () => { + replace(shared, new Item("after")); + }); + return `${seen} -> ${h.item.name}`; +} + +const box: { holder: Holder } = { holder: new Holder(new Item("boxed"), "b") }; +function viaRecord(): string { + const b = box; + const seen = useAfter(b.holder.item, () => { + (b.holder as unknown as { item: Item }).item = new Item("cast"); + }); + return `${seen} -> ${b.holder.item.name}`; +} + +console.log(viaAny()); +console.log(viaRecord()); +let n = 0; +for (let i = 0; i < 500; i++) { + shared = new Holder(new Item(`r${i}`), "loop"); + const h = shared; + n += useAfter(h.item, () => replace(shared, new Item("x"))).length + h.item.name.length; +} +console.log(n); diff --git a/tests/corpus/4630-contract-int32.ts b/tests/corpus/4630-contract-int32.ts new file mode 100644 index 000000000..39f6cc9fe --- /dev/null +++ b/tests/corpus/4630-contract-int32.ts @@ -0,0 +1,88 @@ +// Int32 contract types (@scriptc/types): every value stored into an Int32 +// slot is an int32 by construction, so Node computes the same values and +// scriptc stores the slots as 32-bit integers. `import type` is erased: +// Node never loads the package. +import type { Int32 } from "@scriptc/types"; + +class Cursor { + pos: Int32 = 0; + end: Int32; + readonly id: Int32; + constructor(end: Int32, id: Int32) { + this.end = end; + this.id = id; + } + advance(n: Int32): void { + this.pos = (this.pos + n) | 0; + } + atEnd(): boolean { + return this.pos >= this.end; + } +} + +class Shape { + area(scale: Int32): Int32 { + return scale & 0; + } +} + +class Square extends Shape { + side: Int32; + constructor(side: Int32) { + super(); + this.side = side; + } + override area(scale: Int32): Int32 { + return Math.imul(Math.imul(this.side, this.side), scale); + } +} + +function fnv1a(text: string): Int32 { + let h: Int32 = 0x811c9dc5 | 0; + for (let i: Int32 = 0; i < text.length; i++) { + h = Math.imul(h ^ text.charCodeAt(i), 16777619); + } + return h; +} + +function clamp(i: Int32, lo: Int32, hi: Int32): Int32 { + return i < lo ? lo : i > hi ? hi : i; +} + +let nextId: Int32 = 0; +function allocateId(): Int32 { + nextId = (nextId + 1) | 0; + return nextId; +} + +function total(values: number[]): Int32 { + let sum: Int32 = 0; + values.forEach((v) => { + sum = (sum + v) | 0; + }); + return sum; +} + +function countdown(from: Int32): Int32 { + let steps: Int32 = 0; + for (let i: Int32 = from; i > 0; i--) steps = (steps + 1) | 0; + return steps; +} + +const cursor = new Cursor(10, allocateId()); +while (!cursor.atEnd()) cursor.advance(3); +console.log("cursor", cursor.pos, cursor.end, cursor.id); + +const shapes: Shape[] = [new Shape(), new Square(7), new Square(46341)]; +for (const s of shapes) console.log("area", s.area(2)); + +console.log("fnv1a", fnv1a(""), fnv1a("scriptc"), fnv1a("contract types")); +console.log("clamp", clamp(-5, 0, 9), clamp(4, 0, 9), clamp(99, 0, 9)); +console.log("ids", allocateId(), allocateId()); +console.log("total", total([1, 2.5, 2147483647, 3])); +console.log("wrap", (2147483647 + 1) | 0, ~0, -1 >>> 28 | 0); +console.log("countdown", countdown(5), countdown(-3)); +const big = new Cursor(2147483647, -2147483648); +big.advance(2147483647); +big.advance(1); +console.log("big", big.pos, big.end, big.id, big.atEnd()); diff --git a/tests/corpus/4630-reference-write-call-arguments.ts b/tests/corpus/4630-reference-write-call-arguments.ts new file mode 100644 index 000000000..6a2160bd2 --- /dev/null +++ b/tests/corpus/4630-reference-write-call-arguments.ts @@ -0,0 +1,119 @@ +// Field reads and rebound locals passed to borrowing callees: borrowed only +// when neither the callee nor a later argument can replace them. Each +// "replaces" case makes the field the value's last owner, frees it inside +// the call, churns the allocator and then reads the argument again. + +class Name { + text: string; + parts: string[]; + constructor(text: string) { + this.text = text; + this.parts = text.split(""); + } +} + +class Holder { + name: Name | undefined; + other: Name | undefined = undefined; + items: Name[] = []; + constructor(name: Name) { + this.name = name; + } +} + +function churn(): number { + let total = 0; + for (let i = 0; i < 200; i++) total += new Name("churn-" + i).parts.length; + return total; +} + +function describe(n: Name | undefined): string { + if (n === undefined) return "none"; + return n.text + ":" + n.parts.length; +} + +// Writes an unrelated field: the caller may lend `h.name`. +function touchOther(h: Holder, n: Name | undefined): string { + h.other = new Name("other"); + churn(); + return describe(n); +} + +// Replaces the very field the caller passed: the argument must be owned. +function replaceName(h: Holder, n: Name | undefined): string { + h.name = new Name("replacement"); + churn(); + return describe(n); +} + +// Removes array elements: an element argument must be owned. +function dropItems(h: Holder, n: Name): string { + h.items.length = 0; + churn(); + return describe(n); +} + +function compose(a: string, b: string): string { + return a + "|" + b; +} + +function later(h: Holder): string { + h.name = new Name("later"); + churn(); + return "later"; +} + +// A later argument replaces the field an earlier argument read. +function laterArgument(h: Holder): string { + return compose(describe2(h.name), later(h)); +} +function describe2(n: Name | undefined): string { + churn(); + return describe(n); +} + +// A rebound parameter passed along: no callee can rebind the caller's local. +function rebound(n: Name, h: Holder): string { + if (n.text.length > 3) n = h.name ?? n; + return replaceAndDescribe(n, h) + " " + describe(n); +} +function replaceAndDescribe(n: Name, h: Holder): string { + h.name = undefined; + churn(); + return describe(n); +} + +// A constructor's stores into its own fresh object replace nothing the +// caller lends; a constructor storing into another object does. +class Attach { + label: Name; + constructor(h: Holder, label: Name) { + h.name = undefined; + churn(); + this.label = new Name("own-" + label.text); + } +} +function construct(h: Holder): string { + const a = new Attach(h, h.name!); + return a.label.text; +} + +const h1 = new Holder(new Name("first")); +console.log(touchOther(h1, h1.name)); +const h2 = new Holder(new Name("second")); +console.log(replaceName(h2, h2.name), describe(h2.name)); +const h3 = new Holder(new Name("third")); +h3.items.push(new Name("item0"), new Name("item1")); +console.log(dropItems(h3, h3.items[1]!)); +const h4 = new Holder(new Name("fourth")); +console.log(laterArgument(h4), describe(h4.name)); +const h5 = new Holder(new Name("fifth-name")); +console.log(rebound(new Name("sixth"), h5)); +const h6 = new Holder(new Name("seventh")); +console.log(construct(h6), describe(h6.name)); +let sum = 0; +for (let i = 0; i < 50; i++) { + const h = new Holder(new Name("loop" + i)); + sum += touchOther(h, h.name).length + replaceName(h, h.name).length; +} +console.log("sum", sum); diff --git a/tests/corpus/4631-contract-nothrow.ts b/tests/corpus/4631-contract-nothrow.ts new file mode 100644 index 000000000..4a6ca30c6 --- /dev/null +++ b/tests/corpus/4631-contract-nothrow.ts @@ -0,0 +1,63 @@ +// NoThrow contract types (@scriptc/types): scriptc proves these functions +// cannot throw, so callers need no exception checks after the calls. +import type { Int32, NoThrow } from "@scriptc/types"; + +function isDigit(ch: number): NoThrow { + return ch >= 48 && ch <= 57; +} + +function isIdentifierStart(ch: number): NoThrow { + return (ch >= 65 && ch <= 90) || (ch >= 97 && ch <= 122) || ch === 95 || ch === 36; +} + +function digitValue(ch: number): NoThrow { + return isDigit(ch) ? (ch - 48) | 0 : -1; +} + +class Scanner { + readonly text: string; + pos: Int32 = 0; + constructor(text: string) { + this.text = text; + } + peek(): NoThrow { + return this.pos < this.text.length ? this.text.charCodeAt(this.pos) : -1; + } + skipSpaces(): NoThrow { + while (this.peek() === 32) this.pos = (this.pos + 1) | 0; + } + scanNumber(): NoThrow { + let value: Int32 = 0; + while (isDigit(this.peek())) { + value = (Math.imul(value, 10) + digitValue(this.peek())) | 0; + this.pos = (this.pos + 1) | 0; + } + return value; + } + scanWord(): NoThrow { + const start = this.pos; + while (isIdentifierStart(this.peek()) || isDigit(this.peek())) this.pos = (this.pos + 1) | 0; + return this.text.slice(start, this.pos); + } +} + +function tokens(text: string): string[] { + const scanner = new Scanner(text); + const out: string[] = []; + for (;;) { + scanner.skipSpaces(); + const ch = scanner.peek(); + if (ch < 0) break; + if (isDigit(ch)) out.push(`num:${scanner.scanNumber()}`); + else if (isIdentifierStart(ch)) out.push(`word:${scanner.scanWord()}`); + else { + out.push(`punct:${String.fromCharCode(ch)}`); + scanner.pos = (scanner.pos + 1) | 0; + } + } + return out; +} + +console.log(tokens("let x1 = 42 + y; // 7").join(" ")); +console.log(tokens(" 2147483648 $id _x").join(" ")); +console.log(digitValue(55), digitValue(65), isIdentifierStart(36)); diff --git a/tests/corpus/4631-reference-write-aliases.ts b/tests/corpus/4631-reference-write-aliases.ts new file mode 100644 index 000000000..4d5e04ecb --- /dev/null +++ b/tests/corpus/4631-reference-write-aliases.ts @@ -0,0 +1,116 @@ +// `const t = o.f` borrows the field only when the rest of its block writes +// none of the locations keeping the value alive; returning or storing the +// alias still takes its own reference. + +class Leaf { + text: string; + constructor(text: string) { + this.text = text; + } +} + +class Box { + leaf: Leaf; + spare: Leaf | undefined = undefined; + list: Leaf[] = []; + constructor(leaf: Leaf) { + this.leaf = leaf; + } +} + +function churn(): number { + let total = 0; + for (let i = 0; i < 200; i++) total += new Leaf("x" + i).text.length; + return total; +} + +// No write to `leaf` in the block: borrowed. +function readOnly(b: Box): string { + const t = b.leaf; + b.spare = new Leaf("spare"); + churn(); + return t.text + "/" + b.spare.text; +} + +// The block replaces the field: the alias must own its value. +function replaced(b: Box): string { + const t = b.leaf; + b.leaf = new Leaf("new"); + churn(); + return t.text + "->" + b.leaf.text; +} + +// The replacement happens in a callee. +function swap(b: Box): void { + b.leaf = new Leaf("swapped"); + churn(); +} +function replacedInCallee(b: Box): string { + const t = b.leaf; + swap(b); + return t.text; +} + +// Element aliases and removals. +function element(b: Box): string { + const first = b.list[0]!; + b.list.pop(); + b.list.length = 0; + churn(); + return first.text; +} + +// The alias escapes into a store and a return value. +function escape(b: Box, other: Box): Leaf { + const t = b.leaf; + other.spare = t; + b.leaf = new Leaf("gone"); + churn(); + return t; +} + +// Aliases in loop bodies are fresh per iteration; `continue` ends one. +function loop(boxes: Box[]): string { + const out: string[] = []; + for (let i = 0; i < boxes.length; i++) { + const t = boxes[i]!.leaf; + if (i % 2 === 0) { + out.push(t.text); + continue; + } + boxes[i]!.leaf = new Leaf("odd" + i); + churn(); + out.push(t.text); + } + return out.join(","); +} + +// A switch case's bindings live for the whole switch. +function sw(b: Box, k: number): string { + let s = ""; + switch (k) { + case 0: { + const t = b.leaf; + b.leaf = new Leaf("case0"); + churn(); + s = t.text; + break; + } + default: + s = b.leaf.text; + } + return s; +} + +console.log(readOnly(new Box(new Leaf("ro")))); +console.log(replaced(new Box(new Leaf("old")))); +console.log(replacedInCallee(new Box(new Leaf("callee")))); +const withList = new Box(new Leaf("l")); +withList.list.push(new Leaf("e0"), new Leaf("e1")); +console.log(element(withList)); +const other = new Box(new Leaf("other")); +console.log(escape(new Box(new Leaf("escaped")), other).text, other.spare?.text); +const boxes: Box[] = []; +for (let i = 0; i < 6; i++) boxes.push(new Box(new Leaf("b" + i))); +console.log(loop(boxes), boxes.map((b) => b.leaf.text).join(" ")); +console.log(sw(new Box(new Leaf("sw0")), 0), sw(new Box(new Leaf("sw1")), 1)); diff --git a/tests/corpus/4632-contract-immutable.ts b/tests/corpus/4632-contract-immutable.ts new file mode 100644 index 000000000..a4e412cb7 --- /dev/null +++ b/tests/corpus/4632-contract-immutable.ts @@ -0,0 +1,73 @@ +// Immutable contract types (@scriptc/types): no write can reach these +// values, and module constants built from fresh literals become immortal +// in scriptc (never reference counted or collected). Node sees ordinary +// objects: the annotations are erased. +import type { Immutable } from "@scriptc/types"; + +class Keyword { + readonly text: string; + readonly kind: number; + constructor(text: string, kind: number) { + this.text = text; + this.kind = kind; + } + describe(): string { + return `${this.text}#${this.kind}`; + } +} + +const KEYWORDS: Immutable> = new Map([ + ["let", new Keyword("let", 1)], + ["const", new Keyword("const", 2)], + ["function", new Keyword("function", 3)], +]); + +const CHAR_CLASSES: Immutable = [0, 0, 1, 1, 2, 2, 3, 3]; + +const LIMITS: Immutable<{ name: string; max: number; tags: string[] }> = { + name: "limits", + max: 64, + tags: ["a", "b"], +}; + +function buildTable(size: number): number[] { + const table: number[] = []; + for (let i = 0; i < size; i++) table.push((i * 7) % 5); + return table; +} + +const TABLE: Immutable = buildTable(12); + +function lookup(word: string): string { + const k = KEYWORDS.get(word); + return k === undefined ? "none" : k.describe(); +} + +function classify(codes: Immutable, i: number): number { + return i < codes.length ? codes[i]! : -1; +} + +let hits = 0; +for (const word of ["let", "var", "function", "const", "class"]) { + const result = lookup(word); + if (result !== "none") hits++; + console.log(word, result); +} +console.log("hits", hits, "size", KEYWORDS.size); +console.log("classes", classify(CHAR_CLASSES, 3), classify(CHAR_CLASSES, 9), CHAR_CLASSES.join(",")); +console.log("limits", LIMITS.name, LIMITS.max, LIMITS.tags.length, LIMITS.tags.join("|")); +console.log("table", TABLE.join(""), TABLE.indexOf(4), TABLE.includes(9)); +const copy = TABLE.slice(0, 4); +copy.push(99); +console.log("copy", copy.join(","), "original", TABLE.length); +for (const [text, keyword] of KEYWORDS) console.log("entry", text, keyword.kind); + +// Element writes at provable array indexes keep a factory's result fresh. +function squares(): number[] { + const table: number[] = []; + for (let i = 0; i < 6; i++) table[i] = i * i; + return table; +} + +const SQUARES: Immutable = squares(); +console.log(SQUARES.join(","), classify(SQUARES, 5)); diff --git a/tests/corpus/4632-reference-write-loops-and-walks.ts b/tests/corpus/4632-reference-write-loops-and-walks.ts new file mode 100644 index 000000000..98fcdbad3 --- /dev/null +++ b/tests/corpus/4632-reference-write-loops-and-walks.ts @@ -0,0 +1,116 @@ +// Loop element borrows, optional element reads, parent walks and borrowed +// returns in bodies that write the heap: borrowed only while nothing the +// body (or a callee) writes can release the lent value. + +class Item { + name: string; + parent: Item | undefined; + note: string | undefined = undefined; + constructor(name: string, parent: Item | undefined) { + this.name = name; + this.parent = parent; + } +} + +function churn(): number { + let total = 0; + for (let i = 0; i < 100; i++) total += new Item("c" + i, undefined).name.length; + return total; +} + +// The body writes another field of each element: elements stay lent. +function annotate(items: Item[]): string { + const names: string[] = []; + for (const it of items) { + it.note = "seen:" + it.name; + names.push(it.name); + } + return names.join(","); +} + +// The body removes elements from the iterated array: elements are owned. +function drain(items: Item[]): string { + const names: string[] = []; + for (const it of items) { + items.length = 0; + churn(); + names.push(it.name); + } + return names.join(","); +} + +// Indexed loop with an optional element read and an unrelated write. +function indexed(items: Item[], log: string[]): string { + let s = ""; + for (let i = 0; i < items.length + 1; i++) { + const it = items[i]; + log.push("i" + i); + s += it === undefined ? "-" : it.name; + } + return s; +} + +// Indexed loop replacing the element it just read. +function replaceEach(items: Item[]): string { + let s = ""; + for (let i = 0; i < items.length; i++) { + const it = items[i]; + items[i] = new Item("r" + i, undefined); + churn(); + s += it === undefined ? "-" : it.name; + } + return s; +} + +// A parent walk in a body that writes notes: the walk borrows. +function rootWithNotes(it: Item): string { + let p = it; + while (p.parent !== undefined) { + p.note = "walked"; + p = p.parent; + } + return p.name; +} + +// A walk whose body detaches parents: the walk owns its steps. +function detach(it: Item): string { + let p = it; + let s = ""; + while (p.parent !== undefined) { + const next = p.parent; + p.parent = undefined; + churn(); + s += next.name; + p = next; + } + return s; +} + +// A borrowed return from a body that writes elsewhere, consumed after a +// call that writes notes. +function topOf(it: Item, log: string[]): Item { + log.push("top"); + let p = it; + while (p.parent !== undefined) p = p.parent; + return p; +} +function useTop(it: Item, log: string[]): string { + const top = topOf(it, log); + annotate([it]); + return top.name + ":" + (it.note ?? ""); +} + +const chain: Item[] = []; +let prev: Item | undefined = undefined; +for (let i = 0; i < 8; i++) { + prev = new Item("n" + i, prev); + chain.push(prev); +} +const log: string[] = []; +console.log(annotate(chain.slice()), chain[3]!.note); +console.log(drain(chain.slice(0, 4))); +console.log(indexed(chain.slice(0, 3), log), log.length); +console.log(replaceEach(chain.slice(0, 3))); +console.log(rootWithNotes(chain[7]!), chain[4]!.note); +console.log(useTop(chain[6]!, log), log.join("")); +console.log(detach(chain[7]!), chain[7]!.parent, chain[2]!.parent); diff --git a/tests/corpus/4633-reference-write-callbacks-returns.ts b/tests/corpus/4633-reference-write-callbacks-returns.ts new file mode 100644 index 000000000..8ba1e8991 --- /dev/null +++ b/tests/corpus/4633-reference-write-callbacks-returns.ts @@ -0,0 +1,98 @@ +// Closure calls resolved through callback parameters, adapters and +// captures, and owned locals moved into return values. + +class Cell { + value: string; + next: Cell | undefined = undefined; + constructor(value: string) { + this.value = value; + } +} + +class Store { + cell: Cell; + constructor(cell: Cell) { + this.cell = cell; + } +} + +function churn(): number { + let n = 0; + for (let i = 0; i < 100; i++) n += new Cell("k" + i).value.length; + return n; +} + +function show(c: Cell | undefined): string { + return c === undefined ? "none" : c.value; +} + +// The callback a caller passes replaces the field the caller lends. +function withCallback(s: Store, c: Cell, f: (s: Store) => void): string { + f(s); + churn(); + return show(c); +} +function each(cells: Cell[], f: (c: Cell) => string): string { + return cells.map(f).join(","); +} + +// Captured state written by the callback. +function capture(s: Store): string { + let seen = s.cell; + const record = (c: Cell): string => { + seen = c; + return c.value; + }; + const listed = each([new Cell("a"), new Cell("b")], record); + return listed + " " + seen.value; +} + +// Returning owned locals: plain, from a loop, and through a finally. +function build(n: number): Cell { + const head = new Cell("head" + n); + let cur = head; + for (let i = 0; i < n; i++) { + const c = new Cell("c" + i); + cur.next = c; + cur = c; + } + return head; +} +function pick(cells: Cell[], want: string): Cell | undefined { + for (const c of cells) { + const found = c; + if (found.value === want) return found; + } + return undefined; +} +function guarded(n: number): Cell { + const c = new Cell("guarded" + n); + try { + if (n > 1) return c; + return new Cell("small"); + } finally { + c.value += "!"; + } +} + +const s1 = new Store(new Cell("one")); +console.log( + withCallback(s1, s1.cell, (s) => { + s.cell = new Cell("replaced"); + }), + s1.cell.value, +); +const s2 = new Store(new Cell("two")); +console.log(withCallback(s2, s2.cell, () => {}), s2.cell.value); +console.log(capture(new Store(new Cell("start")))); +let walk: Cell | undefined = build(3); +const parts: string[] = []; +while (walk !== undefined) { + parts.push(walk.value); + walk = walk.next; +} +console.log(parts.join(">")); +const cells = [new Cell("x"), new Cell("y"), new Cell("z")]; +console.log(show(pick(cells, "y")), show(pick(cells, "w"))); +console.log(guarded(2).value, guarded(0).value); +console.log(each(cells, (c) => c.value.toUpperCase())); diff --git a/tests/corpus/4634-optional-element-borrowed-returns.ts b/tests/corpus/4634-optional-element-borrowed-returns.ts new file mode 100644 index 000000000..dab04a34b --- /dev/null +++ b/tests/corpus/4634-optional-element-borrowed-returns.ts @@ -0,0 +1,47 @@ +// Optional element reads (`arr[i]` of `T | undefined` elements) lower to +// helpers that now lend the element their array keeps alive: paged lookups +// borrow, and reads followed by removals still own what they keep. + +class Link { + name: string; + constructor(name: string) { + this.name = name; + } +} + +class Pages { + pages: (Link[] | undefined)[] = []; + get(id: number): Link { + let link = this.pages[id >> 3]?.[id & 7]; + if (link === undefined) { + let page = this.pages[id >> 3]; + if (page === undefined) { + page = []; + this.pages[id >> 3] = page; + } + link = new Link("l" + id); + page[id & 7] = link; + } + return link; + } +} + +function first(links: Link[]): string { + const head = links[0]; + return head === undefined ? "none" : head.name; +} + +const shared: Link[] = [new Link("x"), new Link("y")]; +function readThenClear(): string { + const kept = shared[1]; + shared.length = 0; + let churn = 0; + for (let i = 0; i < 100; i++) churn += new Link("c" + i).name.length; + return (kept === undefined ? "-" : kept.name) + churn; +} + +const pages = new Pages(); +const seen: string[] = []; +for (let i = 0; i < 40; i++) seen.push(pages.get((i * 7) % 19).name); +console.log(seen.join(" ")); +console.log(first([]), first([new Link("a")]), readThenClear(), shared.length); 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); diff --git a/tests/corpus/4651-map-string-get-entry.ts b/tests/corpus/4651-map-string-get-entry.ts new file mode 100644 index 000000000..6319d3a13 --- /dev/null +++ b/tests/corpus/4651-map-string-get-entry.ts @@ -0,0 +1,99 @@ +// String-keyed Map.get of reference values reads the entry and retains the +// value with its static type's retain. Results must outlive the entry: they +// survive delete, overwrite, clear and the map itself, for class instances, +// records, arrays, nested maps, cyclic objects and union-typed values, with +// literal, computed and sliced keys. +class Node { + name: string; + next: Node | undefined = undefined; + constructor(name: string) { + this.name = name; + } +} + +interface Box { + label: string; + items: number[]; +} + +const nodes = new Map(); +for (let i = 0; i < 20; i++) nodes.set("n" + i, new Node("node-" + i)); +const a = nodes.get("n3"); +const b = nodes.get("n" + (1 + 2) * 4); +const missing = nodes.get("nope"); +console.log(a?.name, b?.name, missing === undefined); +nodes.delete("n3"); +nodes.set("n12", new Node("replacement")); +console.log("after delete/overwrite:", a?.name, b?.name, nodes.get("n12")?.name); + +// A cycle through the map value and the result. +const ring = new Map(); +const first = new Node("first"); +const second = new Node("second"); +first.next = second; +second.next = first; +ring.set("first", first); +ring.set("second", second); +const viaMap = ring.get("second"); +ring.clear(); +console.log("cycle:", viaMap?.next?.next?.name, ring.size); + +// Records and arrays as values; keys sliced from a larger string. +const boxes = new Map(); +const source = "alpha,beta,gamma"; +for (const part of source.split(",")) boxes.set(part, { label: part.toUpperCase(), items: [part.length] }); +const keyed = boxes.get(source.slice(6, 10)); +boxes.set("beta", { label: "B2", items: [] }); +console.log("box:", keyed?.label, keyed?.items.join("|"), boxes.get("beta")?.label); +const lists = new Map([["evens", [0, 2, 4]], ["odds", [1, 3]]]); +const evens = lists.get("evens"); +lists.delete("evens"); +evens?.push(6); +console.log("array:", evens?.join(","), lists.has("evens")); + +// Maps as values: the inner map outlives its entry in the outer one. +const outer = new Map>(); +outer.set("inner", new Map([["x", new Node("inner-x")]])); +const inner = outer.get("inner"); +outer.delete("inner"); +inner?.set("y", new Node("inner-y")); +console.log("nested:", inner?.get("x")?.name, inner?.get("y")?.name, outer.size); + +// Union-typed values: nullable instances and mixed arms. +const maybe = new Map(); +maybe.set("set", new Node("present")); +maybe.set("null", null); +const present = maybe.get("set"); +const isNull = maybe.get("null"); +const absent = maybe.get("absent"); +maybe.delete("set"); +console.log("nullable:", present?.name, isNull === null, absent === undefined); +const mixed = new Map(); +mixed.set("node", new Node("mixed-node")); +mixed.set("text", "plain"); +const m1 = mixed.get("node"); +const m2 = mixed.get("text"); +mixed.set("node", "overwritten"); +console.log("mixed:", typeof m1 === "string" ? m1 : m1?.name, m2, mixed.get("node")); + +// Many lookups through a growing map (linear scan, then buckets), keeping +// every result alive past the map. +function collect(): Node[] { + const table = new Map(); + const out: Node[] = []; + for (let i = 0; i < 64; i++) { + table.set(`k${i}`, new Node(`v${i}`)); + const back = table.get(`k${Math.floor(i / 2)}`); + if (back !== undefined) out.push(back); + } + return out; +} +const kept = collect(); +console.log("kept:", kept.length, kept[0]!.name, kept[63]!.name); + +// A result held in a local across a loop that rewrites the entry. +const counters = new Map(); +counters.set("c", { label: "start", items: [] }); +const held = counters.get("c")!; +for (let i = 0; i < 5; i++) counters.set("c", { label: "round" + i, items: [i] }); +console.log("held:", held.label, counters.get("c")?.label); 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()); diff --git a/tests/corpus/4691-publish-constructor-self-alias.ts b/tests/corpus/4691-publish-constructor-self-alias.ts new file mode 100644 index 000000000..01ff2b8c2 --- /dev/null +++ b/tests/corpus/4691-publish-constructor-self-alias.ts @@ -0,0 +1,68 @@ +import { Worker, isMainThread, workerData } from "node:worker_threads"; +import { publish } from "@scriptc/threads"; + +// A constructor that stores `this` into one of its own fields and then hands +// that field to other code has let `this` escape: the object may already be +// published, so every later store must still hit the frozen-object guard. +// Node.js deep-freezes the published object and throws on those stores, and +// a worker receiving the object sees only the values written before. + +let shared: Job | undefined; + +class Job { + label: string; + value = 1; + self: Job; + constructor(label: string) { + this.label = label; + this.self = this; + shared = publish(this.self); + this.value = 2; + } +} + +// The self alias escapes into a registry that is published later. +const registry: Task[] = []; +function publishRegistry(): number { + publish(registry); + return 3; +} + +class Task { + me: Task; + count = 0; + constructor() { + this.me = this; + registry.push(this.me); + this.count = publishRegistry(); + } +} + +function attempt(label: string, f: () => void): void { + try { + f(); + console.log(`${label}: ok`); + } catch (e) { + console.log(`${label}: ${e instanceof TypeError ? "TypeError" : "other"}: ${(e as Error).message}`); + } +} + +if (isMainThread) { + attempt("publishes self alias", () => { + new Job("job"); + }); + const job = shared!; + console.log("main sees", job.label, job.value, job.self === job); + attempt("registers self alias", () => { + new Task(); + }); + console.log("registry", registry.length, registry[0]!.count, registry[0]!.me === registry[0]); + const worker = new Worker(new URL(import.meta.url), { workerData: { job } }); + worker.on("exit", (code: number) => { + console.log("exit", code); + }); +} else { + const data = workerData as { job: Job }; + const job = publish(data.job); + console.log("worker sees", job.label, job.value, job.self === job); +} diff --git a/tests/corpus/4692-borrowed-result-mutating-callees.ts b/tests/corpus/4692-borrowed-result-mutating-callees.ts new file mode 100644 index 000000000..4bc5c145f --- /dev/null +++ b/tests/corpus/4692-borrowed-result-mutating-callees.ts @@ -0,0 +1,78 @@ +// A call whose result is read right away (a receiver) may lend its +// arguments only while the callee cannot replace what they were read from. +// Each helper below makes the caller's field (or array) the argument's last +// owner, replaces it, churns the allocator, reads the argument again and +// returns it, so the caller projects the returned object afterwards. + +class Name { + text: string; + parts: string[]; + constructor(text: string) { + this.text = text; + this.parts = text.split(""); + } +} + +class Holder { + name: Name; + maybe: Name | undefined; + items: Name[] = []; + constructor(name: Name) { + this.name = name; + this.maybe = new Name("maybe-" + name.text); + } +} + +function churn(): number { + let total = 0; + for (let i = 0; i < 200; i++) total += new Name("churn-" + i).parts.length; + return total; +} + +// Replaces the field the caller passed, then returns the argument. +function replaceName(h: Holder, n: Name): Name { + h.name = new Name("replacement"); + churn(); + console.log("inside", n.text, n.parts.length); + return n; +} + +// Clears the optional field the caller passed. +function clearMaybe(h: Holder, n: Name): Name { + h.maybe = undefined; + churn(); + console.log("inside", n.text, n.parts.length); + return n; +} + +// Empties the array whose element the caller passed. +function dropItems(h: Holder, n: Name): Name { + h.items.length = 0; + churn(); + console.log("inside", n.text, n.parts.length); + return n; +} + +// Writes an unrelated field: lending the argument stays sound. +function touchItems(h: Holder, n: Name): Name { + h.items.push(new Name("pushed")); + churn(); + return n; +} + +function run(round: number): void { + const h = new Holder(new Name("first-" + round)); + console.log("name", replaceName(h, h.name).text); + console.log("parts", replaceName(h, h.name).parts.length); + const m = h.maybe; + if (m !== undefined) console.log("maybe", clearMaybe(h, m).text); + h.maybe = new Name("again-" + round); + if (h.maybe !== undefined) console.log("maybe again", clearMaybe(h, h.maybe).parts.length); + h.items.push(new Name("item-" + round)); + console.log("item", dropItems(h, h.items[0]!).text); + h.items.push(new Name("kept-" + round)); + console.log("kept", touchItems(h, h.name).text, h.items.length); + console.log("final", h.name.text, h.items.length); +} + +for (let round = 0; round < 3; round++) run(round); diff --git a/tests/corpus/switch-integer-dispatch.ts b/tests/corpus/switch-integer-dispatch.ts new file mode 100644 index 000000000..de6890a59 --- /dev/null +++ b/tests/corpus/switch-integer-dispatch.ts @@ -0,0 +1,130 @@ +// Literal integer switches dispatch through a native jump: a frozen +// conversion plus an exact round trip rejects NaN, infinities, fractions +// and out-of-range values, -0 selects case 0, and a discriminant already +// proven to be an integer selects without converting at all. + +function small(x: number): string { + switch (x) { + case 0: + return "zero"; + case 1: + return "one"; + case 2: + return "two"; + case 3: + return "three"; + case -1: + return "minus one"; + default: + return "other"; + } +} + +function wide(x: number): string { + switch (x) { + case -2147483648: + return "int32 min"; + case 2147483647: + return "int32 max"; + case 2147483648: + return "past int32"; + case 4294967295: + return "uint32 max"; + case 9007199254740991: + return "safe max"; + case -9007199254740991: + return "safe min"; + default: + return "other"; + } +} + +function proven(x: number): string { + switch (x | 0) { + case 0: + return "a"; + case 1: + return "b"; + case 2: + return "c"; + case 3: + return "d"; + case -5: + return "e"; + default: + return "f"; + } +} + +function provenUnsigned(x: number): string { + switch (x >>> 0) { + case 0: + return "zero"; + case 1: + return "one"; + case 4294967295: + return "all ones"; + case 2147483648: + return "high bit"; + default: + return "other"; + } +} + +function counted(n: number): string { + const out: string[] = []; + for (let i = -2; i < n; i++) { + switch (i) { + case -2: + out.push("m2"); + break; + case 0: + out.push("z"); + break; + case 2: + out.push("t"); + // falls through + case 3: + out.push("t3"); + break; + case 5: + out.push("f"); + break; + default: + out.push("."); + } + } + return out.join(" "); +} + +const inputs = [ + 0, + -0, + 1, + 2, + 3, + -1, + 0.5, + 1.0000001, + NaN, + Infinity, + -Infinity, + 2147483647, + -2147483648, + 2147483648, + -2147483649, + 4294967295, + 4294967296, + 9007199254740991, + -9007199254740991, + 9007199254740992, + 2 ** 63, + -(2 ** 63), + 1e300, + -5, + 4294967291, +]; +for (const x of inputs) { + console.log(String(x), small(x), wide(x), proven(x), provenUnsigned(x)); +} +console.log(counted(7)); diff --git a/tests/diagnostics/contract-immutable.ts b/tests/diagnostics/contract-immutable.ts new file mode 100644 index 000000000..a9a0d9aed --- /dev/null +++ b/tests/diagnostics/contract-immutable.ts @@ -0,0 +1,46 @@ +// Immutable contracts that do not hold: writes that reach the value +// through methods, aliases and casts, and stores of values that other +// references can still change. +import type { Immutable } from "@scriptc/types"; + +class Counter { + count = 0; + bump(): void { + this.count++; + } +} + +const COUNTER: Immutable = new Counter(); + +const shared = [1, 2, 3]; +const VIEW: Immutable = shared; + +const ROWS: Immutable = [[1], [2]]; + +const CONFIG: Immutable<{ name: string }> = { name: "x" }; + +function rename(config: { name: string }): void { + config.name = "y"; +} + +function grow(rows: number[][]): void { + rows[0]!.push(4); +} + +COUNTER.bump(); +rename(CONFIG); +grow(ROWS as number[][]); +shared.push(4); +console.log(COUNTER.count, VIEW.length, ROWS.length, CONFIG.name); + +// A write at an index that may be negative, fractional or too large adds a +// property instead of an element, so the factory's result is not fresh. +function fill(at: number): number[] { + const table: number[] = []; + for (let i = 0; i < 4; i++) table[i] = i; + table[at] = -1; + return table; +} + +const FILLED: Immutable = fill(-1); +console.log(FILLED.length); diff --git a/tests/diagnostics/contract-int32-escapes.ts b/tests/diagnostics/contract-int32-escapes.ts new file mode 100644 index 000000000..fcbbcbfd9 --- /dev/null +++ b/tests/diagnostics/contract-int32-escapes.ts @@ -0,0 +1,17 @@ +// Int32 slots whose writes the program does not show: a parameter of a +// function used as a callback, and a field of instances that reach +// dynamic code. +import type { Int32 } from "@scriptc/types"; + +function double(x: Int32): Int32 { + return (x * 2) | 0; +} + +class Box { + size: Int32 = 0; +} + +const box = new Box(); +const loose: any = box; +loose.size = 0.5; +console.log([1.5, 2].map(double).join(","), box.size); diff --git a/tests/diagnostics/contract-int32.ts b/tests/diagnostics/contract-int32.ts new file mode 100644 index 000000000..f6e900626 --- /dev/null +++ b/tests/diagnostics/contract-int32.ts @@ -0,0 +1,36 @@ +// Int32 contracts that do not hold: each write that is not an int32 by +// construction is reported with the expression and the `| 0` fix. +import type { Int32 } from "@scriptc/types"; + +class Span { + pos: Int32 = 0; + end: Int32 = 0; + readonly id: Int32; + constructor(id: number) { + this.id = id; + } + advance(): void { + this.pos++; + } +} + +function width(span: Span): Int32 { + return span.end - span.pos; +} + +function half(x: Int32): Int32 { + return x / 2; +} + +let count: Int32 = 0; +function bump(): void { + count += 1; +} + +const sizes = [1, 2, 3]; +const len: Int32 = sizes.length; + +const span = new Span(1.5); +span.advance(); +bump(); +console.log(width(span), half(7), count, len); diff --git a/tests/diagnostics/contract-nothrow.ts b/tests/diagnostics/contract-nothrow.ts new file mode 100644 index 000000000..6d971dac5 --- /dev/null +++ b/tests/diagnostics/contract-nothrow.ts @@ -0,0 +1,34 @@ +// NoThrow contracts that do not hold: each diagnostic names the path from +// the annotated function to the operation that can throw. +import type { NoThrow } from "@scriptc/types"; + +function parseDigit(ch: string): number { + const code = ch.charCodeAt(0) - 48; + if (code < 0 || code > 9) throw new RangeError(`not a digit: ${ch}`); + return code; +} + +function sumDigits(text: string): NoThrow { + let sum = 0; + for (let i = 0; i < text.length; i++) sum += parseDigit(text[i]!); + return sum; +} + +function depth(n: number): NoThrow { + return n <= 0 ? 0 : 1 + depth(n - 1); +} + +function apply(f: (x: number) => number, x: number): NoThrow { + return f(x); +} + +// The source type says `string`, but a caller passes a non-null asserted +// element that can be missing; Node then throws inside the callee, so the +// parameter is compiled as `string | undefined` and the read can throw. +function width(text: string): NoThrow { + return text.length; +} + +const words = "a b".split(" "); +console.log(sumDigits("123"), depth(3), apply((x) => x + 1, 1), apply((x) => parseDigit(String(x)), 2)); +console.log(width(words[0]!), width(words[1]!)); diff --git a/tests/diagnostics/contract-positions.ts b/tests/diagnostics/contract-positions.ts new file mode 100644 index 000000000..8223e0ae0 --- /dev/null +++ b/tests/diagnostics/contract-positions.ts @@ -0,0 +1,19 @@ +// Contract types are checked where they annotate a declaration directly. +// Elsewhere they would promise something scriptc does not check, so the +// build reports them. +import type { Immutable, Int32, NoThrow } from "@scriptc/types"; + +type NodeId = Int32; + +interface Point { + x: Int32; +} + +const ids: Int32[] = [1, 2]; +const point: Point = { x: 1 }; +const id: NodeId = 3; +const callback: (x: number) => NoThrow = (x) => x; +const table: Map> = new Map(); +let last: NoThrow = 0; + +console.log(ids, point.x, id, callback(1), table.size, last); diff --git a/tests/harness/__snapshots__/contract-immutable.ts.txt b/tests/harness/__snapshots__/contract-immutable.ts.txt new file mode 100644 index 000000000..a4614d16e --- /dev/null +++ b/tests/harness/__snapshots__/contract-immutable.ts.txt @@ -0,0 +1,44 @@ +contract-immutable.ts:9:5 - error SC7004: 'this.count++' writes to a value that may be Immutable ('this' may be an Immutable value passed to 'Counter.bump' at contract-immutable.ts:30:1) + + 8 | bump(): void { + 9 | this.count++; + | ^~~~~~~~~~~~ + 10 | } + + hint: Immutable values cannot be written through any reference; copy the value before changing it + +contract-immutable.ts:16:35 - error SC7004: the value stored into 'VIEW' (Immutable) may be referenced elsewhere: 'shared' is not a fresh literal, construction or factory result + + 15 | const shared = [1, 2, 3]; + 16 | const VIEW: Immutable = shared; + | ^~~~~~ + 17 | + + hint: build the value in place (a literal, `new`, or a function that returns what it builds), so no mutable reference to it remains + +contract-immutable.ts:23:3 - error SC7004: 'config.name = "y"' writes to a value that may be Immutable ('config' may be an Immutable value passed to 'rename' at contract-immutable.ts:31:1) + + 22 | function rename(config: { name: string }): void { + 23 | config.name = "y"; + | ^~~~~~~~~~~~~~~~~ + 24 | } + + hint: Immutable values cannot be written through any reference; copy the value before changing it + +contract-immutable.ts:27:3 - error SC7004: 'rows[0]!.push(4)' writes to a value that may be Immutable ('rows' may be an Immutable value passed to 'grow' at contract-immutable.ts:32:1) + + 26 | function grow(rows: number[][]): void { + 27 | rows[0]!.push(4); + | ^~~~~~~~~~~~~~~~ + 28 | } + + hint: Immutable values cannot be written through any reference; copy the value before changing it + +contract-immutable.ts:45:37 - error SC7004: the value stored into 'FILLED' (Immutable) may be referenced elsewhere: 'fill(-1)' is not a fresh literal, construction or factory result + + 44 | + 45 | const FILLED: Immutable = fill(-1); + | ^~~~~~~~ + 46 | console.log(FILLED.length); + + hint: build the value in place (a literal, `new`, or a function that returns what it builds), so no mutable reference to it remains \ No newline at end of file diff --git a/tests/harness/__snapshots__/contract-int32-escapes.ts.txt b/tests/harness/__snapshots__/contract-int32-escapes.ts.txt new file mode 100644 index 000000000..5ba985a48 --- /dev/null +++ b/tests/harness/__snapshots__/contract-int32-escapes.ts.txt @@ -0,0 +1,26 @@ +contract-int32-escapes.ts:6:20 - error SC7003: the Int32 contract on 'x' cannot be checked: 'double' is used as a value (callback, class value or export), so its callers are not all visible + + 5 | + 6 | function double(x: Int32): Int32 { + | ^~~~~ + 7 | return (x * 2) | 0; + + hint: wrap it in a function that takes a number and passes `x | 0` + +contract-int32-escapes.ts:11:9 - error SC7003: the Int32 contract on 'Box.size' cannot be checked: instances of the class reach dynamic code (any, unknown casts, islands) where a store to the field is not checked + + 10 | class Box { + 11 | size: Int32 = 0; + | ^~~~~ + 12 | } + + hint: keep instances of this class out of any-typed values, or remove Int32 + +contract-int32-escapes.ts:16:1 - error SC7002: the value stored into 'Box.size' (Int32) is not provably an int32: 'loose.size = 0.5' + + 15 | const loose: any = box; + 16 | loose.size = 0.5; + | ^~~~~~~~~~~~~~~~ + 17 | console.log([1.5, 2].map(double).join(","), box.size); + + hint: make the int32 conversion explicit, for example 'loose.size = 0.5 | 0', so Node computes the same value \ No newline at end of file diff --git a/tests/harness/__snapshots__/contract-int32.ts.txt b/tests/harness/__snapshots__/contract-int32.ts.txt new file mode 100644 index 000000000..2f3a65c1d --- /dev/null +++ b/tests/harness/__snapshots__/contract-int32.ts.txt @@ -0,0 +1,53 @@ +contract-int32.ts:10:15 - error SC7002: the value stored into 'Span.id' (Int32) is not provably an int32: 'id' + + 9 | constructor(id: number) { + 10 | this.id = id; + | ^~ + 11 | } + + hint: make the int32 conversion explicit, for example 'id | 0', so Node computes the same value + +contract-int32.ts:13:5 - error SC7002: the value stored into 'Span.pos' (Int32) is not provably an int32: 'this.pos++' + + 12 | advance(): void { + 13 | this.pos++; + | ^~~~~~~~~~ + 14 | } + + hint: make the int32 conversion explicit, for example 'this.pos = (this.pos + 1) | 0', so Node computes the same value + +contract-int32.ts:18:10 - error SC7002: the value returned from 'width' (Int32) is not provably an int32: 'span.end - span.pos' + + 17 | function width(span: Span): Int32 { + 18 | return span.end - span.pos; + | ^~~~~~~~~~~~~~~~~~~ + 19 | } + + hint: make the int32 conversion explicit, for example '(span.end - span.pos) | 0', so Node computes the same value + +contract-int32.ts:22:10 - error SC7002: the value returned from 'half' (Int32) is not provably an int32: 'x / 2' + + 21 | function half(x: Int32): Int32 { + 22 | return x / 2; + | ^~~~~ + 23 | } + + hint: make the int32 conversion explicit, for example '(x / 2) | 0', so Node computes the same value + +contract-int32.ts:27:3 - error SC7002: the value stored into 'count' (Int32) is not provably an int32: 'count += 1' + + 26 | function bump(): void { + 27 | count += 1; + | ^~~~~~~~~~ + 28 | } + + hint: make the int32 conversion explicit, for example 'count = (count + 1) | 0', so Node computes the same value + +contract-int32.ts:31:20 - error SC7002: the value stored into 'len' (Int32) is not provably an int32: 'sizes.length' + + 30 | const sizes = [1, 2, 3]; + 31 | const len: Int32 = sizes.length; + | ^~~~~~~~~~~~ + 32 | + + hint: make the int32 conversion explicit, for example 'sizes.length | 0', so Node computes the same value \ No newline at end of file diff --git a/tests/harness/__snapshots__/contract-nothrow.ts.txt b/tests/harness/__snapshots__/contract-nothrow.ts.txt new file mode 100644 index 000000000..412ba2352 --- /dev/null +++ b/tests/harness/__snapshots__/contract-nothrow.ts.txt @@ -0,0 +1,35 @@ +contract-nothrow.ts:11:35 - error SC7001: 'sumDigits' is declared NoThrow but may throw: calls 'parseDigit' at contract-nothrow.ts:13:48 → throw statement at contract-nothrow.ts:7:29 + + 10 | + 11 | function sumDigits(text: string): NoThrow { + | ^~~~~~~~~~~~~~~ + 12 | let sum = 0; + + hint: remove the throwing operation from the path (or the recursion), or remove NoThrow; a surrounding try/catch does not discharge the contract in this version + +contract-nothrow.ts:17:28 - error SC7001: 'depth' is declared NoThrow but may throw: can recurse (directly or through callbacks), so the stack guard may throw RangeError at contract-nothrow.ts:17:1 + + 16 | + 17 | function depth(n: number): NoThrow { + | ^~~~~~~~~~~~~~~ + 18 | return n <= 0 ? 0 : 1 + depth(n - 1); + + hint: remove the throwing operation from the path (or the recursion), or remove NoThrow; a surrounding try/catch does not discharge the contract in this version + +contract-nothrow.ts:21:54 - error SC7001: 'apply' is declared NoThrow but may throw: calls a function value at contract-nothrow.ts:22:10, and the function value 'the function at contract-nothrow.ts:33:71' may throw → calls 'parseDigit' at contract-nothrow.ts:33:78 → throw statement at contract-nothrow.ts:7:29 + + 20 | + 21 | function apply(f: (x: number) => number, x: number): NoThrow { + | ^~~~~~~~~~~~~~~ + 22 | return f(x); + + hint: remove the throwing operation from the path (or the recursion), or remove NoThrow; a surrounding try/catch does not discharge the contract in this version + +contract-nothrow.ts:28:31 - error SC7001: 'width' is declared NoThrow but may throw: throws TypeError: Cannot read properties of undefined (reading 'length') at contract-nothrow.ts:29:10 (parameter 'text' is compiled as string | undefined: the argument at contract-nothrow.ts:34:19 can be missing) + + 27 | // parameter is compiled as `string | undefined` and the read can throw. + 28 | function width(text: string): NoThrow { + | ^~~~~~~~~~~~~~~ + 29 | return text.length; + + hint: remove the throwing operation from the path (or the recursion), or remove NoThrow; a surrounding try/catch does not discharge the contract in this version \ No newline at end of file diff --git a/tests/harness/__snapshots__/contract-positions.ts.txt b/tests/harness/__snapshots__/contract-positions.ts.txt new file mode 100644 index 000000000..d43cd07e3 --- /dev/null +++ b/tests/harness/__snapshots__/contract-positions.ts.txt @@ -0,0 +1,53 @@ +contract-positions.ts:6:15 - error SC7006: the Int32 contract is not checked in this position (Int32 is checked on parameters, variables, class instance fields and function results) + + 5 | + 6 | type NodeId = Int32; + | ^~~~~ + 7 | + + hint: write Int32 directly as the annotation of the declaration; type aliases, interface members and types nested in other types (arrays, unions, type arguments) are not followed + +contract-positions.ts:9:6 - error SC7006: the Int32 contract is not checked in this position (Int32 is checked on parameters, variables, class instance fields and function results) + + 8 | interface Point { + 9 | x: Int32; + | ^~~~~ + 10 | } + + hint: write Int32 directly as the annotation of the declaration; type aliases, interface members and types nested in other types (arrays, unions, type arguments) are not followed + +contract-positions.ts:12:12 - error SC7006: the Int32 contract is not checked in this position (Int32 is checked on parameters, variables, class instance fields and function results) + + 11 | + 12 | const ids: Int32[] = [1, 2]; + | ^~~~~ + 13 | const point: Point = { x: 1 }; + + hint: write Int32 directly as the annotation of the declaration; type aliases, interface members and types nested in other types (arrays, unions, type arguments) are not followed + +contract-positions.ts:15:32 - error SC7006: the NoThrow contract is not checked in this position (NoThrow wraps a function's written return type) + + 14 | const id: NodeId = 3; + 15 | const callback: (x: number) => NoThrow = (x) => x; + | ^~~~~~~~~~~~~~~ + 16 | const table: Map> = new Map(); + + hint: write it as the function's return type annotation: function f(): NoThrow + +contract-positions.ts:16:26 - error SC7006: the Immutable contract is not checked in this position (Immutable is checked on parameters, variables, class instance fields and function results) + + 15 | const callback: (x: number) => NoThrow = (x) => x; + 16 | const table: Map> = new Map(); + | ^~~~~~~~~~~~~~~~~~~ + 17 | let last: NoThrow = 0; + + hint: write Immutable directly as the annotation of the declaration; type aliases, interface members and types nested in other types (arrays, unions, type arguments) are not followed + +contract-positions.ts:17:11 - error SC7006: the NoThrow contract is not checked in this position (NoThrow wraps a function's written return type) + + 16 | const table: Map> = new Map(); + 17 | let last: NoThrow = 0; + | ^~~~~~~~~~~~~~~ + 18 | + + hint: write it as the function's return type annotation: function f(): NoThrow \ No newline at end of file diff --git a/tests/harness/large-artifacts.test.ts b/tests/harness/large-artifacts.test.ts index 207ce80a2..a8bb95fb4 100644 --- a/tests/harness/large-artifacts.test.ts +++ b/tests/harness/large-artifacts.test.ts @@ -4,8 +4,8 @@ import { occurrences, withoutFirstLine, withoutRange } from "./large-artifacts.j test("byte-level artifact edits match their string equivalents", () => { const text = "x declare void @scr_runtime_abi_v3()\ndeclare void @scr_runtime_abi_vX()\n" + - "declare void @scr_runtime_abi_v12()\n call void @scr_runtime_abi_v12()\n" + - "é\n call void @scr_runtime_abi_v12()\n"; + "declare void @scr_runtime_abi_v13()\n call void @scr_runtime_abi_v13()\n" + + "é\n call void @scr_runtime_abi_v13()\n"; const bytes = Buffer.from(text); const declaration = /^declare void @scr_runtime_abi_v\d+\(\)\n/m; const call = /^ {2}call void @scr_runtime_abi_v\d+\(\)\n/m; @@ -21,7 +21,7 @@ test("byte-level artifact edits match their string equivalents", () => { expect(edited.toString()).toBe(text.replace(declaration, "").replace(call, "")); expect(withoutFirstLine(bytes, "missing", /^missing\n$/)).toBe(bytes); - const line = " call void @scr_runtime_abi_v12()\n"; + const line = " call void @scr_runtime_abi_v13()\n"; const found = occurrences(bytes, line); expect(found).toHaveLength(text.split(line).length - 1); expect(withoutRange(bytes, found[0]!, Buffer.byteLength(line)).toString()).toBe( diff --git a/tests/harness/self-hosting-emission.test.ts b/tests/harness/self-hosting-emission.test.ts index 2105d5b4e..d245c136d 100644 --- a/tests/harness/self-hosting-emission.test.ts +++ b/tests/harness/self-hosting-emission.test.ts @@ -1,14 +1,15 @@ -import { spawnSync } from "node:child_process"; import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"; 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, moduleUsesDynInvoke, @@ -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, @@ -83,14 +84,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 +116,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 +153,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 +186,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 +196,7 @@ for (const backend of ["llvm"] as const) { }, ]; expect( - run( + await run( unsupported, { ...emissionRequest(), joinUnions: ["containers"] }, "unsupported union join", @@ -225,7 +235,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 +266,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-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( diff --git a/tests/harness/self-hosting-native-toolchain.test.ts b/tests/harness/self-hosting-native-toolchain.test.ts index 43a230682..09caf2f0f 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"; @@ -100,7 +100,7 @@ for (const backend of ["llvm"] as const) { object_format: target.objectFormat, minimum_os: target.minimumOs, }, - runtime_abi: { version: 12, marker: "scr_runtime_abi_v12" }, + runtime_abi: { version: 13, marker: "scr_runtime_abi_v13" }, compiler: { command: "fixture", identity: "fixture", target: target.llvmTriple }, macros: { executable: [], excluded: [], sanitizer: "external-toolchain-required" }, flavors: { @@ -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), + }), + ); + }); +} 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");