microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-15 20:25:23 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Add tests and baselines

Browse Source
This commit is contained in:
Kanchalai Tanglertsampan 2016-10-28 16:39:05 -07:00
parent 2869f9cb05
commit 01e06f9295
20 changed files with 395 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters1.types
View File

@ -8,7 +8,7 @@ export type Bar<X, Y> = () => [X, Y];
>Y : Y
export type Foo<Y> = Bar<any, Y>;
>Foo : () => [any, Y]
>Foo : Bar<any, Y>
>Y : Y
>Bar : Bar<X, Y>
>Y : Y
@ -17,6 +17,6 @@ export const y = (x: Foo<string>) => 1
>y : (x: () => [any, string]) => number
>(x: Foo<string>) => 1 : (x: () => [any, string]) => number
>x : () => [any, string]
>Foo : () => [any, Y]
>Foo : Bar<any, Y>
>1 : 1

17
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.js Normal file
View File

@ -0,0 +1,17 @@
//// [declarationEmitTypeAliasWithTypeParameters2.ts]
export type Bar<X, Y, Z> = () => [X, Y, Z];
export type Baz<M, N> = Bar<M, string, N>;
export type Baa<Y> = Baz<boolean, Y>;
export const y = (x: Baa<number>) => 1
//// [declarationEmitTypeAliasWithTypeParameters2.js]
"use strict";
exports.y = function (x) { return 1; };
//// [declarationEmitTypeAliasWithTypeParameters2.d.ts]
export declare type Bar<X, Y, Z> = () => [X, Y, Z];
export declare type Baz<M, N> = Bar<M, string, N>;
export declare type Baa<Y> = Baz<boolean, Y>;
export declare const y: (x: () => [boolean, string, number]) => number;

30
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.symbols Normal file
View File

@ -0,0 +1,30 @@
=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters2.ts ===
export type Bar<X, Y, Z> = () => [X, Y, Z];
>Bar : Symbol(Bar, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 0))
>X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 16))
>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 18))
>Z : Symbol(Z, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 21))
>X : Symbol(X, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 16))
>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 18))
>Z : Symbol(Z, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 21))
export type Baz<M, N> = Bar<M, string, N>;
>Baz : Symbol(Baz, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 43))
>M : Symbol(M, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 16))
>N : Symbol(N, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 18))
>Bar : Symbol(Bar, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 0, 0))
>M : Symbol(M, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 16))
>N : Symbol(N, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 18))
export type Baa<Y> = Baz<boolean, Y>;
>Baa : Symbol(Baa, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 42))
>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 3, 16))
>Baz : Symbol(Baz, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 1, 43))
>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 3, 16))
export const y = (x: Baa<number>) => 1
>y : Symbol(y, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 4, 12))
>x : Symbol(x, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 4, 18))
>Baa : Symbol(Baa, Decl(declarationEmitTypeAliasWithTypeParameters2.ts, 2, 42))

32
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters2.types Normal file
View File

@ -0,0 +1,32 @@
=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters2.ts ===
export type Bar<X, Y, Z> = () => [X, Y, Z];
>Bar : Bar<X, Y, Z>
>X : X
>Y : Y
>Z : Z
>X : X
>Y : Y
>Z : Z
export type Baz<M, N> = Bar<M, string, N>;
>Baz : Bar<M, string, N>
>M : M
>N : N
>Bar : Bar<X, Y, Z>
>M : M
>N : N
export type Baa<Y> = Baz<boolean, Y>;
>Baa : () => [boolean, string, Y]
>Y : Y
>Baz : Bar<M, string, N>
>Y : Y
export const y = (x: Baa<number>) => 1
>y : (x: () => [boolean, string, number]) => number
>(x: Baa<number>) => 1 : (x: () => [boolean, string, number]) => number
>x : () => [boolean, string, number]
>Baa : () => [boolean, string, Y]
>1 : 1

21
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.js Normal file
View File

