From a1f82c12d7d626da27265c0931b7953537ec2b00 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Sun, 29 Aug 2021 16:19:05 -0700 Subject: [PATCH] Add regression test --- ...rDependenceGenericAssignability.errors.txt | 65 ++++++++ ...heckOrderDependenceGenericAssignability.js | 69 +++++++++ ...rderDependenceGenericAssignability.symbols | 139 ++++++++++++++++++ ...kOrderDependenceGenericAssignability.types | 103 +++++++++++++ ...heckOrderDependenceGenericAssignability.ts | 53 +++++++ 5 files changed, 429 insertions(+) create mode 100644 tests/baselines/reference/checkOrderDependenceGenericAssignability.errors.txt create mode 100644 tests/baselines/reference/checkOrderDependenceGenericAssignability.js create mode 100644 tests/baselines/reference/checkOrderDependenceGenericAssignability.symbols create mode 100644 tests/baselines/reference/checkOrderDependenceGenericAssignability.types create mode 100644 tests/cases/compiler/checkOrderDependenceGenericAssignability.ts diff --git a/tests/baselines/reference/checkOrderDependenceGenericAssignability.errors.txt b/tests/baselines/reference/checkOrderDependenceGenericAssignability.errors.txt new file mode 100644 index 00000000000..edf09615152 --- /dev/null +++ b/tests/baselines/reference/checkOrderDependenceGenericAssignability.errors.txt @@ -0,0 +1,65 @@ +tests/cases/compiler/checkOrderDependenceGenericAssignability.ts(24,1): error TS2322: Type 'Parent1' is not assignable to type 'Parent1'. + Type 'unknown' is not assignable to type 'string'. +tests/cases/compiler/checkOrderDependenceGenericAssignability.ts(51,1): error TS2322: Type 'Parent2' is not assignable to type 'Parent2'. + Type 'unknown' is not assignable to type 'string'. + + +==== tests/cases/compiler/checkOrderDependenceGenericAssignability.ts (2 errors) ==== + // Repro from #44572 with interface types + + interface Parent1 { + child: Child1; + parent: Parent1; + } + + interface Child1 extends Parent1 { + readonly a: A; + // This field isn't necessary to the repro, but the + // type parameter is, so including it + readonly b: B; + } + + function fn1(inp: Child1) { + // This assignability check defeats the later one + const a: Child1 = inp; + } + + declare let pu1: Parent1; + declare let ps1: Parent1; + + pu1 = ps1; // Ok + ps1 = pu1; // Error expected + ~~~ +!!! error TS2322: Type 'Parent1' is not assignable to type 'Parent1'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + + // Repro from #44572 with aliased object types + + type Parent2 = { + child: Child2; + parent: Parent2; + } + + type Child2 = { + child: Child2; + parent: Parent2; + readonly a: A; + // This field isn't necessary to the repro, but the + // type parameter is, so including it + readonly b: B; + } + + function fn2(inp: Child2) { + // This assignability check defeats the later one + const a: Child2 = inp; + } + + declare let pu2: Parent2; + declare let ps2: Parent2; + + pu2 = ps2; // Ok + ps2 = pu2; // Error expected + ~~~ +!!! error TS2322: Type 'Parent2' is not assignable to type 'Parent2'. +!!! error TS2322: Type 'unknown' is not assignable to type 'string'. + \ No newline at end of file diff --git a/tests/baselines/reference/checkOrderDependenceGenericAssignability.js b/tests/baselines/reference/checkOrderDependenceGenericAssignability.js new file mode 100644 index 00000000000..3e88b08098b --- /dev/null +++ b/tests/baselines/reference/checkOrderDependenceGenericAssignability.js @@ -0,0 +1,69 @@ +//// [checkOrderDependenceGenericAssignability.ts] +// Repro from #44572 with interface types + +interface Parent1 { + child: Child1; + parent: Parent1; +} + +interface Child1 extends Parent1 { + readonly a: A; + // This field isn't necessary to the repro, but the + // type parameter is, so including it + readonly b: B; +} + +function fn1(inp: Child1) { + // This assignability check defeats the later one + const a: Child1 = inp; +} + +declare let pu1: Parent1; +declare let ps1: Parent1; + +pu1 = ps1; // Ok +ps1 = pu1; // Error expected + +// Repro from #44572 with aliased object types + +type Parent2 = { + child: Child2; + parent: Parent2; +} + +type Child2 = { + child: Child2; + parent: Parent2; + readonly a: A; + // This field isn't necessary to the repro, but the + // type parameter is, so including it + readonly b: B; +} + +function fn2(inp: Child2) { + // This assignability check defeats the later one + const a: Child2 = inp; +} + +declare let pu2: Parent2; +declare let ps2: Parent2; + +pu2 = ps2; // Ok +ps2 = pu2; // Error expected + + +//// [checkOrderDependenceGenericAssignability.js] +"use strict"; +// Repro from #44572 with interface types +function fn1(inp) { + // This assignability check defeats the later one + var a = inp; +} +pu1 = ps1; // Ok +ps1 = pu1; // Error expected +function fn2(inp) { + // This assignability check defeats the later one + var a = inp; +} +pu2 = ps2; // Ok +ps2 = pu2; // Error expected diff --git a/tests/baselines/reference/checkOrderDependenceGenericAssignability.symbols b/tests/baselines/reference/checkOrderDependenceGenericAssignability.symbols new file mode 100644 index 00000000000..aeaa39264c7 --- /dev/null +++ b/tests/baselines/reference/checkOrderDependenceGenericAssignability.symbols @@ -0,0 +1,139 @@ +=== tests/cases/compiler/checkOrderDependenceGenericAssignability.ts === +// Repro from #44572 with interface types + +interface Parent1 { +>Parent1 : Symbol(Parent1, Decl(checkOrderDependenceGenericAssignability.ts, 0, 0)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 2, 18)) + + child: Child1; +>child : Symbol(Parent1.child, Decl(checkOrderDependenceGenericAssignability.ts, 2, 22)) +>Child1 : Symbol(Child1, Decl(checkOrderDependenceGenericAssignability.ts, 5, 1)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 2, 18)) + + parent: Parent1; +>parent : Symbol(Parent1.parent, Decl(checkOrderDependenceGenericAssignability.ts, 3, 21)) +>Parent1 : Symbol(Parent1, Decl(checkOrderDependenceGenericAssignability.ts, 0, 0)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 2, 18)) +} + +interface Child1 extends Parent1 { +>Child1 : Symbol(Child1, Decl(checkOrderDependenceGenericAssignability.ts, 5, 1)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 7, 17)) +>B : Symbol(B, Decl(checkOrderDependenceGenericAssignability.ts, 7, 19)) +>Parent1 : Symbol(Parent1, Decl(checkOrderDependenceGenericAssignability.ts, 0, 0)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 7, 17)) + + readonly a: A; +>a : Symbol(Child1.a, Decl(checkOrderDependenceGenericAssignability.ts, 7, 53)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 7, 17)) + + // This field isn't necessary to the repro, but the + // type parameter is, so including it + readonly b: B; +>b : Symbol(Child1.b, Decl(checkOrderDependenceGenericAssignability.ts, 8, 18)) +>B : Symbol(B, Decl(checkOrderDependenceGenericAssignability.ts, 7, 19)) +} + +function fn1(inp: Child1) { +>fn1 : Symbol(fn1, Decl(checkOrderDependenceGenericAssignability.ts, 12, 1)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 14, 13)) +>inp : Symbol(inp, Decl(checkOrderDependenceGenericAssignability.ts, 14, 16)) +>Child1 : Symbol(Child1, Decl(checkOrderDependenceGenericAssignability.ts, 5, 1)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 14, 13)) + + // This assignability check defeats the later one + const a: Child1 = inp; +>a : Symbol(a, Decl(checkOrderDependenceGenericAssignability.ts, 16, 9)) +>Child1 : Symbol(Child1, Decl(checkOrderDependenceGenericAssignability.ts, 5, 1)) +>inp : Symbol(inp, Decl(checkOrderDependenceGenericAssignability.ts, 14, 16)) +} + +declare let pu1: Parent1; +>pu1 : Symbol(pu1, Decl(checkOrderDependenceGenericAssignability.ts, 19, 11)) +>Parent1 : Symbol(Parent1, Decl(checkOrderDependenceGenericAssignability.ts, 0, 0)) + +declare let ps1: Parent1; +>ps1 : Symbol(ps1, Decl(checkOrderDependenceGenericAssignability.ts, 20, 11)) +>Parent1 : Symbol(Parent1, Decl(checkOrderDependenceGenericAssignability.ts, 0, 0)) + +pu1 = ps1; // Ok +>pu1 : Symbol(pu1, Decl(checkOrderDependenceGenericAssignability.ts, 19, 11)) +>ps1 : Symbol(ps1, Decl(checkOrderDependenceGenericAssignability.ts, 20, 11)) + +ps1 = pu1; // Error expected +>ps1 : Symbol(ps1, Decl(checkOrderDependenceGenericAssignability.ts, 20, 11)) +>pu1 : Symbol(pu1, Decl(checkOrderDependenceGenericAssignability.ts, 19, 11)) + +// Repro from #44572 with aliased object types + +type Parent2 = { +>Parent2 : Symbol(Parent2, Decl(checkOrderDependenceGenericAssignability.ts, 23, 10)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 27, 13)) + + child: Child2; +>child : Symbol(child, Decl(checkOrderDependenceGenericAssignability.ts, 27, 19)) +>Child2 : Symbol(Child2, Decl(checkOrderDependenceGenericAssignability.ts, 30, 1)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 27, 13)) + + parent: Parent2; +>parent : Symbol(parent, Decl(checkOrderDependenceGenericAssignability.ts, 28, 21)) +>Parent2 : Symbol(Parent2, Decl(checkOrderDependenceGenericAssignability.ts, 23, 10)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 27, 13)) +} + +type Child2 = { +>Child2 : Symbol(Child2, Decl(checkOrderDependenceGenericAssignability.ts, 30, 1)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 32, 12)) +>B : Symbol(B, Decl(checkOrderDependenceGenericAssignability.ts, 32, 14)) + + child: Child2; +>child : Symbol(child, Decl(checkOrderDependenceGenericAssignability.ts, 32, 31)) +>Child2 : Symbol(Child2, Decl(checkOrderDependenceGenericAssignability.ts, 30, 1)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 32, 12)) + + parent: Parent2; +>parent : Symbol(parent, Decl(checkOrderDependenceGenericAssignability.ts, 33, 21)) +>Parent2 : Symbol(Parent2, Decl(checkOrderDependenceGenericAssignability.ts, 23, 10)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 32, 12)) + + readonly a: A; +>a : Symbol(a, Decl(checkOrderDependenceGenericAssignability.ts, 34, 23)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 32, 12)) + + // This field isn't necessary to the repro, but the + // type parameter is, so including it + readonly b: B; +>b : Symbol(b, Decl(checkOrderDependenceGenericAssignability.ts, 35, 18)) +>B : Symbol(B, Decl(checkOrderDependenceGenericAssignability.ts, 32, 14)) +} + +function fn2(inp: Child2) { +>fn2 : Symbol(fn2, Decl(checkOrderDependenceGenericAssignability.ts, 39, 1)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 41, 13)) +>inp : Symbol(inp, Decl(checkOrderDependenceGenericAssignability.ts, 41, 16)) +>Child2 : Symbol(Child2, Decl(checkOrderDependenceGenericAssignability.ts, 30, 1)) +>A : Symbol(A, Decl(checkOrderDependenceGenericAssignability.ts, 41, 13)) + + // This assignability check defeats the later one + const a: Child2 = inp; +>a : Symbol(a, Decl(checkOrderDependenceGenericAssignability.ts, 43, 9)) +>Child2 : Symbol(Child2, Decl(checkOrderDependenceGenericAssignability.ts, 30, 1)) +>inp : Symbol(inp, Decl(checkOrderDependenceGenericAssignability.ts, 41, 16)) +} + +declare let pu2: Parent2; +>pu2 : Symbol(pu2, Decl(checkOrderDependenceGenericAssignability.ts, 46, 11)) +>Parent2 : Symbol(Parent2, Decl(checkOrderDependenceGenericAssignability.ts, 23, 10)) + +declare let ps2: Parent2; +>ps2 : Symbol(ps2, Decl(checkOrderDependenceGenericAssignability.ts, 47, 11)) +>Parent2 : Symbol(Parent2, Decl(checkOrderDependenceGenericAssignability.ts, 23, 10)) + +pu2 = ps2; // Ok +>pu2 : Symbol(pu2, Decl(checkOrderDependenceGenericAssignability.ts, 46, 11)) +>ps2 : Symbol(ps2, Decl(checkOrderDependenceGenericAssignability.ts, 47, 11)) + +ps2 = pu2; // Error expected +>ps2 : Symbol(ps2, Decl(checkOrderDependenceGenericAssignability.ts, 47, 11)) +>pu2 : Symbol(pu2, Decl(checkOrderDependenceGenericAssignability.ts, 46, 11)) + diff --git a/tests/baselines/reference/checkOrderDependenceGenericAssignability.types b/tests/baselines/reference/checkOrderDependenceGenericAssignability.types new file mode 100644 index 00000000000..29bd7a004ae --- /dev/null +++ b/tests/baselines/reference/checkOrderDependenceGenericAssignability.types @@ -0,0 +1,103 @@ +=== tests/cases/compiler/checkOrderDependenceGenericAssignability.ts === +// Repro from #44572 with interface types + +interface Parent1 { + child: Child1; +>child : Child1 + + parent: Parent1; +>parent : Parent1 +} + +interface Child1 extends Parent1 { + readonly a: A; +>a : A + + // This field isn't necessary to the repro, but the + // type parameter is, so including it + readonly b: B; +>b : B +} + +function fn1(inp: Child1) { +>fn1 : (inp: Child1) => void +>inp : Child1 + + // This assignability check defeats the later one + const a: Child1 = inp; +>a : Child1 +>inp : Child1 +} + +declare let pu1: Parent1; +>pu1 : Parent1 + +declare let ps1: Parent1; +>ps1 : Parent1 + +pu1 = ps1; // Ok +>pu1 = ps1 : Parent1 +>pu1 : Parent1 +>ps1 : Parent1 + +ps1 = pu1; // Error expected +>ps1 = pu1 : Parent1 +>ps1 : Parent1 +>pu1 : Parent1 + +// Repro from #44572 with aliased object types + +type Parent2 = { +>Parent2 : Parent2 + + child: Child2; +>child : Child2 + + parent: Parent2; +>parent : Parent2 +} + +type Child2 = { +>Child2 : Child2 + + child: Child2; +>child : Child2 + + parent: Parent2; +>parent : Parent2 + + readonly a: A; +>a : A + + // This field isn't necessary to the repro, but the + // type parameter is, so including it + readonly b: B; +>b : B +} + +function fn2(inp: Child2) { +>fn2 : (inp: Child2) => void +>inp : Child2 + + // This assignability check defeats the later one + const a: Child2 = inp; +>a : Child2 +>inp : Child2 +} + +declare let pu2: Parent2; +>pu2 : Parent2 + +declare let ps2: Parent2; +>ps2 : Parent2 + +pu2 = ps2; // Ok +>pu2 = ps2 : Parent2 +>pu2 : Parent2 +>ps2 : Parent2 + +ps2 = pu2; // Error expected +>ps2 = pu2 : Parent2 +>ps2 : Parent2 +>pu2 : Parent2 + diff --git a/tests/cases/compiler/checkOrderDependenceGenericAssignability.ts b/tests/cases/compiler/checkOrderDependenceGenericAssignability.ts new file mode 100644 index 00000000000..4445165a79d --- /dev/null +++ b/tests/cases/compiler/checkOrderDependenceGenericAssignability.ts @@ -0,0 +1,53 @@ +// @strict: true + +// Repro from #44572 with interface types + +interface Parent1 { + child: Child1; + parent: Parent1; +} + +interface Child1 extends Parent1 { + readonly a: A; + // This field isn't necessary to the repro, but the + // type parameter is, so including it + readonly b: B; +} + +function fn1(inp: Child1) { + // This assignability check defeats the later one + const a: Child1 = inp; +} + +declare let pu1: Parent1; +declare let ps1: Parent1; + +pu1 = ps1; // Ok +ps1 = pu1; // Error expected + +// Repro from #44572 with aliased object types + +type Parent2 = { + child: Child2; + parent: Parent2; +} + +type Child2 = { + child: Child2; + parent: Parent2; + readonly a: A; + // This field isn't necessary to the repro, but the + // type parameter is, so including it + readonly b: B; +} + +function fn2(inp: Child2) { + // This assignability check defeats the later one + const a: Child2 = inp; +} + +declare let pu2: Parent2; +declare let ps2: Parent2; + +pu2 = ps2; // Ok +ps2 = pu2; // Error expected