Adding simple tests
This commit is contained in:
Anders Hejlsberg
parent
eb8a0e8d56
commit
bcdbc98dac
120
tests/baselines/reference/genericTypeAliases.js
Normal file
120
tests/baselines/reference/genericTypeAliases.js
Normal file
|
|
@ -0,0 +1,120 @@
|
|||
//// [genericTypeAliases.ts]
|
||||
type Tree<T> = T | { left: Tree<T>, right: Tree<T> };
|
||||
|
||||
var tree: Tree<number> = {
|
||||
left: {
|
||||
left: 0,
|
||||
right: {
|
||||
left: 1,
|
||||
right: 2
|
||||
},
|
||||
},
|
||||
right: 3
|
||||
};
|
||||
|
||||
type Lazy<T> = T | (() => T);
|
||||
|
||||
var ls: Lazy<string>;
|
||||
ls = "eager";
|
||||
ls = () => "lazy";
|
||||
|
||||
type Foo<T> = T | { x: Foo<T> };
|
||||
type Bar<U> = U | { x: Bar<U> };
|
||||
|
||||
// Deeply instantiated generics
|
||||
var x: Foo<string>;
|
||||
var y: Bar<string>;
|
||||
x = y;
|
||||
y = x;
|
||||
|
||||
x = "string";
|
||||
x = { x: "hello" };
|
||||
x = { x: { x: "world" } };
|
||||
|
||||
var z: Foo<number>;
|
||||
z = 42;
|
||||
z = { x: 42 };
|
||||
z = { x: { x: 42 } };
|
||||
|
||||
type Strange<T> = string; // Type parameter not used
|
||||
var s: Strange<number>;
|
||||
s = "hello";
|
||||
|
||||
interface Tuple<A, B> {
|
||||
a: A;
|
||||
b: B;
|
||||
}
|
||||
|
||||
type Pair<T> = Tuple<T, T>;
|
||||
|
||||
interface TaggedPair<T> extends Pair<T> {
|
||||
tag: string;
|
||||
}
|
||||
|
||||
var p: TaggedPair<number>;
|
||||
p.a = 1;
|
||||
p.b = 2;
|
||||
p.tag = "test";
|
||||
|
||||
function f<A>() {
|
||||
type Foo<T> = T | { x: Foo<T> };
|
||||
var x: Foo<A[]>;
|
||||
return x;
|
||||
}
|
||||
|
||||
function g<B>() {
|
||||
type Bar<U> = U | { x: Bar<U> };
|
||||
var x: Bar<B[]>;
|
||||
return x;
|
||||
}
|
||||
|
||||
// Deeply instantiated generics
|
||||
var a = f<string>();
|
||||
var b = g<string>();
|
||||
a = b;
|
||||
|
||||
|
||||
//// [genericTypeAliases.js]
|
||||
var tree = {
|
||||
left: {
|
||||
left: 0,
|
||||
right: {
|
||||
left: 1,
|
||||
right: 2
|
||||
}
|
||||
},
|
||||
right: 3
|
||||
};
|
||||
var ls;
|
||||
ls = "eager";
|
||||
ls = function () { return "lazy"; };
|
||||
// Deeply instantiated generics
|
||||
var x;
|
||||
var y;
|
||||
x = y;
|
||||
y = x;
|
||||
x = "string";
|
||||
x = { x: "hello" };
|
||||
x = { x: { x: "world" } };
|
||||
var z;
|
||||
z = 42;
|
||||
z = { x: 42 };
|
||||
z = { x: { x: 42 } };
|
||||
var s;
|
||||
s = "hello";
|
||||
var p;
|
||||
p.a = 1;
|
||||
p.b = 2;
|
||||
p.tag = "test";
|
||||
function f() {
|
||||
var x;
|
||||
return x;
|
||||
}
|
||||
function g() {
|
||||
var x;
|
||||
return x;
|
||||
}
|
||||
// Deeply instantiated generics
|
||||
var a = f();
|
||||
var b = g();
|
||||
a = b;
|
||||
231
tests/baselines/reference/genericTypeAliases.symbols
Normal file
231
tests/baselines/reference/genericTypeAliases.symbols
Normal file
|
|
@ -0,0 +1,231 @@
|
|||
=== tests/cases/conformance/types/typeAliases/genericTypeAliases.ts ===
|
||||
type Tree<T> = T | { left: Tree<T>, right: Tree<T> };
|
||||
>Tree : Symbol(Tree, Decl(genericTypeAliases.ts, 0, 0))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 0, 10))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 0, 10))
|
||||
>left : Symbol(left, Decl(genericTypeAliases.ts, 0, 20))
|
||||
>Tree : Symbol(Tree, Decl(genericTypeAliases.ts, 0, 0))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 0, 10))
|
||||
>right : Symbol(right, Decl(genericTypeAliases.ts, 0, 35))
|
||||
>Tree : Symbol(Tree, Decl(genericTypeAliases.ts, 0, 0))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 0, 10))
|
||||
|
||||
var tree: Tree<number> = {
|
||||
>tree : Symbol(tree, Decl(genericTypeAliases.ts, 2, 3))
|
||||
>Tree : Symbol(Tree, Decl(genericTypeAliases.ts, 0, 0))
|
||||
|
||||
left: {
|
||||
>left : Symbol(left, Decl(genericTypeAliases.ts, 2, 26))
|
||||
|
||||
left: 0,
|
||||
>left : Symbol(left, Decl(genericTypeAliases.ts, 3, 11))
|
||||
|
||||
right: {
|
||||
>right : Symbol(right, Decl(genericTypeAliases.ts, 4, 16))
|
||||
|
||||
left: 1,
|
||||
>left : Symbol(left, Decl(genericTypeAliases.ts, 5, 16))
|
||||
|
||||
right: 2
|
||||
>right : Symbol(right, Decl(genericTypeAliases.ts, 6, 20))
|
||||
|
||||
},
|
||||
},
|
||||
right: 3
|
||||
>right : Symbol(right, Decl(genericTypeAliases.ts, 9, 6))
|
||||
|
||||
};
|
||||
|
||||
type Lazy<T> = T | (() => T);
|
||||
>Lazy : Symbol(Lazy, Decl(genericTypeAliases.ts, 11, 2))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 13, 10))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 13, 10))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 13, 10))
|
||||
|
||||
var ls: Lazy<string>;
|
||||
>ls : Symbol(ls, Decl(genericTypeAliases.ts, 15, 3))
|
||||
>Lazy : Symbol(Lazy, Decl(genericTypeAliases.ts, 11, 2))
|
||||
|
||||
ls = "eager";
|
||||
>ls : Symbol(ls, Decl(genericTypeAliases.ts, 15, 3))
|
||||
|
||||
ls = () => "lazy";
|
||||
>ls : Symbol(ls, Decl(genericTypeAliases.ts, 15, 3))
|
||||
|
||||
type Foo<T> = T | { x: Foo<T> };
|
||||
>Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 17, 18))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 19, 9))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 19, 9))
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 19, 19))
|
||||
>Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 17, 18))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 19, 9))
|
||||
|
||||
type Bar<U> = U | { x: Bar<U> };
|
||||
>Bar : Symbol(Bar, Decl(genericTypeAliases.ts, 19, 32))
|
||||
>U : Symbol(U, Decl(genericTypeAliases.ts, 20, 9))
|
||||
>U : Symbol(U, Decl(genericTypeAliases.ts, 20, 9))
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 20, 19))
|
||||
>Bar : Symbol(Bar, Decl(genericTypeAliases.ts, 19, 32))
|
||||
>U : Symbol(U, Decl(genericTypeAliases.ts, 20, 9))
|
||||
|
||||
// Deeply instantiated generics
|
||||
var x: Foo<string>;
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
|
||||
>Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 17, 18))
|
||||
|
||||
var y: Bar<string>;
|
||||
>y : Symbol(y, Decl(genericTypeAliases.ts, 24, 3))
|
||||
>Bar : Symbol(Bar, Decl(genericTypeAliases.ts, 19, 32))
|
||||
|
||||
x = y;
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
|
||||
>y : Symbol(y, Decl(genericTypeAliases.ts, 24, 3))
|
||||
|
||||
y = x;
|
||||
>y : Symbol(y, Decl(genericTypeAliases.ts, 24, 3))
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
|
||||
|
||||
x = "string";
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
|
||||
|
||||
x = { x: "hello" };
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 29, 5))
|
||||
|
||||
x = { x: { x: "world" } };
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 23, 3))
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 30, 5))
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 30, 10))
|
||||
|
||||
var z: Foo<number>;
|
||||
>z : Symbol(z, Decl(genericTypeAliases.ts, 32, 3))
|
||||
>Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 17, 18))
|
||||
|
||||
z = 42;
|
||||
>z : Symbol(z, Decl(genericTypeAliases.ts, 32, 3))
|
||||
|
||||
z = { x: 42 };
|
||||
>z : Symbol(z, Decl(genericTypeAliases.ts, 32, 3))
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 34, 5))
|
||||
|
||||
z = { x: { x: 42 } };
|
||||
>z : Symbol(z, Decl(genericTypeAliases.ts, 32, 3))
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 35, 5))
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 35, 10))
|
||||
|
||||
type Strange<T> = string; // Type parameter not used
|
||||
>Strange : Symbol(Strange, Decl(genericTypeAliases.ts, 35, 21))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 37, 13))
|
||||
|
||||
var s: Strange<number>;
|
||||
>s : Symbol(s, Decl(genericTypeAliases.ts, 38, 3))
|
||||
>Strange : Symbol(Strange, Decl(genericTypeAliases.ts, 35, 21))
|
||||
|
||||
s = "hello";
|
||||
>s : Symbol(s, Decl(genericTypeAliases.ts, 38, 3))
|
||||
|
||||
interface Tuple<A, B> {
|
||||
>Tuple : Symbol(Tuple, Decl(genericTypeAliases.ts, 39, 12))
|
||||
>A : Symbol(A, Decl(genericTypeAliases.ts, 41, 16))
|
||||
>B : Symbol(B, Decl(genericTypeAliases.ts, 41, 18))
|
||||
|
||||
a: A;
|
||||
>a : Symbol(a, Decl(genericTypeAliases.ts, 41, 23))
|
||||
>A : Symbol(A, Decl(genericTypeAliases.ts, 41, 16))
|
||||
|
||||
b: B;
|
||||
>b : Symbol(b, Decl(genericTypeAliases.ts, 42, 9))
|
||||
>B : Symbol(B, Decl(genericTypeAliases.ts, 41, 18))
|
||||
}
|
||||
|
||||
type Pair<T> = Tuple<T, T>;
|
||||
>Pair : Symbol(Pair, Decl(genericTypeAliases.ts, 44, 1))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 46, 10))
|
||||
>Tuple : Symbol(Tuple, Decl(genericTypeAliases.ts, 39, 12))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 46, 10))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 46, 10))
|
||||
|
||||
interface TaggedPair<T> extends Pair<T> {
|
||||
>TaggedPair : Symbol(TaggedPair, Decl(genericTypeAliases.ts, 46, 27))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 48, 21))
|
||||
>Pair : Symbol(Pair, Decl(genericTypeAliases.ts, 44, 1))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 48, 21))
|
||||
|
||||
tag: string;
|
||||
>tag : Symbol(tag, Decl(genericTypeAliases.ts, 48, 41))
|
||||
}
|
||||
|
||||
var p: TaggedPair<number>;
|
||||
>p : Symbol(p, Decl(genericTypeAliases.ts, 52, 3))
|
||||
>TaggedPair : Symbol(TaggedPair, Decl(genericTypeAliases.ts, 46, 27))
|
||||
|
||||
p.a = 1;
|
||||
>p.a : Symbol(Tuple.a, Decl(genericTypeAliases.ts, 41, 23))
|
||||
>p : Symbol(p, Decl(genericTypeAliases.ts, 52, 3))
|
||||
>a : Symbol(Tuple.a, Decl(genericTypeAliases.ts, 41, 23))
|
||||
|
||||
p.b = 2;
|
||||
>p.b : Symbol(Tuple.b, Decl(genericTypeAliases.ts, 42, 9))
|
||||
>p : Symbol(p, Decl(genericTypeAliases.ts, 52, 3))
|
||||
>b : Symbol(Tuple.b, Decl(genericTypeAliases.ts, 42, 9))
|
||||
|
||||
p.tag = "test";
|
||||
>p.tag : Symbol(TaggedPair.tag, Decl(genericTypeAliases.ts, 48, 41))
|
||||
>p : Symbol(p, Decl(genericTypeAliases.ts, 52, 3))
|
||||
>tag : Symbol(TaggedPair.tag, Decl(genericTypeAliases.ts, 48, 41))
|
||||
|
||||
function f<A>() {
|
||||
>f : Symbol(f, Decl(genericTypeAliases.ts, 55, 15))
|
||||
>A : Symbol(A, Decl(genericTypeAliases.ts, 57, 11))
|
||||
|
||||
type Foo<T> = T | { x: Foo<T> };
|
||||
>Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 57, 17))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 58, 13))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 58, 13))
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 58, 23))
|
||||
>Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 57, 17))
|
||||
>T : Symbol(T, Decl(genericTypeAliases.ts, 58, 13))
|
||||
|
||||
var x: Foo<A[]>;
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 59, 7))
|
||||
>Foo : Symbol(Foo, Decl(genericTypeAliases.ts, 57, 17))
|
||||
>A : Symbol(A, Decl(genericTypeAliases.ts, 57, 11))
|
||||
|
||||
return x;
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 59, 7))
|
||||
}
|
||||
|
||||
function g<B>() {
|
||||
>g : Symbol(g, Decl(genericTypeAliases.ts, 61, 1))
|
||||
>B : Symbol(B, Decl(genericTypeAliases.ts, 63, 11))
|
||||
|
||||
type Bar<U> = U | { x: Bar<U> };
|
||||
>Bar : Symbol(Bar, Decl(genericTypeAliases.ts, 63, 17))
|
||||
>U : Symbol(U, Decl(genericTypeAliases.ts, 64, 13))
|
||||
>U : Symbol(U, Decl(genericTypeAliases.ts, 64, 13))
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 64, 23))
|
||||
>Bar : Symbol(Bar, Decl(genericTypeAliases.ts, 63, 17))
|
||||
>U : Symbol(U, Decl(genericTypeAliases.ts, 64, 13))
|
||||
|
||||
var x: Bar<B[]>;
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 65, 7))
|
||||
>Bar : Symbol(Bar, Decl(genericTypeAliases.ts, 63, 17))
|
||||
>B : Symbol(B, Decl(genericTypeAliases.ts, 63, 11))
|
||||
|
||||
return x;
|
||||
>x : Symbol(x, Decl(genericTypeAliases.ts, 65, 7))
|
||||
}
|
||||
|
||||
// Deeply instantiated generics
|
||||
var a = f<string>();
|
||||
>a : Symbol(a, Decl(genericTypeAliases.ts, 70, 3))
|
||||
>f : Symbol(f, Decl(genericTypeAliases.ts, 55, 15))
|
||||
|
||||
var b = g<string>();
|
||||
>b : Symbol(b, Decl(genericTypeAliases.ts, 71, 3))
|
||||
>g : Symbol(g, Decl(genericTypeAliases.ts, 61, 1))
|
||||
|
||||
a = b;
|
||||
>a : Symbol(a, Decl(genericTypeAliases.ts, 70, 3))
|
||||
>b : Symbol(b, Decl(genericTypeAliases.ts, 71, 3))
|
||||
|
||||
274
tests/baselines/reference/genericTypeAliases.types
Normal file
274
tests/baselines/reference/genericTypeAliases.types
Normal file
|
|
@ -0,0 +1,274 @@
|
|||
=== tests/cases/conformance/types/typeAliases/genericTypeAliases.ts ===
|
||||
type Tree<T> = T | { left: Tree<T>, right: Tree<T> };
|
||||
>Tree : T | { left: T | any; right: T | any; }
|
||||
>T : T
|
||||
>T : T
|
||||
>left : T | { left: T | any; right: T | any; }
|
||||
>Tree : T | { left: T | any; right: T | any; }
|
||||
>T : T
|
||||
>right : T | { left: T | any; right: T | any; }
|
||||
>Tree : T | { left: T | any; right: T | any; }
|
||||
>T : T
|
||||
|
||||
var tree: Tree<number> = {
|
||||
>tree : number | { left: number | any; right: number | any; }
|
||||
>Tree : T | { left: T | any; right: T | any; }
|
||||
>{ left: { left: 0, right: { left: 1, right: 2 }, }, right: 3} : { left: { left: number; right: { left: number; right: number; }; }; right: number; }
|
||||
|
||||
left: {
|
||||
>left : { left: number; right: { left: number; right: number; }; }
|
||||
>{ left: 0, right: { left: 1, right: 2 }, } : { left: number; right: { left: number; right: number; }; }
|
||||
|
||||
left: 0,
|
||||
>left : number
|
||||
>0 : number
|
||||
|
||||
right: {
|
||||
>right : { left: number; right: number; }
|
||||
>{ left: 1, right: 2 } : { left: number; right: number; }
|
||||
|
||||
left: 1,
|
||||
>left : number
|
||||
>1 : number
|
||||
|
||||
right: 2
|
||||
>right : number
|
||||
>2 : number
|
||||
|
||||
},
|
||||
},
|
||||
right: 3
|
||||
>right : number
|
||||
>3 : number
|
||||
|
||||
};
|
||||
|
||||
type Lazy<T> = T | (() => T);
|
||||
>Lazy : T | (() => T)
|
||||
>T : T
|
||||
>T : T
|
||||
>T : T
|
||||
|
||||
var ls: Lazy<string>;
|
||||
>ls : string | (() => string)
|
||||
>Lazy : T | (() => T)
|
||||
|
||||
ls = "eager";
|
||||
>ls = "eager" : string
|
||||
>ls : string | (() => string)
|
||||
>"eager" : string
|
||||
|
||||
ls = () => "lazy";
|
||||
>ls = () => "lazy" : () => string
|
||||
>ls : string | (() => string)
|
||||
>() => "lazy" : () => string
|
||||
>"lazy" : string
|
||||
|
||||
type Foo<T> = T | { x: Foo<T> };
|
||||
>Foo : T | { x: T | any; }
|
||||
>T : T
|
||||
>T : T
|
||||
>x : T | { x: T | any; }
|
||||
>Foo : T | { x: T | any; }
|
||||
>T : T
|
||||
|
||||
type Bar<U> = U | { x: Bar<U> };
|
||||
>Bar : U | { x: U | any; }
|
||||
>U : U
|
||||
>U : U
|
||||
>x : U | { x: U | any; }
|
||||
>Bar : U | { x: U | any; }
|
||||
>U : U
|
||||
|
||||
// Deeply instantiated generics
|
||||
var x: Foo<string>;
|
||||
>x : string | { x: string | any; }
|
||||
>Foo : T | { x: T | any; }
|
||||
|
||||
var y: Bar<string>;
|
||||
>y : string | { x: string | any; }
|
||||
>Bar : U | { x: U | any; }
|
||||
|
||||
x = y;
|
||||
>x = y : string | { x: string | any; }
|
||||
>x : string | { x: string | any; }
|
||||
>y : string | { x: string | any; }
|
||||
|
||||
y = x;
|
||||
>y = x : string | { x: string | any; }
|
||||
>y : string | { x: string | any; }
|
||||
>x : string | { x: string | any; }
|
||||
|
||||
x = "string";
|
||||
>x = "string" : string
|
||||
>x : string | { x: string | any; }
|
||||
>"string" : string
|
||||
|
||||
x = { x: "hello" };
|
||||
>x = { x: "hello" } : { x: string; }
|
||||
>x : string | { x: string | any; }
|
||||
>{ x: "hello" } : { x: string; }
|
||||
>x : string
|
||||
>"hello" : string
|
||||
|
||||
x = { x: { x: "world" } };
|
||||
>x = { x: { x: "world" } } : { x: { x: string; }; }
|
||||
>x : string | { x: string | any; }
|
||||
>{ x: { x: "world" } } : { x: { x: string; }; }
|
||||
>x : { x: string; }
|
||||
>{ x: "world" } : { x: string; }
|
||||
>x : string
|
||||
>"world" : string
|
||||
|
||||
var z: Foo<number>;
|
||||
>z : number | { x: number | any; }
|
||||
>Foo : T | { x: T | any; }
|
||||
|
||||
z = 42;
|
||||
>z = 42 : number
|
||||
>z : number | { x: number | any; }
|
||||
>42 : number
|
||||
|
||||
z = { x: 42 };
|
||||
>z = { x: 42 } : { x: number; }
|
||||
>z : number | { x: number | any; }
|
||||
>{ x: 42 } : { x: number; }
|
||||
>x : number
|
||||
>42 : number
|
||||
|
||||
z = { x: { x: 42 } };
|
||||
>z = { x: { x: 42 } } : { x: { x: number; }; }
|
||||
>z : number | { x: number | any; }
|
||||
>{ x: { x: 42 } } : { x: { x: number; }; }
|
||||
>x : { x: number; }
|
||||
>{ x: 42 } : { x: number; }
|
||||
>x : number
|
||||
>42 : number
|
||||
|
||||
type Strange<T> = string; // Type parameter not used
|
||||
>Strange : string
|
||||
>T : T
|
||||
|
||||
var s: Strange<number>;
|
||||
>s : string
|
||||
>Strange : string
|
||||
|
||||
s = "hello";
|
||||
>s = "hello" : string
|
||||
>s : string
|
||||
>"hello" : string
|
||||
|
||||
interface Tuple<A, B> {
|
||||
>Tuple : Tuple<A, B>
|
||||
>A : A
|
||||
>B : B
|
||||
|
||||
a: A;
|
||||
>a : A
|
||||
>A : A
|
||||
|
||||
b: B;
|
||||
>b : B
|
||||
>B : B
|
||||
}
|
||||
|
||||
type Pair<T> = Tuple<T, T>;
|
||||
>Pair : Tuple<T, T>
|
||||
>T : T
|
||||
>Tuple : Tuple<A, B>
|
||||
>T : T
|
||||
>T : T
|
||||
|
||||
interface TaggedPair<T> extends Pair<T> {
|
||||
>TaggedPair : TaggedPair<T>
|
||||
>T : T
|
||||
>Pair : Tuple<T, T>
|
||||
>T : T
|
||||
|
||||
tag: string;
|
||||
>tag : string
|
||||
}
|
||||
|
||||
var p: TaggedPair<number>;
|
||||
>p : TaggedPair<number>
|
||||
>TaggedPair : TaggedPair<T>
|
||||
|
||||
p.a = 1;
|
||||
>p.a = 1 : number
|
||||
>p.a : number
|
||||
>p : TaggedPair<number>
|
||||
>a : number
|
||||
>1 : number
|
||||
|
||||
p.b = 2;
|
||||
>p.b = 2 : number
|
||||
>p.b : number
|
||||
>p : TaggedPair<number>
|
||||
>b : number
|
||||
>2 : number
|
||||
|
||||
p.tag = "test";
|
||||
>p.tag = "test" : string
|
||||
>p.tag : string
|
||||
>p : TaggedPair<number>
|
||||
>tag : string
|
||||
>"test" : string
|
||||
|
||||
function f<A>() {
|
||||
>f : <A>() => A[] | { x: A[] | any; }
|
||||
>A : A
|
||||
|
||||
type Foo<T> = T | { x: Foo<T> };
|
||||
>Foo : T | { x: T | any; }
|
||||
>T : T
|
||||
>T : T
|
||||
>x : T | { x: T | any; }
|
||||
>Foo : T | { x: T | any; }
|
||||
>T : T
|
||||
|
||||
var x: Foo<A[]>;
|
||||
>x : A[] | { x: A[] | any; }
|
||||
>Foo : T | { x: T | any; }
|
||||
>A : A
|
||||
|
||||
return x;
|
||||
>x : A[] | { x: A[] | any; }
|
||||
}
|
||||
|
||||
function g<B>() {
|
||||
>g : <B>() => B[] | { x: B[] | any; }
|
||||
>B : B
|
||||
|
||||
type Bar<U> = U | { x: Bar<U> };
|
||||
>Bar : U | { x: U | any; }
|
||||
>U : U
|
||||
>U : U
|
||||
>x : U | { x: U | any; }
|
||||
>Bar : U | { x: U | any; }
|
||||
>U : U
|
||||
|
||||
var x: Bar<B[]>;
|
||||
>x : B[] | { x: B[] | any; }
|
||||
>Bar : U | { x: U | any; }
|
||||
>B : B
|
||||
|
||||
return x;
|
||||
>x : B[] | { x: B[] | any; }
|
||||
}
|
||||
|
||||
// Deeply instantiated generics
|
||||
var a = f<string>();
|
||||
>a : string[] | { x: string[] | any; }
|
||||
>f<string>() : string[] | { x: string[] | any; }
|
||||
>f : <A>() => A[] | { x: A[] | any; }
|
||||
|
||||
var b = g<string>();
|
||||
>b : string[] | { x: string[] | any; }
|
||||
>g<string>() : string[] | { x: string[] | any; }
|
||||
>g : <B>() => B[] | { x: B[] | any; }
|
||||
|
||||
a = b;
|
||||
>a = b : string[] | { x: string[] | any; }
|
||||
>a : string[] | { x: string[] | any; }
|
||||
>b : string[] | { x: string[] | any; }
|
||||
|
||||
|
|
@ -0,0 +1,73 @@
|
|||
type Tree<T> = T | { left: Tree<T>, right: Tree<T> };
|
||||
|
||||
var tree: Tree<number> = {
|
||||
left: {
|
||||
left: 0,
|
||||
right: {
|
||||
left: 1,
|
||||
right: 2
|
||||
},
|
||||
},
|
||||
right: 3
|
||||
};
|
||||
|
||||
type Lazy<T> = T | (() => T);
|
||||
|
||||
var ls: Lazy<string>;
|
||||
ls = "eager";
|
||||
ls = () => "lazy";
|
||||
|
||||
type Foo<T> = T | { x: Foo<T> };
|
||||
type Bar<U> = U | { x: Bar<U> };
|
||||
|
||||
// Deeply instantiated generics
|
||||
var x: Foo<string>;
|
||||
var y: Bar<string>;
|
||||
x = y;
|
||||
y = x;
|
||||
|
||||
x = "string";
|
||||
x = { x: "hello" };
|
||||
x = { x: { x: "world" } };
|
||||
|
||||
var z: Foo<number>;
|
||||
z = 42;
|
||||
z = { x: 42 };
|
||||
z = { x: { x: 42 } };
|
||||
|
||||
type Strange<T> = string; // Type parameter not used
|
||||
var s: Strange<number>;
|
||||
s = "hello";
|
||||
|
||||
interface Tuple<A, B> {
|
||||
a: A;
|
||||
b: B;
|
||||
}
|
||||
|
||||
type Pair<T> = Tuple<T, T>;
|
||||
|
||||
interface TaggedPair<T> extends Pair<T> {
|
||||
tag: string;
|
||||
}
|
||||
|
||||
var p: TaggedPair<number>;
|
||||
p.a = 1;
|
||||
p.b = 2;
|
||||
p.tag = "test";
|
||||
|
||||
function f<A>() {
|
||||
type Foo<T> = T | { x: Foo<T> };
|
||||
var x: Foo<A[]>;
|
||||
return x;
|
||||
}
|
||||
|
||||
function g<B>() {
|
||||
type Bar<U> = U | { x: Bar<U> };
|
||||
var x: Bar<B[]>;
|
||||
return x;
|
||||
}
|
||||
|
||||
// Deeply instantiated generics
|
||||
var a = f<string>();
|
||||
var b = g<string>();
|
||||
a = b;
|
||||
Loading…
Reference in a new issue