Add tests for check order dependence

tsc/testdata/baselines/reference/compiler/contextualCheckReentryFromOuterTypeParameters.symbols

@@ -0,0 +1,81 @@
+//// [tests/cases/compiler/contextualCheckReentryFromOuterTypeParameters.ts] ////
+
+=== contextualCheckReentryFromOuterTypeParameters.ts ===
+interface Argv<T = {}> {
+>Argv : Symbol(Argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 0))
+>T : Symbol(T, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 15))
+
+    command<U>(builder: (args: Argv<T>) => Argv<U>, handler: (args: Arguments<U>) => void): Argv<T>;
+>command : Symbol(Argv.command, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 24))
+>U : Symbol(U, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 12))
+>builder : Symbol(builder, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 15))
+>args : Symbol(args, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 25))
+>Argv : Symbol(Argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 0))
+>T : Symbol(T, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 15))
+>Argv : Symbol(Argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 0))
+>U : Symbol(U, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 12))
+>handler : Symbol(handler, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 51))
+>args : Symbol(args, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 62))
+>Arguments : Symbol(Arguments, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 3, 1))
+>U : Symbol(U, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 12))
+>Argv : Symbol(Argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 0))
+>T : Symbol(T, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 15))
+
+    option<K extends string, O>(key: K, options: O): Argv<{ [key in K]: O } & Check<O>>;
+>option : Symbol(Argv.option, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 100))
+>K : Symbol(K, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 11))
+>O : Symbol(O, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 28))
+>key : Symbol(key, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 32))
+>K : Symbol(K, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 11))
+>options : Symbol(options, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 39))
+>O : Symbol(O, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 28))
+>Argv : Symbol(Argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 0))
+>key : Symbol(key, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 61))
+>K : Symbol(K, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 11))
+>O : Symbol(O, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 28))
+>Check : Symbol(Check, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 78))
+>O : Symbol(O, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 2, 28))
+}
+type Arguments<T> = { [key in keyof T]: T[key] } & { [key: string]: unknown };
+>Arguments : Symbol(Arguments, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 3, 1))
+>T : Symbol(T, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 15))
+>key : Symbol(key, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 23))
+>T : Symbol(T, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 15))
+>T : Symbol(T, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 15))
+>key : Symbol(key, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 23))
+>key : Symbol(key, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 54))
+
+type Check<O> = O extends {} ? {} : {};
+>Check : Symbol(Check, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 4, 78))
+>O : Symbol(O, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 5, 11))
+>O : Symbol(O, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 5, 11))
+
+declare const yargs: Argv;
+>yargs : Symbol(yargs, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 6, 13))
+>Argv : Symbol(Argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 0))
+
+yargs.command(
+>yargs.command : Symbol(Argv.command, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 24))
+>yargs : Symbol(yargs, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 6, 13))
+>command : Symbol(Argv.command, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 0, 24))
+
+    (yargs) => yargs.option("a", { type: "string" }),
+>yargs : Symbol(yargs, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 9, 5))
+>yargs.option : Symbol(Argv.option, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 100))
+>yargs : Symbol(yargs, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 9, 5))
+>option : Symbol(Argv.option, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 1, 100))
+>type : Symbol(type, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 9, 34))
+
+    (argv) => {
+>argv : Symbol(argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 10, 5))
+
+        const a: { type: string } = argv.a;
+>a : Symbol(a, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 11, 13))
+>type : Symbol(type, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 11, 18))
+>argv.a : Symbol(a)
+>argv : Symbol(argv, Decl(contextualCheckReentryFromOuterTypeParameters.ts, 10, 5))
+>a : Symbol(a)
+
+    },
+);
+

tsc/testdata/baselines/reference/compiler/contextualCheckReentryFromOuterTypeParameters.types

