276 lines
5.6 KiB
Text
276 lines
5.6 KiB
Text
=== 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
|
|
>'' : string
|
|
}
|
|
|
|
class B extends A {
|
|
>B : B
|
|
>A : A
|
|
|
|
bar(): string {
|
|
>bar : () => string
|
|
|
|
return '';
|
|
>'' : string
|
|
}
|
|
}
|
|
|
|
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
|
|
>'foo' : string
|
|
|
|
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
|
|
>'foo' : string
|
|
|
|
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>
|
|
>I : I<U, T>
|
|
>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
|
|
>'foo' : string
|
|
|
|
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; }
|
|
>'foo' : string
|
|
|
|
// 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
|
|
>'foo' : string
|
|
|
|
var b = {
|
|
>b : { foo: <U extends A, T extends A>(x: U, y: T) => string; }
|
|
>{ 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; }
|
|
|
|
foo: <U extends A, T extends A>(x: U, y: T) => {
|
|
>foo : <U extends A, T extends A>(x: U, y: T) => string
|
|
><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
|
|
>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
|
|
>'foo' : string
|
|
|
|
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
|
|
|