From 110b81b1af4e4b58045d0cd5819d7df262c57dbc Mon Sep 17 00:00:00 2001 From: Jack Williams Date: Thu, 28 Feb 2019 10:24:21 +0000 Subject: [PATCH] Add regressions for conditional types that affect parameter variance --- tests/baselines/reference/variance.js | 45 ++++++++++++++ tests/baselines/reference/variance.symbols | 62 +++++++++++++++++++ tests/baselines/reference/variance.types | 58 +++++++++++++++++ .../conformance/types/conditional/variance.ts | 27 ++++++++ 4 files changed, 192 insertions(+) create mode 100644 tests/baselines/reference/variance.js create mode 100644 tests/baselines/reference/variance.symbols create mode 100644 tests/baselines/reference/variance.types create mode 100644 tests/cases/conformance/types/conditional/variance.ts diff --git a/tests/baselines/reference/variance.js b/tests/baselines/reference/variance.js new file mode 100644 index 0000000000000..df84404b31beb --- /dev/null +++ b/tests/baselines/reference/variance.js @@ -0,0 +1,45 @@ +//// [variance.ts] +// Test cases for parameter variances affected by conditional types. + +// Repro from #30047 + +interface Foo { + prop: T extends unknown ? true : false; +} + +const foo = { prop: true } as const; +const x: Foo<1> = foo; +const y: Foo = foo; +const z: Foo = x; + + +// Repro from #30118 + +class Bar { + private static instance: Bar[]; + + cast(_name: ([T] extends [string] ? string : string)) { } + + pushThis() { + Bar.instance.push(this); + } +} + + +//// [variance.js] +"use strict"; +// Test cases for parameter variances affected by conditional types. +var foo = { prop: true }; +var x = foo; +var y = foo; +var z = x; +// Repro from #30118 +var Bar = /** @class */ (function () { + function Bar() { + } + Bar.prototype.cast = function (_name) { }; + Bar.prototype.pushThis = function () { + Bar.instance.push(this); + }; + return Bar; +}()); diff --git a/tests/baselines/reference/variance.symbols b/tests/baselines/reference/variance.symbols new file mode 100644 index 0000000000000..0a6ec56d725b6 --- /dev/null +++ b/tests/baselines/reference/variance.symbols @@ -0,0 +1,62 @@ +=== tests/cases/conformance/types/conditional/variance.ts === +// Test cases for parameter variances affected by conditional types. + +// Repro from #30047 + +interface Foo { +>Foo : Symbol(Foo, Decl(variance.ts, 0, 0)) +>T : Symbol(T, Decl(variance.ts, 4, 14)) + + prop: T extends unknown ? true : false; +>prop : Symbol(Foo.prop, Decl(variance.ts, 4, 18)) +>T : Symbol(T, Decl(variance.ts, 4, 14)) +} + +const foo = { prop: true } as const; +>foo : Symbol(foo, Decl(variance.ts, 8, 5)) +>prop : Symbol(prop, Decl(variance.ts, 8, 13)) + +const x: Foo<1> = foo; +>x : Symbol(x, Decl(variance.ts, 9, 5)) +>Foo : Symbol(Foo, Decl(variance.ts, 0, 0)) +>foo : Symbol(foo, Decl(variance.ts, 8, 5)) + +const y: Foo = foo; +>y : Symbol(y, Decl(variance.ts, 10, 5)) +>Foo : Symbol(Foo, Decl(variance.ts, 0, 0)) +>foo : Symbol(foo, Decl(variance.ts, 8, 5)) + +const z: Foo = x; +>z : Symbol(z, Decl(variance.ts, 11, 5)) +>Foo : Symbol(Foo, Decl(variance.ts, 0, 0)) +>x : Symbol(x, Decl(variance.ts, 9, 5)) + + +// Repro from #30118 + +class Bar { +>Bar : Symbol(Bar, Decl(variance.ts, 11, 25)) +>T : Symbol(T, Decl(variance.ts, 16, 10)) + + private static instance: Bar[]; +>instance : Symbol(Bar.instance, Decl(variance.ts, 16, 29)) +>Bar : Symbol(Bar, Decl(variance.ts, 11, 25)) + + cast(_name: ([T] extends [string] ? string : string)) { } +>cast : Symbol(Bar.cast, Decl(variance.ts, 17, 41)) +>_name : Symbol(_name, Decl(variance.ts, 19, 7)) +>T : Symbol(T, Decl(variance.ts, 16, 10)) + + pushThis() { +>pushThis : Symbol(Bar.pushThis, Decl(variance.ts, 19, 59)) + + Bar.instance.push(this); +>Bar.instance.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>Bar.instance : Symbol(Bar.instance, Decl(variance.ts, 16, 29)) +>Bar : Symbol(Bar, Decl(variance.ts, 11, 25)) +>instance : Symbol(Bar.instance, Decl(variance.ts, 16, 29)) +>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --)) +>this : Symbol(Bar, Decl(variance.ts, 11, 25)) + } +} + diff --git a/tests/baselines/reference/variance.types b/tests/baselines/reference/variance.types new file mode 100644 index 0000000000000..210c00aee9665 --- /dev/null +++ b/tests/baselines/reference/variance.types @@ -0,0 +1,58 @@ +=== tests/cases/conformance/types/conditional/variance.ts === +// Test cases for parameter variances affected by conditional types. + +// Repro from #30047 + +interface Foo { + prop: T extends unknown ? true : false; +>prop : T extends unknown ? true : false +>true : true +>false : false +} + +const foo = { prop: true } as const; +>foo : { readonly prop: true; } +>{ prop: true } as const : { readonly prop: true; } +>{ prop: true } : { readonly prop: true; } +>prop : true +>true : true + +const x: Foo<1> = foo; +>x : Foo<1> +>foo : { readonly prop: true; } + +const y: Foo = foo; +>y : Foo +>foo : { readonly prop: true; } + +const z: Foo = x; +>z : Foo +>x : Foo<1> + + +// Repro from #30118 + +class Bar { +>Bar : Bar + + private static instance: Bar[]; +>instance : Bar[] + + cast(_name: ([T] extends [string] ? string : string)) { } +>cast : (_name: [T] extends [string] ? string : string) => void +>_name : [T] extends [string] ? string : string + + pushThis() { +>pushThis : () => void + + Bar.instance.push(this); +>Bar.instance.push(this) : number +>Bar.instance.push : (...items: Bar[]) => number +>Bar.instance : Bar[] +>Bar : typeof Bar +>instance : Bar[] +>push : (...items: Bar[]) => number +>this : this + } +} + diff --git a/tests/cases/conformance/types/conditional/variance.ts b/tests/cases/conformance/types/conditional/variance.ts new file mode 100644 index 0000000000000..1dd5db5c67e8f --- /dev/null +++ b/tests/cases/conformance/types/conditional/variance.ts @@ -0,0 +1,27 @@ +// @strict: true + +// Test cases for parameter variances affected by conditional types. + +// Repro from #30047 + +interface Foo { + prop: T extends unknown ? true : false; +} + +const foo = { prop: true } as const; +const x: Foo<1> = foo; +const y: Foo = foo; +const z: Foo = x; + + +// Repro from #30118 + +class Bar { + private static instance: Bar[]; + + cast(_name: ([T] extends [string] ? string : string)) { } + + pushThis() { + Bar.instance.push(this); + } +}