@@ -0,0 +1,58 @@
+//// [tests/cases/compiler/contextualCheckReentryFromOuterTypeParameters.ts] ////
+
+=== contextualCheckReentryFromOuterTypeParameters.ts ===
+interface Argv<T = {}> {
+    command<U>(builder: (args: Argv<T>) => Argv<U>, handler: (args: Arguments<U>) => void): Argv<T>;
+>command : <U>(builder: (args: Argv<T>) => Argv<U>, handler: (args: Arguments<U>) => void) => Argv<T>
+>builder : (args: Argv<T>) => Argv<U>
+>args : Argv<T>
+>handler : (args: Arguments<U>) => void
+>args : Arguments<U>
+
+    option<K extends string, O>(key: K, options: O): Argv<{ [key in K]: O } & Check<O>>;
+>option : <K extends string, O>(key: K, options: O) => Argv<{ [key in K]: O; } & Check<O>>
+>key : K
+>options : O
+}
+type Arguments<T> = { [key in keyof T]: T[key] } & { [key: string]: unknown };
+>Arguments : Arguments<T>
+>key : string
+
+type Check<O> = O extends {} ? {} : {};
+>Check : Check<O>
+
+declare const yargs: Argv;
+>yargs : Argv<{}>
+
+yargs.command(
+>yargs.command(    (yargs) => yargs.option("a", { type: "string" }),    (argv) => {        const a: { type: string } = argv.a;    },) : Argv<{}>
+>yargs.command : <U>(builder: (args: Argv<{}>) => Argv<U>, handler: (args: Arguments<U>) => void) => Argv<{}>
+>yargs : Argv<{}>
+>command : <U>(builder: (args: Argv<{}>) => Argv<U>, handler: (args: Arguments<U>) => void) => Argv<{}>
+
+    (yargs) => yargs.option("a", { type: "string" }),
+>(yargs) => yargs.option("a", { type: "string" }) : (yargs: Argv<{}>) => Argv<{ a: { type: string; }; }>
+>yargs : Argv<{}>
+>yargs.option("a", { type: "string" }) : Argv<{ a: { type: string; }; }>
+>yargs.option : <K extends string, O>(key: K, options: O) => Argv<{ [key in K]: O; } & Check<O>>
+>yargs : Argv<{}>
+>option : <K extends string, O>(key: K, options: O) => Argv<{ [key in K]: O; } & Check<O>>
+>"a" : "a"
+>{ type: "string" } : { type: string; }
+>type : string
+>"string" : "string"
+
+    (argv) => {
+>(argv) => {        const a: { type: string } = argv.a;    } : (argv: Arguments<{ a: { type: string; }; }>) => void
+>argv : Arguments<{ a: { type: string; }; }>
+
+        const a: { type: string } = argv.a;
+>a : { type: string; }
+>type : string
+>argv.a : { type: string; }
+>argv : Arguments<{ a: { type: string; }; }>
+>a : { type: string; }
+
+    },
+);
+

tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.errors.txt

@@ -0,0 +1,24 @@
+deferredTypeReferenceCycleRollback.ts(17,31): error TS2304: Cannot find name 'Missing'.
+
+
+==== deferredTypeReferenceCycleRollback.ts (1 errors) ====
+    // A cycle rollback used to reset the type of the Array<NodePath<unknown>>
+    // node while the deferred reference identified by that node survived,
+    // which crashed a later instantiation of it.
+
+    declare function declare<T extends PluginObj = PluginObj>(): void;
+
+    interface PluginObj<S = unknown> {
+        visitor: Visit<S, never>;
+    }
+    type Visit<S, P> = VisitFn<S, P> | VisitObj<S, P>;
+    type VisitFn<S, P> = (path: NodePath<P>) => void;
+    interface VisitObj<S, P> {}
+    declare class NodePath<T> {
+        parentPath: NodePath<Exclude<T, null>>;
+        get: Get<T>;
+    }
+    type Get<T> = T extends Array<Missing> ? Array<NodePath<unknown>> : never;
+                                  ~~~~~~~
+!!! error TS2304: Cannot find name 'Missing'.
+

tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.symbols