@ -0,0 +1,21 @@
//// [declarationEmitTypeAliasWithTypeParameters3.ts]
type Foo<T> = {
foo<U>(): Foo<U>
};
function bar() {
return {} as Foo<number>;
}
//// [declarationEmitTypeAliasWithTypeParameters3.js]
function bar() {
return {};
}
//// [declarationEmitTypeAliasWithTypeParameters3.d.ts]
declare type Foo<T> = {
foo<U>(): Foo<U>;
};
declare function bar(): Foo<number>;

20
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.symbols Normal file
View File

@ -0,0 +1,20 @@
=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters3.ts ===
type Foo<T> = {
>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 0))
>T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 1, 9))
foo<U>(): Foo<U>
>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 1, 15))
>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 2, 8))
>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 0))
>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 2, 8))
};
function bar() {
>bar : Symbol(bar, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 3, 2))
return {} as Foo<number>;
>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters3.ts, 0, 0))
}

22
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters3.types Normal file
View File

@ -0,0 +1,22 @@
=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters3.ts ===
type Foo<T> = {
>Foo : Foo<T>
>T : T
foo<U>(): Foo<U>
>foo : <U>() => Foo<U>
>U : U
>Foo : Foo<T>
>U : U
};
function bar() {
>bar : () => Foo<number>
return {} as Foo<number>;
>{} as Foo<number> : Foo<number>
>{} : {}
>Foo : Foo<T>
}

26
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.js Normal file
View File

@ -0,0 +1,26 @@
//// [declarationEmitTypeAliasWithTypeParameters4.ts]
type Foo<T, Y> = {
foo<U, J>(): Foo<U, J>
};
type SubFoo<R> = Foo<string, R>;
function foo() {
return {} as SubFoo<number>;
}
//// [declarationEmitTypeAliasWithTypeParameters4.js]
function foo() {
return {};
}
//// [declarationEmitTypeAliasWithTypeParameters4.d.ts]
declare type Foo<T, Y> = {
foo<U, J>(): Foo<U, J>;
};
declare type SubFoo<R> = Foo<string, R>;
declare function foo(): {
foo<U, J>(): any;
};

29
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.symbols Normal file
View File

@ -0,0 +1,29 @@
=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters4.ts ===
type Foo<T, Y> = {
>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 0))
>T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 9))
>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 11))
foo<U, J>(): Foo<U, J>
>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 1, 18))
>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 8))
>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 10))
>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 0))
>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 8))
>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 2, 10))
};
type SubFoo<R> = Foo<string, R>;
>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 3, 2))
>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 4, 12))
>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 0, 0))
>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 4, 12))
function foo() {
>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 4, 32))
return {} as SubFoo<number>;
>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters4.ts, 3, 2))
}

31
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters4.types Normal file
View File

@ -0,0 +1,31 @@
=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters4.ts ===
type Foo<T, Y> = {
>Foo : Foo<T, Y>
>T : T
>Y : Y
foo<U, J>(): Foo<U, J>
>foo : <U, J>() => Foo<U, J>
>U : U
>J : J
>Foo : Foo<T, Y>
>U : U
>J : J
};
type SubFoo<R> = Foo<string, R>;
>SubFoo : Foo<string, R>
>R : R
>Foo : Foo<T, Y>
>R : R
function foo() {
>foo : () => { foo<U, J>(): any; }
return {} as SubFoo<number>;
>{} as SubFoo<number> : { foo<U, J>(): any; }
>{} : {}
>SubFoo : Foo<string, R>
}

16
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.errors.txt Normal file
View File

@ -0,0 +1,16 @@
tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters5.ts(5,25): error TS4081: Exported type alias 'SubFoo' has or is using private name 'Foo'.
==== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters5.ts (1 errors) ====
type Foo<T, Y> = {
foo<U, J>(): Foo<U, J>
};
export type SubFoo<R> = Foo<string, R>;
~~~
!!! error TS4081: Exported type alias 'SubFoo' has or is using private name 'Foo'.
function foo() {
return {} as SubFoo<number>;
}

17
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters5.js Normal file
View File

@ -0,0 +1,17 @@
//// [declarationEmitTypeAliasWithTypeParameters5.ts]
type Foo<T, Y> = {
foo<U, J>(): Foo<U, J>
};
export type SubFoo<R> = Foo<string, R>;
function foo() {
return {} as SubFoo<number>;
}
//// [declarationEmitTypeAliasWithTypeParameters5.js]
"use strict";
function foo() {
return {};
}

