2014-08-15 23:33:16 +02:00
=== tests/cases/conformance/types/typeParameters/typeParameterLists/propertyAccessOnTypeParameterWithConstraints2.ts ===
// generic types should behave as if they have properties of their constraint type
class A {
>A : A
foo(): string { return ''; }
>foo : () => string
}
class B extends A {
>B : B
>A : A
bar(): string {
>bar : () => string
return '';
}
}
class C<U extends A, T extends A> {
>C : C<U, T>
>U : U
>A : A
>T : T
>A : A
f() {
>f : () => string
var x: U;
>x : U
>U : U
var a = x['foo'](); // should be string
>a : string
>x['foo']() : string
>x['foo'] : () => string
>x : U
return a + x.foo();
>a + x.foo() : string
>a : string
>x.foo() : string
>x.foo : () => string
>x : U
>foo : () => string
}
g(x: U) {
>g : (x: U) => string
>x : U
>U : U
var a = x['foo'](); // should be string
>a : string
>x['foo']() : string
>x['foo'] : () => string
>x : U
return a + x.foo();
>a + x.foo() : string
>a : string
>x.foo() : string
>x.foo : () => string
>x : U
>foo : () => string
}
}
//class C<U extends T, T extends A> {
// f() {
// var x: U;
// var a = x['foo'](); // should be string
// return a + x.foo();
// }
// g(x: U) {
// var a = x['foo'](); // should be string
// return a + x.foo();
// }
//}
var r1 = (new C<B, A>()).f();
>r1 : string
>(new C<B, A>()).f() : string
>(new C<B, A>()).f : () => string
>(new C<B, A>()) : C<B, A>
>new C<B, A>() : C<B, A>
>C : typeof C
>B : B
>A : A
>f : () => string
var r1b = (new C<B, A>()).g(new B());
>r1b : string
>(new C<B, A>()).g(new B()) : string
>(new C<B, A>()).g : (x: B) => string
>(new C<B, A>()) : C<B, A>
>new C<B, A>() : C<B, A>
>C : typeof C
>B : B
>A : A
>g : (x: B) => string
>new B() : B
>B : typeof B
interface I<U extends A, T extends A> {
>I : I<U, T>
>U : U
>A : A
>T : T
>A : A
foo: U;
>foo : U
>U : U
}
//interface I<U extends T, T extends A> {
// foo: U;
//}
var i: I<B, A>;
>i : I<B, A>
2014-08-19 04:56:03 +02:00
>I : I<U, T>
2014-08-15 23:33:16 +02:00
>B : B
>A : A
var r2 = i.foo.foo();
>r2 : string
>i.foo.foo() : string
>i.foo.foo : () => string
>i.foo : B
>i : I<B, A>
>foo : B
>foo : () => string
var r2b = i.foo['foo']();
>r2b : string
>i.foo['foo']() : string
>i.foo['foo'] : () => string
>i.foo : B
>i : I<B, A>
>foo : B
var a: {
>a : { <U extends A, T extends A>(): U; <U extends A, T extends A>(x: U): U; <U extends A, T extends A>(x: U, y: T): U; }
<U extends A, T extends A>(): U;
>U : U
>A : A
>T : T
>A : A
>U : U
<U extends A, T extends A>(x: U): U;
>U : U
>A : A
>T : T
>A : A
>x : U
>U : U
>U : U
<U extends A, T extends A>(x: U, y: T): U;
>U : U
>A : A
>T : T
>A : A
>x : U
>U : U
>y : T
>T : T
>U : U
}
//var a: {
// <U extends T, T extends A>(): U;
// <U extends T, T extends A>(x: U): U;
// <U extends T, T extends A>(x: U, y: T): U;
//}
var r3 = a<A, A>().foo();
>r3 : string
>a<A, A>().foo() : string
>a<A, A>().foo : () => string
>a<A, A>() : A
>a : { <U extends A, T extends A>(): U; <U extends A, T extends A>(x: U): U; <U extends A, T extends A>(x: U, y: T): U; }
>A : A
>A : A
>foo : () => string
var r3b = a()['foo']();
>r3b : string
>a()['foo']() : string
>a()['foo'] : () => string
>a() : A
>a : { <U extends A, T extends A>(): U; <U extends A, T extends A>(x: U): U; <U extends A, T extends A>(x: U, y: T): U; }
// parameter supplied for type argument inference to succeed
var aB = new B();
>aB : B
>new B() : B
>B : typeof B
var r3c = a(aB, aB).foo();
>r3c : string
>a(aB, aB).foo() : string
>a(aB, aB).foo : () => string
>a(aB, aB) : B
>a : { <U extends A, T extends A>(): U; <U extends A, T extends A>(x: U): U; <U extends A, T extends A>(x: U, y: T): U; }
>aB : B
>aB : B
>foo : () => string
var r3d = a(aB, aB)['foo']();
>r3d : string
>a(aB, aB)['foo']() : string
>a(aB, aB)['foo'] : () => string
>a(aB, aB) : B
>a : { <U extends A, T extends A>(): U; <U extends A, T extends A>(x: U): U; <U extends A, T extends A>(x: U, y: T): U; }
>aB : B
>aB : B
var b = {
>b : { foo: <U extends A, T extends A>(x: U, y: T) => string; }
2014-08-22 03:39:46 +02:00
>{ foo: <U extends A, T extends A>(x: U, y: T) => { var a = x['foo'](); // should be string return a + x.foo(); }} : { foo: <U extends A, T extends A>(x: U, y: T) => string; }
2014-08-15 23:33:16 +02:00
foo: <U extends A, T extends A>(x: U, y: T) => {
>foo : <U extends A, T extends A>(x: U, y: T) => string
2014-08-22 03:39:46 +02:00
><U extends A, T extends A>(x: U, y: T) => { var a = x['foo'](); // should be string return a + x.foo(); } : <U extends A, T extends A>(x: U, y: T) => string
2014-08-15 23:33:16 +02:00
>U : U
>A : A
>T : T
>A : A
>x : U
>U : U
>y : T
>T : T
var a = x['foo'](); // should be string
>a : string
>x['foo']() : string
>x['foo'] : () => string
>x : U
return a + x.foo();
>a + x.foo() : string
>a : string
>x.foo() : string
>x.foo : () => string
>x : U
>foo : () => string
}
}
//var b = {
// foo: <U extends T, T extends A>(x: U, y: T) => {
// var a = x['foo'](); // should be string
// return a + x.foo();
// }
//}
var r4 = b.foo(aB, aB); // no inferences for T so constraint isn't satisfied, error
>r4 : string
>b.foo(aB, aB) : string
>b.foo : <U extends A, T extends A>(x: U, y: T) => string
>b : { foo: <U extends A, T extends A>(x: U, y: T) => string; }
>foo : <U extends A, T extends A>(x: U, y: T) => string
>aB : B
>aB : B