From 263c54edd4713565c31f157cdc42b401f3abb2ca Mon Sep 17 00:00:00 2001 From: Jason Freeman Date: Wed, 8 Jul 2015 16:17:03 -0700 Subject: [PATCH] Add tests for type parameter fixing --- .../fixingTypeParametersRepeatedly1.js | 12 +++ .../fixingTypeParametersRepeatedly1.symbols | 51 ++++++++++++ .../fixingTypeParametersRepeatedly1.types | 63 +++++++++++++++ ...fixingTypeParametersRepeatedly2.errors.txt | 32 ++++++++ .../fixingTypeParametersRepeatedly2.js | 23 ++++++ .../fixingTypeParametersRepeatedly3.js | 23 ++++++ .../fixingTypeParametersRepeatedly3.symbols | 73 +++++++++++++++++ .../fixingTypeParametersRepeatedly3.types | 79 +++++++++++++++++++ .../fixingTypeParametersRepeatedly1.ts | 7 ++ .../fixingTypeParametersRepeatedly2.ts | 17 ++++ .../fixingTypeParametersRepeatedly3.ts | 17 ++++ .../fixingTypeParametersQuickInfo.ts | 13 +++ 12 files changed, 410 insertions(+) create mode 100644 tests/baselines/reference/fixingTypeParametersRepeatedly1.js create mode 100644 tests/baselines/reference/fixingTypeParametersRepeatedly1.symbols create mode 100644 tests/baselines/reference/fixingTypeParametersRepeatedly1.types create mode 100644 tests/baselines/reference/fixingTypeParametersRepeatedly2.errors.txt create mode 100644 tests/baselines/reference/fixingTypeParametersRepeatedly2.js create mode 100644 tests/baselines/reference/fixingTypeParametersRepeatedly3.js create mode 100644 tests/baselines/reference/fixingTypeParametersRepeatedly3.symbols create mode 100644 tests/baselines/reference/fixingTypeParametersRepeatedly3.types create mode 100644 tests/cases/compiler/fixingTypeParametersRepeatedly1.ts create mode 100644 tests/cases/compiler/fixingTypeParametersRepeatedly2.ts create mode 100644 tests/cases/compiler/fixingTypeParametersRepeatedly3.ts create mode 100644 tests/cases/fourslash/fixingTypeParametersQuickInfo.ts diff --git a/tests/baselines/reference/fixingTypeParametersRepeatedly1.js b/tests/baselines/reference/fixingTypeParametersRepeatedly1.js new file mode 100644 index 00000000000..93ab8ba9888 --- /dev/null +++ b/tests/baselines/reference/fixingTypeParametersRepeatedly1.js @@ -0,0 +1,12 @@ +//// [fixingTypeParametersRepeatedly1.ts] +declare function f(x: T, y: (p: T) => T, z: (p: T) => T): T; +f("", x => null, x => x.toLowerCase()); + +// First overload of g should type check just like f +declare function g(x: T, y: (p: T) => T, z: (p: T) => T): T; +declare function g(); +g("", x => null, x => x.toLowerCase()); + +//// [fixingTypeParametersRepeatedly1.js] +f("", function (x) { return null; }, function (x) { return x.toLowerCase(); }); +g("", function (x) { return null; }, function (x) { return x.toLowerCase(); }); diff --git a/tests/baselines/reference/fixingTypeParametersRepeatedly1.symbols b/tests/baselines/reference/fixingTypeParametersRepeatedly1.symbols new file mode 100644 index 00000000000..998e59c0b8f --- /dev/null +++ b/tests/baselines/reference/fixingTypeParametersRepeatedly1.symbols @@ -0,0 +1,51 @@ +=== tests/cases/compiler/fixingTypeParametersRepeatedly1.ts === +declare function f(x: T, y: (p: T) => T, z: (p: T) => T): T; +>f : Symbol(f, Decl(fixingTypeParametersRepeatedly1.ts, 0, 0)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly1.ts, 0, 19)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 0, 22)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly1.ts, 0, 19)) +>y : Symbol(y, Decl(fixingTypeParametersRepeatedly1.ts, 0, 27)) +>p : Symbol(p, Decl(fixingTypeParametersRepeatedly1.ts, 0, 32)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly1.ts, 0, 19)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly1.ts, 0, 19)) +>z : Symbol(z, Decl(fixingTypeParametersRepeatedly1.ts, 0, 43)) +>p : Symbol(p, Decl(fixingTypeParametersRepeatedly1.ts, 0, 48)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly1.ts, 0, 19)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly1.ts, 0, 19)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly1.ts, 0, 19)) + +f("", x => null, x => x.toLowerCase()); +>f : Symbol(f, Decl(fixingTypeParametersRepeatedly1.ts, 0, 0)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 1, 5)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 1, 16)) +>x.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 1, 16)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) + +// First overload of g should type check just like f +declare function g(x: T, y: (p: T) => T, z: (p: T) => T): T; +>g : Symbol(g, Decl(fixingTypeParametersRepeatedly1.ts, 1, 39), Decl(fixingTypeParametersRepeatedly1.ts, 4, 63)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly1.ts, 4, 19)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 4, 22)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly1.ts, 4, 19)) +>y : Symbol(y, Decl(fixingTypeParametersRepeatedly1.ts, 4, 27)) +>p : Symbol(p, Decl(fixingTypeParametersRepeatedly1.ts, 4, 32)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly1.ts, 4, 19)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly1.ts, 4, 19)) +>z : Symbol(z, Decl(fixingTypeParametersRepeatedly1.ts, 4, 43)) +>p : Symbol(p, Decl(fixingTypeParametersRepeatedly1.ts, 4, 48)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly1.ts, 4, 19)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly1.ts, 4, 19)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly1.ts, 4, 19)) + +declare function g(); +>g : Symbol(g, Decl(fixingTypeParametersRepeatedly1.ts, 1, 39), Decl(fixingTypeParametersRepeatedly1.ts, 4, 63)) + +g("", x => null, x => x.toLowerCase()); +>g : Symbol(g, Decl(fixingTypeParametersRepeatedly1.ts, 1, 39), Decl(fixingTypeParametersRepeatedly1.ts, 4, 63)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 6, 5)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 6, 16)) +>x.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 6, 16)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) + diff --git a/tests/baselines/reference/fixingTypeParametersRepeatedly1.types b/tests/baselines/reference/fixingTypeParametersRepeatedly1.types new file mode 100644 index 00000000000..273c66b342d --- /dev/null +++ b/tests/baselines/reference/fixingTypeParametersRepeatedly1.types @@ -0,0 +1,63 @@ +=== tests/cases/compiler/fixingTypeParametersRepeatedly1.ts === +declare function f(x: T, y: (p: T) => T, z: (p: T) => T): T; +>f : (x: T, y: (p: T) => T, z: (p: T) => T) => T +>T : T +>x : T +>T : T +>y : (p: T) => T +>p : T +>T : T +>T : T +>z : (p: T) => T +>p : T +>T : T +>T : T +>T : T + +f("", x => null, x => x.toLowerCase()); +>f("", x => null, x => x.toLowerCase()) : string +>f : (x: T, y: (p: T) => T, z: (p: T) => T) => T +>"" : string +>x => null : (x: string) => any +>x : string +>null : null +>x => x.toLowerCase() : (x: string) => string +>x : string +>x.toLowerCase() : string +>x.toLowerCase : () => string +>x : string +>toLowerCase : () => string + +// First overload of g should type check just like f +declare function g(x: T, y: (p: T) => T, z: (p: T) => T): T; +>g : { (x: T, y: (p: T) => T, z: (p: T) => T): T; (): any; } +>T : T +>x : T +>T : T +>y : (p: T) => T +>p : T +>T : T +>T : T +>z : (p: T) => T +>p : T +>T : T +>T : T +>T : T + +declare function g(); +>g : { (x: T, y: (p: T) => T, z: (p: T) => T): T; (): any; } + +g("", x => null, x => x.toLowerCase()); +>g("", x => null, x => x.toLowerCase()) : string +>g : { (x: T, y: (p: T) => T, z: (p: T) => T): T; (): any; } +>"" : string +>x => null : (x: string) => any +>x : string +>null : null +>x => x.toLowerCase() : (x: string) => string +>x : string +>x.toLowerCase() : string +>x.toLowerCase : () => string +>x : string +>toLowerCase : () => string + diff --git a/tests/baselines/reference/fixingTypeParametersRepeatedly2.errors.txt b/tests/baselines/reference/fixingTypeParametersRepeatedly2.errors.txt new file mode 100644 index 00000000000..e56b58a268d --- /dev/null +++ b/tests/baselines/reference/fixingTypeParametersRepeatedly2.errors.txt @@ -0,0 +1,32 @@ +tests/cases/compiler/fixingTypeParametersRepeatedly2.ts(11,27): error TS2345: Argument of type '(d: Derived) => Base' is not assignable to parameter of type '(p: Derived) => Derived'. + Type 'Base' is not assignable to type 'Derived'. + Property 'toBase' is missing in type 'Base'. +tests/cases/compiler/fixingTypeParametersRepeatedly2.ts(17,27): error TS2345: Argument of type '(d: Derived) => Base' is not assignable to parameter of type '(p: Derived) => Derived'. + Type 'Base' is not assignable to type 'Derived'. + + +==== tests/cases/compiler/fixingTypeParametersRepeatedly2.ts (2 errors) ==== + interface Base { + baseProp; + } + interface Derived extends Base { + toBase(): Base; + } + + var derived: Derived; + + declare function foo(x: T, func: (p: T) => T): T; + var result = foo(derived, d => d.toBase()); + ~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '(d: Derived) => Base' is not assignable to parameter of type '(p: Derived) => Derived'. +!!! error TS2345: Type 'Base' is not assignable to type 'Derived'. +!!! error TS2345: Property 'toBase' is missing in type 'Base'. + + // bar should type check just like foo. + // The same error should be observed in both cases. + declare function bar(x: T, func: (p: T) => T): T; + declare function bar(x: T, func: (p: T) => T): T; + var result = bar(derived, d => d.toBase()); + ~~~~~~~~~~~~~~~ +!!! error TS2345: Argument of type '(d: Derived) => Base' is not assignable to parameter of type '(p: Derived) => Derived'. +!!! error TS2345: Type 'Base' is not assignable to type 'Derived'. \ No newline at end of file diff --git a/tests/baselines/reference/fixingTypeParametersRepeatedly2.js b/tests/baselines/reference/fixingTypeParametersRepeatedly2.js new file mode 100644 index 00000000000..9ebf426bbd2 --- /dev/null +++ b/tests/baselines/reference/fixingTypeParametersRepeatedly2.js @@ -0,0 +1,23 @@ +//// [fixingTypeParametersRepeatedly2.ts] +interface Base { + baseProp; +} +interface Derived extends Base { + toBase(): Base; +} + +var derived: Derived; + +declare function foo(x: T, func: (p: T) => T): T; +var result = foo(derived, d => d.toBase()); + +// bar should type check just like foo. +// The same error should be observed in both cases. +declare function bar(x: T, func: (p: T) => T): T; +declare function bar(x: T, func: (p: T) => T): T; +var result = bar(derived, d => d.toBase()); + +//// [fixingTypeParametersRepeatedly2.js] +var derived; +var result = foo(derived, function (d) { return d.toBase(); }); +var result = bar(derived, function (d) { return d.toBase(); }); diff --git a/tests/baselines/reference/fixingTypeParametersRepeatedly3.js b/tests/baselines/reference/fixingTypeParametersRepeatedly3.js new file mode 100644 index 00000000000..83a47c92c34 --- /dev/null +++ b/tests/baselines/reference/fixingTypeParametersRepeatedly3.js @@ -0,0 +1,23 @@ +//// [fixingTypeParametersRepeatedly3.ts] +interface Base { + baseProp; +} +interface Derived extends Base { + toBase?(): Base; +} + +var derived: Derived; + +declare function foo(x: T, func: (p: T) => T): T; +var result = foo(derived, d => d.toBase()); + +// bar should type check just like foo. +// result2 should have the same type as result +declare function bar(x: T, func: (p: T) => T): T; +declare function bar(x: T, func: (p: T) => T): T; +var result2 = bar(derived, d => d.toBase()); + +//// [fixingTypeParametersRepeatedly3.js] +var derived; +var result = foo(derived, function (d) { return d.toBase(); }); +var result2 = bar(derived, function (d) { return d.toBase(); }); diff --git a/tests/baselines/reference/fixingTypeParametersRepeatedly3.symbols b/tests/baselines/reference/fixingTypeParametersRepeatedly3.symbols new file mode 100644 index 00000000000..a849adb6235 --- /dev/null +++ b/tests/baselines/reference/fixingTypeParametersRepeatedly3.symbols @@ -0,0 +1,73 @@ +=== tests/cases/compiler/fixingTypeParametersRepeatedly3.ts === +interface Base { +>Base : Symbol(Base, Decl(fixingTypeParametersRepeatedly3.ts, 0, 0)) + + baseProp; +>baseProp : Symbol(baseProp, Decl(fixingTypeParametersRepeatedly3.ts, 0, 16)) +} +interface Derived extends Base { +>Derived : Symbol(Derived, Decl(fixingTypeParametersRepeatedly3.ts, 2, 1)) +>Base : Symbol(Base, Decl(fixingTypeParametersRepeatedly3.ts, 0, 0)) + + toBase?(): Base; +>toBase : Symbol(toBase, Decl(fixingTypeParametersRepeatedly3.ts, 3, 32)) +>Base : Symbol(Base, Decl(fixingTypeParametersRepeatedly3.ts, 0, 0)) +} + +var derived: Derived; +>derived : Symbol(derived, Decl(fixingTypeParametersRepeatedly3.ts, 7, 3)) +>Derived : Symbol(Derived, Decl(fixingTypeParametersRepeatedly3.ts, 2, 1)) + +declare function foo(x: T, func: (p: T) => T): T; +>foo : Symbol(foo, Decl(fixingTypeParametersRepeatedly3.ts, 7, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 9, 21)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly3.ts, 9, 24)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 9, 21)) +>func : Symbol(func, Decl(fixingTypeParametersRepeatedly3.ts, 9, 29)) +>p : Symbol(p, Decl(fixingTypeParametersRepeatedly3.ts, 9, 37)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 9, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 9, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 9, 21)) + +var result = foo(derived, d => d.toBase()); +>result : Symbol(result, Decl(fixingTypeParametersRepeatedly3.ts, 10, 3)) +>foo : Symbol(foo, Decl(fixingTypeParametersRepeatedly3.ts, 7, 21)) +>derived : Symbol(derived, Decl(fixingTypeParametersRepeatedly3.ts, 7, 3)) +>d : Symbol(d, Decl(fixingTypeParametersRepeatedly3.ts, 10, 25)) +>d.toBase : Symbol(Derived.toBase, Decl(fixingTypeParametersRepeatedly3.ts, 3, 32)) +>d : Symbol(d, Decl(fixingTypeParametersRepeatedly3.ts, 10, 25)) +>toBase : Symbol(Derived.toBase, Decl(fixingTypeParametersRepeatedly3.ts, 3, 32)) + +// bar should type check just like foo. +// result2 should have the same type as result +declare function bar(x: T, func: (p: T) => T): T; +>bar : Symbol(bar, Decl(fixingTypeParametersRepeatedly3.ts, 10, 43), Decl(fixingTypeParametersRepeatedly3.ts, 14, 52)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 14, 21)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly3.ts, 14, 24)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 14, 21)) +>func : Symbol(func, Decl(fixingTypeParametersRepeatedly3.ts, 14, 29)) +>p : Symbol(p, Decl(fixingTypeParametersRepeatedly3.ts, 14, 37)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 14, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 14, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 14, 21)) + +declare function bar(x: T, func: (p: T) => T): T; +>bar : Symbol(bar, Decl(fixingTypeParametersRepeatedly3.ts, 10, 43), Decl(fixingTypeParametersRepeatedly3.ts, 14, 52)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 15, 21)) +>x : Symbol(x, Decl(fixingTypeParametersRepeatedly3.ts, 15, 24)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 15, 21)) +>func : Symbol(func, Decl(fixingTypeParametersRepeatedly3.ts, 15, 29)) +>p : Symbol(p, Decl(fixingTypeParametersRepeatedly3.ts, 15, 37)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 15, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 15, 21)) +>T : Symbol(T, Decl(fixingTypeParametersRepeatedly3.ts, 15, 21)) + +var result2 = bar(derived, d => d.toBase()); +>result2 : Symbol(result2, Decl(fixingTypeParametersRepeatedly3.ts, 16, 3)) +>bar : Symbol(bar, Decl(fixingTypeParametersRepeatedly3.ts, 10, 43), Decl(fixingTypeParametersRepeatedly3.ts, 14, 52)) +>derived : Symbol(derived, Decl(fixingTypeParametersRepeatedly3.ts, 7, 3)) +>d : Symbol(d, Decl(fixingTypeParametersRepeatedly3.ts, 16, 26)) +>d.toBase : Symbol(Derived.toBase, Decl(fixingTypeParametersRepeatedly3.ts, 3, 32)) +>d : Symbol(d, Decl(fixingTypeParametersRepeatedly3.ts, 16, 26)) +>toBase : Symbol(Derived.toBase, Decl(fixingTypeParametersRepeatedly3.ts, 3, 32)) + diff --git a/tests/baselines/reference/fixingTypeParametersRepeatedly3.types b/tests/baselines/reference/fixingTypeParametersRepeatedly3.types new file mode 100644 index 00000000000..3bf926276d2 --- /dev/null +++ b/tests/baselines/reference/fixingTypeParametersRepeatedly3.types @@ -0,0 +1,79 @@ +=== tests/cases/compiler/fixingTypeParametersRepeatedly3.ts === +interface Base { +>Base : Base + + baseProp; +>baseProp : any +} +interface Derived extends Base { +>Derived : Derived +>Base : Base + + toBase?(): Base; +>toBase : () => Base +>Base : Base +} + +var derived: Derived; +>derived : Derived +>Derived : Derived + +declare function foo(x: T, func: (p: T) => T): T; +>foo : (x: T, func: (p: T) => T) => T +>T : T +>x : T +>T : T +>func : (p: T) => T +>p : T +>T : T +>T : T +>T : T + +var result = foo(derived, d => d.toBase()); +>result : Derived +>foo(derived, d => d.toBase()) : Derived +>foo : (x: T, func: (p: T) => T) => T +>derived : Derived +>d => d.toBase() : (d: Derived) => Base +>d : Derived +>d.toBase() : Base +>d.toBase : () => Base +>d : Derived +>toBase : () => Base + +// bar should type check just like foo. +// result2 should have the same type as result +declare function bar(x: T, func: (p: T) => T): T; +>bar : { (x: T, func: (p: T) => T): T; (x: T, func: (p: T) => T): T; } +>T : T +>x : T +>T : T +>func : (p: T) => T +>p : T +>T : T +>T : T +>T : T + +declare function bar(x: T, func: (p: T) => T): T; +>bar : { (x: T, func: (p: T) => T): T; (x: T, func: (p: T) => T): T; } +>T : T +>x : T +>T : T +>func : (p: T) => T +>p : T +>T : T +>T : T +>T : T + +var result2 = bar(derived, d => d.toBase()); +>result2 : Derived +>bar(derived, d => d.toBase()) : Derived +>bar : { (x: T, func: (p: T) => T): T; (x: T, func: (p: T) => T): T; } +>derived : Derived +>d => d.toBase() : (d: Derived) => Base +>d : Derived +>d.toBase() : Base +>d.toBase : () => Base +>d : Derived +>toBase : () => Base + diff --git a/tests/cases/compiler/fixingTypeParametersRepeatedly1.ts b/tests/cases/compiler/fixingTypeParametersRepeatedly1.ts new file mode 100644 index 00000000000..d02e434c61c --- /dev/null +++ b/tests/cases/compiler/fixingTypeParametersRepeatedly1.ts @@ -0,0 +1,7 @@ +declare function f(x: T, y: (p: T) => T, z: (p: T) => T): T; +f("", x => null, x => x.toLowerCase()); + +// First overload of g should type check just like f +declare function g(x: T, y: (p: T) => T, z: (p: T) => T): T; +declare function g(); +g("", x => null, x => x.toLowerCase()); \ No newline at end of file diff --git a/tests/cases/compiler/fixingTypeParametersRepeatedly2.ts b/tests/cases/compiler/fixingTypeParametersRepeatedly2.ts new file mode 100644 index 00000000000..b439838862f --- /dev/null +++ b/tests/cases/compiler/fixingTypeParametersRepeatedly2.ts @@ -0,0 +1,17 @@ +interface Base { + baseProp; +} +interface Derived extends Base { + toBase(): Base; +} + +var derived: Derived; + +declare function foo(x: T, func: (p: T) => T): T; +var result = foo(derived, d => d.toBase()); + +// bar should type check just like foo. +// The same error should be observed in both cases. +declare function bar(x: T, func: (p: T) => T): T; +declare function bar(x: T, func: (p: T) => T): T; +var result = bar(derived, d => d.toBase()); \ No newline at end of file diff --git a/tests/cases/compiler/fixingTypeParametersRepeatedly3.ts b/tests/cases/compiler/fixingTypeParametersRepeatedly3.ts new file mode 100644 index 00000000000..1ffba2e50c6 --- /dev/null +++ b/tests/cases/compiler/fixingTypeParametersRepeatedly3.ts @@ -0,0 +1,17 @@ +interface Base { + baseProp; +} +interface Derived extends Base { + toBase?(): Base; +} + +var derived: Derived; + +declare function foo(x: T, func: (p: T) => T): T; +var result = foo(derived, d => d.toBase()); + +// bar should type check just like foo. +// result2 should have the same type as result +declare function bar(x: T, func: (p: T) => T): T; +declare function bar(x: T, func: (p: T) => T): T; +var result2 = bar(derived, d => d.toBase()); \ No newline at end of file diff --git a/tests/cases/fourslash/fixingTypeParametersQuickInfo.ts b/tests/cases/fourslash/fixingTypeParametersQuickInfo.ts new file mode 100644 index 00000000000..033663052be --- /dev/null +++ b/tests/cases/fourslash/fixingTypeParametersQuickInfo.ts @@ -0,0 +1,13 @@ +/// + +////declare function f(x: T, y: (p: T) => T, z: (p: T) => T): T; +////var /*1*/result = /*2*/f(0, /*3*/x => null, /*4*/x => x.blahblah); + +goTo.marker('1'); +verify.quickInfoIs('var result: number'); +goTo.marker('2'); +verify.quickInfoIs('function f(x: number, y: (p: number) => number, z: (p: number) => number): number'); +goTo.marker('3'); +verify.quickInfoIs('(parameter) x: number'); +goTo.marker('4'); +verify.quickInfoIs('(parameter) x: number'); \ No newline at end of file