@@ -0,0 +1,70 @@
+//// [tests/cases/compiler/deferredTypeReferenceCycleRollback.ts] ////
+
+=== deferredTypeReferenceCycleRollback.ts ===
+// A cycle rollback used to reset the type of the Array<NodePath<unknown>>
+// node while the deferred reference identified by that node survived,
+// which crashed a later instantiation of it.
+
+declare function declare<T extends PluginObj = PluginObj>(): void;
+>declare : Symbol(declare, Decl(deferredTypeReferenceCycleRollback.ts, 0, 0))
+>T : Symbol(T, Decl(deferredTypeReferenceCycleRollback.ts, 4, 25))
+>PluginObj : Symbol(PluginObj, Decl(deferredTypeReferenceCycleRollback.ts, 4, 66))
+>PluginObj : Symbol(PluginObj, Decl(deferredTypeReferenceCycleRollback.ts, 4, 66))
+
+interface PluginObj<S = unknown> {
+>PluginObj : Symbol(PluginObj, Decl(deferredTypeReferenceCycleRollback.ts, 4, 66))
+>S : Symbol(S, Decl(deferredTypeReferenceCycleRollback.ts, 6, 20))
+
+    visitor: Visit<S, never>;
+>visitor : Symbol(PluginObj.visitor, Decl(deferredTypeReferenceCycleRollback.ts, 6, 34))
+>Visit : Symbol(Visit, Decl(deferredTypeReferenceCycleRollback.ts, 8, 1))
+>S : Symbol(S, Decl(deferredTypeReferenceCycleRollback.ts, 6, 20))
+}
+type Visit<S, P> = VisitFn<S, P> | VisitObj<S, P>;
+>Visit : Symbol(Visit, Decl(deferredTypeReferenceCycleRollback.ts, 8, 1))
+>S : Symbol(S, Decl(deferredTypeReferenceCycleRollback.ts, 9, 11))
+>P : Symbol(P, Decl(deferredTypeReferenceCycleRollback.ts, 9, 13))
+>VisitFn : Symbol(VisitFn, Decl(deferredTypeReferenceCycleRollback.ts, 9, 50))
+>S : Symbol(S, Decl(deferredTypeReferenceCycleRollback.ts, 9, 11))
+>P : Symbol(P, Decl(deferredTypeReferenceCycleRollback.ts, 9, 13))
+>VisitObj : Symbol(VisitObj, Decl(deferredTypeReferenceCycleRollback.ts, 10, 49))
+>S : Symbol(S, Decl(deferredTypeReferenceCycleRollback.ts, 9, 11))
+>P : Symbol(P, Decl(deferredTypeReferenceCycleRollback.ts, 9, 13))
+
+type VisitFn<S, P> = (path: NodePath<P>) => void;
+>VisitFn : Symbol(VisitFn, Decl(deferredTypeReferenceCycleRollback.ts, 9, 50))
+>S : Symbol(S, Decl(deferredTypeReferenceCycleRollback.ts, 10, 13))
+>P : Symbol(P, Decl(deferredTypeReferenceCycleRollback.ts, 10, 15))
+>path : Symbol(path, Decl(deferredTypeReferenceCycleRollback.ts, 10, 22))
+>NodePath : Symbol(NodePath, Decl(deferredTypeReferenceCycleRollback.ts, 11, 27))
+>P : Symbol(P, Decl(deferredTypeReferenceCycleRollback.ts, 10, 15))
+
+interface VisitObj<S, P> {}
+>VisitObj : Symbol(VisitObj, Decl(deferredTypeReferenceCycleRollback.ts, 10, 49))
+>S : Symbol(S, Decl(deferredTypeReferenceCycleRollback.ts, 11, 19))
+>P : Symbol(P, Decl(deferredTypeReferenceCycleRollback.ts, 11, 21))
+
+declare class NodePath<T> {
+>NodePath : Symbol(NodePath, Decl(deferredTypeReferenceCycleRollback.ts, 11, 27))
+>T : Symbol(T, Decl(deferredTypeReferenceCycleRollback.ts, 12, 23))
+
+    parentPath: NodePath<Exclude<T, null>>;
+>parentPath : Symbol(NodePath.parentPath, Decl(deferredTypeReferenceCycleRollback.ts, 12, 27))
+>NodePath : Symbol(NodePath, Decl(deferredTypeReferenceCycleRollback.ts, 11, 27))
+>Exclude : Symbol(Exclude, Decl(lib.es5.d.ts, --, --))
+>T : Symbol(T, Decl(deferredTypeReferenceCycleRollback.ts, 12, 23))
+
+    get: Get<T>;
+>get : Symbol(NodePath.get, Decl(deferredTypeReferenceCycleRollback.ts, 13, 43))
+>Get : Symbol(Get, Decl(deferredTypeReferenceCycleRollback.ts, 15, 1))
+>T : Symbol(T, Decl(deferredTypeReferenceCycleRollback.ts, 12, 23))
+}
+type Get<T> = T extends Array<Missing> ? Array<NodePath<unknown>> : never;
+>Get : Symbol(Get, Decl(deferredTypeReferenceCycleRollback.ts, 15, 1))
+>T : Symbol(T, Decl(deferredTypeReferenceCycleRollback.ts, 16, 9))
+>T : Symbol(T, Decl(deferredTypeReferenceCycleRollback.ts, 16, 9))
+>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more)
+>Missing : Symbol(Missing)
+>Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --) ... and 4 more)
+>NodePath : Symbol(NodePath, Decl(deferredTypeReferenceCycleRollback.ts, 11, 27))
+