24
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.js Normal file
View File

@ -0,0 +1,24 @@
//// [declarationEmitTypeAliasWithTypeParameters6.ts]
type Foo<T, Y> = {
foo<U, J>(): Foo<U, J>
};
type SubFoo<R, S> = Foo<S, R>;
function foo() {
return {} as SubFoo<number, string>;
}
//// [declarationEmitTypeAliasWithTypeParameters6.js]
function foo() {
return {};
}
//// [declarationEmitTypeAliasWithTypeParameters6.d.ts]
declare type Foo<T, Y> = {
foo<U, J>(): Foo<U, J>;
};
declare type SubFoo<R, S> = Foo<S, R>;
declare function foo(): Foo<number, string>;

31
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.symbols Normal file
View File

@ -0,0 +1,31 @@
=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters6.ts ===
type Foo<T, Y> = {
>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 0))
>T : Symbol(T, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 9))
>Y : Symbol(Y, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 11))
foo<U, J>(): Foo<U, J>
>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 1, 18))
>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 8))
>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 10))
>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 0))
>U : Symbol(U, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 8))
>J : Symbol(J, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 2, 10))
};
type SubFoo<R, S> = Foo<S, R>;
>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 2))
>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 12))
>S : Symbol(S, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 14))
>Foo : Symbol(Foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 0, 0))
>S : Symbol(S, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 14))
>R : Symbol(R, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 12))
function foo() {
>foo : Symbol(foo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 4, 30))
return {} as SubFoo<number, string>;
>SubFoo : Symbol(SubFoo, Decl(declarationEmitTypeAliasWithTypeParameters6.ts, 3, 2))
}

33
tests/baselines/reference/declarationEmitTypeAliasWithTypeParameters6.types Normal file
View File

@ -0,0 +1,33 @@
=== tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters6.ts ===
type Foo<T, Y> = {
>Foo : Foo<T, Y>
>T : T
>Y : Y
foo<U, J>(): Foo<U, J>
>foo : <U, J>() => Foo<U, J>
>U : U
>J : J
>Foo : Foo<T, Y>
>U : U
>J : J
};
type SubFoo<R, S> = Foo<S, R>;
>SubFoo : Foo<S, R>
>R : R
>S : S
>Foo : Foo<T, Y>
>S : S
>R : R
function foo() {
>foo : () => Foo<number, string>
return {} as SubFoo<number, string>;
>{} as SubFoo<number, string> : Foo<number, string>
>{} : {}
>SubFoo : Foo<S, R>
}

6
tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters2.ts Normal file
View File

@ -0,0 +1,6 @@
// @declaration: true
export type Bar<X, Y, Z> = () => [X, Y, Z];
export type Baz<M, N> = Bar<M, string, N>;
export type Baa<Y> = Baz<boolean, Y>;
export const y = (x: Baa<number>) => 1

8
tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters3.ts Normal file
View File

@ -0,0 +1,8 @@
// @declaration: true
type Foo<T> = {
foo<U>(): Foo<U>
};
function bar() {
return {} as Foo<number>;
}

10
tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters4.ts Normal file
View File

@ -0,0 +1,10 @@
// @declaration: true
type Foo<T, Y> = {
foo<U, J>(): Foo<U, J>
};
type SubFoo<R> = Foo<string, R>;
function foo() {
return {} as SubFoo<number>;
}

10
tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters5.ts Normal file
View File

@ -0,0 +1,10 @@
// @declaration: true
type Foo<T, Y> = {
foo<U, J>(): Foo<U, J>
};
export type SubFoo<R> = Foo<string, R>;
function foo() {
return {} as SubFoo<number>;
}

10
tests/cases/compiler/declarationEmitTypeAliasWithTypeParameters6.ts Normal file
View File

@ -0,0 +1,10 @@
// @declaration: true
type Foo<T, Y> = {
foo<U, J>(): Foo<U, J>
};
type SubFoo<R, S> = Foo<S, R>;
function foo() {
return {} as SubFoo<number, string>;
}