tsc/testdata/baselines/reference/compiler/deferredTypeReferenceCycleRollback.types

@@ -0,0 +1,34 @@
+//// [tests/cases/compiler/deferredTypeReferenceCycleRollback.ts] ////
+
+=== deferredTypeReferenceCycleRollback.ts ===
+// A cycle rollback used to reset the type of the Array<NodePath<unknown>>
+// node while the deferred reference identified by that node survived,
+// which crashed a later instantiation of it.
+
+declare function declare<T extends PluginObj = PluginObj>(): void;
+>declare : <T extends PluginObj = PluginObj<unknown>>() => void
+
+interface PluginObj<S = unknown> {
+    visitor: Visit<S, never>;
+>visitor : Visit<S, never>
+}
+type Visit<S, P> = VisitFn<S, P> | VisitObj<S, P>;
+>Visit : Visit<S, P>
+
+type VisitFn<S, P> = (path: NodePath<P>) => void;
+>VisitFn : VisitFn<S, P>
+>path : NodePath<P>
+
+interface VisitObj<S, P> {}
+declare class NodePath<T> {
+>NodePath : NodePath<T>
+
+    parentPath: NodePath<Exclude<T, null>>;
+>parentPath : NodePath<Exclude<T, null>>
+
+    get: Get<T>;
+>get : Get<T>
+}
+type Get<T> = T extends Array<Missing> ? Array<NodePath<unknown>> : never;
+>Get : Get<T>
+

tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.errors.txt

@@ -0,0 +1,30 @@
+instantiationLimitsCheckOrder.ts(11,16): error TS2589: Type instantiation is excessively deep and possibly infinite.
+
+
+==== instantiationLimitsCheckOrder.ts (1 errors) ====
+    // Instantiation limits must not depend on what was instantiated before.
+    // This holds for the depth limit, but not yet for the limit on the number
+    // of instantiations, which Wide2All only reaches if Wide2Tail was not
+    // checked first.
+
+    type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    type K = `${D}${D}${D}`;
+
+    // Over five million instantiations for one statement.
+    type Wide<N extends 0[], I> = N["length"] extends 6 ? I : { [J in K]: Wide<[...N, 0], [J, I][0]> }[K];
+    type WideAll = Wide<[], "">;
+                   ~~~~~~~~~~~~
+!!! error TS2589: Type instantiation is excessively deep and possibly infinite.
+
+    // The same, but half of the instantiations already happened for another
+    // statement.
+    type Wide2<N extends 0[], I> = N["length"] extends 6 ? I : { [J in K]: Wide2<[...N, 0], [J, I][0]> }[K];
+    type Wide2Tail = Wide2<[0, 0, 0], "">;
+    type Wide2All = Wide2<[], "">;
+
+    // Over a hundred nested instantiations, half of which already happened for
+    // another statement.
+    type Deep<N extends 0[]> = N["length"] extends 60 ? never : Deep<[...N, 0]> | N["length"];
+    type DeepTail = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>;
+    type DeepAll = Deep<[]>;
+

tsc/testdata/baselines/reference/compiler/instantiationLimitsCheckOrder.symbols

@@ -0,0 +1,78 @@
+//// [tests/cases/compiler/instantiationLimitsCheckOrder.ts] ////
+
+=== instantiationLimitsCheckOrder.ts ===
+// Instantiation limits must not depend on what was instantiated before.
+// This holds for the depth limit, but not yet for the limit on the number
+// of instantiations, which Wide2All only reaches if Wide2Tail was not
+// checked first.
+
+type D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+>D : Symbol(D, Decl(instantiationLimitsCheckOrder.ts, 0, 0))
+
+type K = `${D}${D}${D}`;
+>K : Symbol(K, Decl(instantiationLimitsCheckOrder.ts, 5, 47))
+>D : Symbol(D, Decl(instantiationLimitsCheckOrder.ts, 0, 0))
+>D : Symbol(D, Decl(instantiationLimitsCheckOrder.ts, 0, 0))
+>D : Symbol(D, Decl(instantiationLimitsCheckOrder.ts, 0, 0))
+
+// Over five million instantiations for one statement.
+type Wide<N extends 0[], I> = N["length"] extends 6 ? I : { [J in K]: Wide<[...N, 0], [J, I][0]> }[K];
+>Wide : Symbol(Wide, Decl(instantiationLimitsCheckOrder.ts, 6, 24))
+>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 9, 10))
+>I : Symbol(I, Decl(instantiationLimitsCheckOrder.ts, 9, 24))
+>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 9, 10))
+>I : Symbol(I, Decl(instantiationLimitsCheckOrder.ts, 9, 24))
+>J : Symbol(J, Decl(instantiationLimitsCheckOrder.ts, 9, 61))
+>K : Symbol(K, Decl(instantiationLimitsCheckOrder.ts, 5, 47))
+>Wide : Symbol(Wide, Decl(instantiationLimitsCheckOrder.ts, 6, 24))
+>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 9, 10))
+>J : Symbol(J, Decl(instantiationLimitsCheckOrder.ts, 9, 61))
+>I : Symbol(I, Decl(instantiationLimitsCheckOrder.ts, 9, 24))
+>K : Symbol(K, Decl(instantiationLimitsCheckOrder.ts, 5, 47))
+
+type WideAll = Wide<[], "">;
+>WideAll : Symbol(WideAll, Decl(instantiationLimitsCheckOrder.ts, 9, 102))
+>Wide : Symbol(Wide, Decl(instantiationLimitsCheckOrder.ts, 6, 24))
+
+// The same, but half of the instantiations already happened for another
+// statement.
+type Wide2<N extends 0[], I> = N["length"] extends 6 ? I : { [J in K]: Wide2<[...N, 0], [J, I][0]> }[K];
+>Wide2 : Symbol(Wide2, Decl(instantiationLimitsCheckOrder.ts, 10, 28))
+>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 14, 11))
+>I : Symbol(I, Decl(instantiationLimitsCheckOrder.ts, 14, 25))
+>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 14, 11))
+>I : Symbol(I, Decl(instantiationLimitsCheckOrder.ts, 14, 25))
+>J : Symbol(J, Decl(instantiationLimitsCheckOrder.ts, 14, 62))
+>K : Symbol(K, Decl(instantiationLimitsCheckOrder.ts, 5, 47))
+>Wide2 : Symbol(Wide2, Decl(instantiationLimitsCheckOrder.ts, 10, 28))
+>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 14, 11))
+>J : Symbol(J, Decl(instantiationLimitsCheckOrder.ts, 14, 62))
+>I : Symbol(I, Decl(instantiationLimitsCheckOrder.ts, 14, 25))
+>K : Symbol(K, Decl(instantiationLimitsCheckOrder.ts, 5, 47))
+
+type Wide2Tail = Wide2<[0, 0, 0], "">;
+>Wide2Tail : Symbol(Wide2Tail, Decl(instantiationLimitsCheckOrder.ts, 14, 104))
+>Wide2 : Symbol(Wide2, Decl(instantiationLimitsCheckOrder.ts, 10, 28))
+
+type Wide2All = Wide2<[], "">;
+>Wide2All : Symbol(Wide2All, Decl(instantiationLimitsCheckOrder.ts, 15, 38))
+>Wide2 : Symbol(Wide2, Decl(instantiationLimitsCheckOrder.ts, 10, 28))
+
+// Over a hundred nested instantiations, half of which already happened for
+// another statement.
+type Deep<N extends 0[]> = N["length"] extends 60 ? never : Deep<[...N, 0]> | N["length"];
+>Deep : Symbol(Deep, Decl(instantiationLimitsCheckOrder.ts, 16, 30))
+>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 20, 10))
+>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 20, 10))
+>Deep : Symbol(Deep, Decl(instantiationLimitsCheckOrder.ts, 16, 30))
+>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 20, 10))
+>N : Symbol(N, Decl(instantiationLimitsCheckOrder.ts, 20, 10))
+
+type DeepTail = Deep<[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]>;
+>DeepTail : Symbol(DeepTail, Decl(instantiationLimitsCheckOrder.ts, 20, 90))
+>Deep : Symbol(Deep, Decl(instantiationLimitsCheckOrder.ts, 16, 30))
+
+type DeepAll = Deep<[]>;
+>DeepAll : Symbol(DeepAll, Decl(instantiationLimitsCheckOrder.ts, 21, 113))
+>Deep : Symbol(Deep, Decl(instantiationLimitsCheckOrder.ts, 16, 30))
+