Microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2025-11-18 17:21:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update baselines

Browse Source
This commit is contained in:
Kanchalai Tanglertsampan
2016-09-16 09:25:56 -07:00
parent e8810812e0
commit e60e72ee73
30 changed files with 677 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/baselines/reference/controlFlowBinaryOrExpression.types
+6 -6
View File
@@ -62,21 +62,21 @@ declare function isHTMLCollection(sourceObj: any): sourceObj is HTMLCollection;
>HTMLCollection : HTMLCollection
type EventTargetLike = {a: string} | HTMLCollection | NodeList;
>EventTargetLike : EventTargetLike
>EventTargetLike : NodeList | HTMLCollection | { a: string; }
>a : string
>HTMLCollection : HTMLCollection
>NodeList : NodeList
var sourceObj: EventTargetLike = <any>undefined;
>sourceObj : EventTargetLike
>EventTargetLike : EventTargetLike
>sourceObj : NodeList | HTMLCollection | { a: string; }
>EventTargetLike : NodeList | HTMLCollection | { a: string; }
><any>undefined : any
>undefined : undefined
if (isNodeList(sourceObj)) {
>isNodeList(sourceObj) : boolean
>isNodeList : (sourceObj: any) => sourceObj is NodeList
>sourceObj : EventTargetLike
>sourceObj : NodeList | HTMLCollection | { a: string; }
sourceObj.length;
>sourceObj.length : number
@@ -87,7 +87,7 @@ if (isNodeList(sourceObj)) {
if (isHTMLCollection(sourceObj)) {
>isHTMLCollection(sourceObj) : boolean
>isHTMLCollection : (sourceObj: any) => sourceObj is HTMLCollection
>sourceObj : EventTargetLike
>sourceObj : NodeList | HTMLCollection | { a: string; }
sourceObj.length;
>sourceObj.length : number
@@ -99,7 +99,7 @@ if (isNodeList(sourceObj) || isHTMLCollection(sourceObj)) {
>isNodeList(sourceObj) || isHTMLCollection(sourceObj) : boolean
>isNodeList(sourceObj) : boolean
>isNodeList : (sourceObj: any) => sourceObj is NodeList
>sourceObj : EventTargetLike
>sourceObj : NodeList | HTMLCollection | { a: string; }
>isHTMLCollection(sourceObj) : boolean
>isHTMLCollection : (sourceObj: any) => sourceObj is HTMLCollection
>sourceObj : HTMLCollection | { a: string; }
tests/baselines/reference/declarationEmitInferedTypeAlias1.js
+30
View File
@@ -0,0 +1,30 @@
//// [tests/cases/compiler/declarationEmitInferedTypeAlias1.ts] ////
//// [0.ts]
{
type Data = string | boolean;
let obj: Data = true;
}
export { }
//// [1.ts]
let v = "str" || true;
export { v }
//// [0.js]
"use strict";
{
var obj = true;
}
//// [1.js]
"use strict";
var v = "str" || true;
exports.v = v;
//// [0.d.ts]
export { };
//// [1.d.ts]
declare let v: string | boolean;
export { v };
tests/baselines/reference/declarationEmitInferedTypeAlias1.symbols
+19
View File
@@ -0,0 +1,19 @@
=== tests/cases/compiler/0.ts ===
{
type Data = string | boolean;
>Data : Symbol(Data, Decl(0.ts, 1, 1))
let obj: Data = true;
>obj : Symbol(obj, Decl(0.ts, 3, 7))
>Data : Symbol(Data, Decl(0.ts, 1, 1))
}
export { }
=== tests/cases/compiler/1.ts ===
let v = "str" || true;
>v : Symbol(v, Decl(1.ts, 0, 3))
export { v }
>v : Symbol(v, Decl(1.ts, 1, 8))
tests/baselines/reference/declarationEmitInferedTypeAlias1.types
+23
View File
@@ -0,0 +1,23 @@
=== tests/cases/compiler/0.ts ===
{
type Data = string | boolean;
>Data : string | boolean
let obj: Data = true;
>obj : string | boolean
>Data : string | boolean
>true : true
}
export { }
=== tests/cases/compiler/1.ts ===
let v = "str" || true;
>v : string | boolean
>"str" || true : true | "str"
>"str" : "str"
>true : true
export { v }
>v : string | boolean
tests/baselines/reference/declarationEmitInferedTypeAlias2.js
+38
View File
@@ -0,0 +1,38 @@
//// [tests/cases/compiler/declarationEmitInferedTypeAlias2.ts] ////
//// [0.ts]
{
type Data = string | boolean;
let obj: Data = true;
}
export { }
//// [1.ts]
let v = "str" || true;
function bar () {
return v;
}
export { v, bar }
//// [0.js]
"use strict";
{
var obj = true;
}
//// [1.js]
"use strict";
var v = "str" || true;
exports.v = v;
function bar() {
return v;
}
exports.bar = bar;
//// [0.d.ts]
export { };
//// [1.d.ts]
declare let v: string | boolean;
declare function bar(): string | boolean;
export { v, bar };
tests/baselines/reference/declarationEmitInferedTypeAlias2.symbols
+26
View File
@@ -0,0 +1,26 @@
=== tests/cases/compiler/0.ts ===
{
type Data = string | boolean;
>Data : Symbol(Data, Decl(0.ts, 1, 1))
let obj: Data = true;
>obj : Symbol(obj, Decl(0.ts, 3, 7))
>Data : Symbol(Data, Decl(0.ts, 1, 1))
}
export { }
=== tests/cases/compiler/1.ts ===
let v = "str" || true;
>v : Symbol(v, Decl(1.ts, 0, 3))
function bar () {
>bar : Symbol(bar, Decl(1.ts, 0, 22))
return v;
>v : Symbol(v, Decl(1.ts, 0, 3))
}
export { v, bar }
>v : Symbol(v, Decl(1.ts, 4, 8))
>bar : Symbol(bar, Decl(1.ts, 4, 11))
tests/baselines/reference/declarationEmitInferedTypeAlias2.types
+30
View File
@@ -0,0 +1,30 @@
=== tests/cases/compiler/0.ts ===
{
type Data = string | boolean;
>Data : string | boolean
let obj: Data = true;
>obj : string | boolean
>Data : string | boolean
>true : true
}
export { }
=== tests/cases/compiler/1.ts ===
let v = "str" || true;
>v : string | boolean
>"str" || true : true | "str"
>"str" : "str"
>true : true
function bar () {
>bar : () => string | boolean
return v;
>v : string | boolean
}
export { v, bar }
>v : string | boolean
>bar : () => string | boolean
tests/baselines/reference/declarationEmitInferedTypeAlias3.js
+31
View File
@@ -0,0 +1,31 @@
//// [tests/cases/compiler/declarationEmitInferedTypeAlias3.ts] ////
//// [0.ts]
{
type Data = string | boolean;
let obj: Data = true;
}
export { }
//// [1.ts]
var x = "hi" || 5;
export default x;
//// [0.js]
"use strict";
{
var obj = true;
}
//// [1.js]
"use strict";
var x = "hi" || 5;
exports.__esModule = true;
exports["default"] = x;
//// [0.d.ts]
export { };
//// [1.d.ts]
declare var x: string | number;
export default x;
tests/baselines/reference/declarationEmitInferedTypeAlias3.symbols
+19
View File
@@ -0,0 +1,19 @@
=== tests/cases/compiler/0.ts ===
{
type Data = string | boolean;
>Data : Symbol(Data, Decl(0.ts, 1, 1))
let obj: Data = true;
>obj : Symbol(obj, Decl(0.ts, 3, 7))
>Data : Symbol(Data, Decl(0.ts, 1, 1))
}
export { }
=== tests/cases/compiler/1.ts ===
var x = "hi" || 5;
>x : Symbol(x, Decl(1.ts, 0, 3))
export default x;
>x : Symbol(x, Decl(1.ts, 0, 3))
tests/baselines/reference/declarationEmitInferedTypeAlias3.types
+23
View File
@@ -0,0 +1,23 @@
=== tests/cases/compiler/0.ts ===
{
type Data = string | boolean;
>Data : string | boolean
let obj: Data = true;
>obj : string | boolean
>Data : string | boolean
>true : true
}
export { }
=== tests/cases/compiler/1.ts ===
var x = "hi" || 5;
>x : string | number
>"hi" || 5 : "hi" | 5
>"hi" : "hi"
>5 : 5
export default x;
>x : string | number
tests/baselines/reference/declarationEmitInferedTypeAlias4.js
+19
View File
@@ -0,0 +1,19 @@
//// [declarationEmitInferedTypeAlias4.ts]
function f<A>() {
type Foo<T> = T | { x: Foo<T> };
var x: Foo<A[]>;
return x;
}
//// [declarationEmitInferedTypeAlias4.js]
function f() {
var x;
return x;
}
//// [declarationEmitInferedTypeAlias4.d.ts]
declare function f<A>(): A[] | {
x: A[] | any;
};
tests/baselines/reference/declarationEmitInferedTypeAlias4.symbols
+22
View File
@@ -0,0 +1,22 @@
=== tests/cases/compiler/declarationEmitInferedTypeAlias4.ts ===
function f<A>() {
>f : Symbol(f, Decl(declarationEmitInferedTypeAlias4.ts, 0, 0))
>A : Symbol(A, Decl(declarationEmitInferedTypeAlias4.ts, 1, 11))
type Foo<T> = T | { x: Foo<T> };
>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 1, 17))
>T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 2, 13))
>T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 2, 13))
>x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 2, 23))
>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 1, 17))
>T : Symbol(T, Decl(declarationEmitInferedTypeAlias4.ts, 2, 13))
var x: Foo<A[]>;
>x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 3, 7))
>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias4.ts, 1, 17))
>A : Symbol(A, Decl(declarationEmitInferedTypeAlias4.ts, 1, 11))
return x;
>x : Symbol(x, Decl(declarationEmitInferedTypeAlias4.ts, 3, 7))
}
tests/baselines/reference/declarationEmitInferedTypeAlias4.types
+22
View File
@@ -0,0 +1,22 @@
=== tests/cases/compiler/declarationEmitInferedTypeAlias4.ts ===
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; }
}
tests/baselines/reference/declarationEmitInferedTypeAlias5.js
+29
View File
@@ -0,0 +1,29 @@
//// [tests/cases/compiler/declarationEmitInferedTypeAlias5.ts] ////
//// [0.ts]
export type Data = string | boolean;
let obj: Data = true;
//// [1.ts]
import * as Z from "./0"
//let v2: Z.Data;
let v = "str" || true;
export { v }
//// [0.js]
"use strict";
var obj = true;
//// [1.js]
"use strict";
//let v2: Z.Data;
var v = "str" || true;
exports.v = v;
//// [0.d.ts]
export declare type Data = string | boolean;
//// [1.d.ts]
import * as Z from "./0";
declare let v: Z.Data;
export { v };
tests/baselines/reference/declarationEmitInferedTypeAlias5.symbols
+20
View File
@@ -0,0 +1,20 @@
=== tests/cases/compiler/0.ts ===
export type Data = string | boolean;
>Data : Symbol(Data, Decl(0.ts, 0, 0))
let obj: Data = true;
>obj : Symbol(obj, Decl(0.ts, 2, 3))
>Data : Symbol(Data, Decl(0.ts, 0, 0))
=== tests/cases/compiler/1.ts ===
import * as Z from "./0"
>Z : Symbol(Z, Decl(1.ts, 0, 6))
//let v2: Z.Data;
let v = "str" || true;
>v : Symbol(v, Decl(1.ts, 2, 3))
export { v }
>v : Symbol(v, Decl(1.ts, 3, 8))
tests/baselines/reference/declarationEmitInferedTypeAlias5.types
+24
View File
@@ -0,0 +1,24 @@
=== tests/cases/compiler/0.ts ===
export type Data = string | boolean;
>Data : Data
let obj: Data = true;
>obj : Data
>Data : Data
>true : true
=== tests/cases/compiler/1.ts ===
import * as Z from "./0"
>Z : typeof Z
//let v2: Z.Data;
let v = "str" || true;
>v : Z.Data
>"str" || true : true | "str"
>"str" : "str"
>true : true
export { v }
>v : Z.Data
tests/baselines/reference/declarationEmitInferedTypeAlias6.js
+30
View File
@@ -0,0 +1,30 @@
//// [tests/cases/compiler/declarationEmitInferedTypeAlias6.ts] ////
//// [0.ts]
{
type Data = string | boolean;
let obj: Data = true;
}
export { }
//// [1.ts]
let v = "str" || true;
export { v }
//// [0.js]
"use strict";
{
var obj = true;
}
//// [1.js]
"use strict";
var v = "str" || true;
exports.v = v;
//// [0.d.ts]
export { };
//// [1.d.ts]
declare let v: string | boolean;
export { v };
tests/baselines/reference/declarationEmitInferedTypeAlias6.symbols
+19
View File
@@ -0,0 +1,19 @@
=== tests/cases/compiler/0.ts ===
{
type Data = string | boolean;
>Data : Symbol(Data, Decl(0.ts, 1, 1))
let obj: Data = true;
>obj : Symbol(obj, Decl(0.ts, 3, 7))
>Data : Symbol(Data, Decl(0.ts, 1, 1))
}
export { }
=== tests/cases/compiler/1.ts ===
let v = "str" || true;
>v : Symbol(v, Decl(1.ts, 0, 3))
export { v }
>v : Symbol(v, Decl(1.ts, 1, 8))
tests/baselines/reference/declarationEmitInferedTypeAlias6.types
+23
View File
@@ -0,0 +1,23 @@
=== tests/cases/compiler/0.ts ===
{
type Data = string | boolean;
>Data : string | boolean
let obj: Data = true;
>obj : string | boolean
>Data : string | boolean
>true : true
}
export { }
=== tests/cases/compiler/1.ts ===
let v = "str" || true;
>v : string | boolean
>"str" || true : true | "str"
>"str" : "str"
>true : true
export { v }
>v : string | boolean
tests/baselines/reference/declarationEmitInferedTypeAlias7.js
+25
View File
@@ -0,0 +1,25 @@
//// [tests/cases/compiler/declarationEmitInferedTypeAlias7.ts] ////
//// [0.ts]
export type Data = string | boolean;
let obj: Data = true;
//// [1.ts]
let v = "str" || true;
export { v }
//// [0.js]
"use strict";
var obj = true;
//// [1.js]
"use strict";
var v = "str" || true;
exports.v = v;
//// [0.d.ts]
export declare type Data = string | boolean;
//// [1.d.ts]
declare let v: string | boolean;
export { v };
tests/baselines/reference/declarationEmitInferedTypeAlias7.symbols
+16
View File
@@ -0,0 +1,16 @@
=== tests/cases/compiler/0.ts ===
export type Data = string | boolean;
>Data : Symbol(Data, Decl(0.ts, 0, 0))
let obj: Data = true;
>obj : Symbol(obj, Decl(0.ts, 2, 3))
>Data : Symbol(Data, Decl(0.ts, 0, 0))
=== tests/cases/compiler/1.ts ===
let v = "str" || true;
>v : Symbol(v, Decl(1.ts, 0, 3))
export { v }
>v : Symbol(v, Decl(1.ts, 1, 8))
tests/baselines/reference/declarationEmitInferedTypeAlias7.types
+20
View File
@@ -0,0 +1,20 @@
=== tests/cases/compiler/0.ts ===
export type Data = string | boolean;
>Data : Data
let obj: Data = true;
>obj : Data
>Data : Data
>true : true
=== tests/cases/compiler/1.ts ===
let v = "str" || true;
>v : string | boolean
>"str" || true : true | "str"
>"str" : "str"
>true : true
export { v }
>v : string | boolean
tests/baselines/reference/declarationEmitInferedTypeAlias8.js
+22
View File
@@ -0,0 +1,22 @@
//// [declarationEmitInferedTypeAlias8.ts]
type Foo<T> = T | { x: Foo<T> };
var x: Foo<number[]>;
function returnSomeGlobalValue() {
return x;
}
//// [declarationEmitInferedTypeAlias8.js]
var x;
function returnSomeGlobalValue() {
return x;
}
//// [declarationEmitInferedTypeAlias8.d.ts]
declare type Foo<T> = T | {
x: Foo<T>;
};
declare var x: Foo<number[]>;
declare function returnSomeGlobalValue(): Foo<number[]>;
tests/baselines/reference/declarationEmitInferedTypeAlias8.symbols
+20
View File
@@ -0,0 +1,20 @@
=== tests/cases/compiler/declarationEmitInferedTypeAlias8.ts ===
type Foo<T> = T | { x: Foo<T> };
>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0))
>T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 1, 9))
>T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 1, 9))
>x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 1, 19))
>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0))
>T : Symbol(T, Decl(declarationEmitInferedTypeAlias8.ts, 1, 9))
var x: Foo<number[]>;
>x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 2, 3))
>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias8.ts, 0, 0))
function returnSomeGlobalValue() {
>returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferedTypeAlias8.ts, 2, 21))
return x;
>x : Symbol(x, Decl(declarationEmitInferedTypeAlias8.ts, 2, 3))
}
tests/baselines/reference/declarationEmitInferedTypeAlias8.types
+20
View File
@@ -0,0 +1,20 @@
=== tests/cases/compiler/declarationEmitInferedTypeAlias8.ts ===
type Foo<T> = T | { x: Foo<T> };
>Foo : Foo<T>
>T : T
>T : T
>x : Foo<T>
>Foo : Foo<T>
>T : T
var x: Foo<number[]>;
>x : Foo<number[]>
>Foo : Foo<T>
function returnSomeGlobalValue() {
>returnSomeGlobalValue : () => Foo<number[]>
return x;
>x : Foo<number[]>
}
tests/baselines/reference/declarationEmitInferedTypeAlias9.js
+22
View File
@@ -0,0 +1,22 @@
//// [declarationEmitInferedTypeAlias9.ts]
type Foo<T> = T | { x: Foo<T> };
var x: Foo<number[]>;
export function returnSomeGlobalValue() {
return x;
}
//// [declarationEmitInferedTypeAlias9.js]
"use strict";
var x;
function returnSomeGlobalValue() {
return x;
}
exports.returnSomeGlobalValue = returnSomeGlobalValue;
//// [declarationEmitInferedTypeAlias9.d.ts]
export declare function returnSomeGlobalValue(): number[] | {
x: number[] | any;
};
tests/baselines/reference/declarationEmitInferedTypeAlias9.symbols
+20
View File
@@ -0,0 +1,20 @@
=== tests/cases/compiler/declarationEmitInferedTypeAlias9.ts ===
type Foo<T> = T | { x: Foo<T> };
>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0))
>T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 1, 9))
>T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 1, 9))
>x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 1, 19))
>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0))
>T : Symbol(T, Decl(declarationEmitInferedTypeAlias9.ts, 1, 9))
var x: Foo<number[]>;
>x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 2, 3))
>Foo : Symbol(Foo, Decl(declarationEmitInferedTypeAlias9.ts, 0, 0))
export function returnSomeGlobalValue() {
>returnSomeGlobalValue : Symbol(returnSomeGlobalValue, Decl(declarationEmitInferedTypeAlias9.ts, 2, 21))
return x;
>x : Symbol(x, Decl(declarationEmitInferedTypeAlias9.ts, 2, 3))
}
tests/baselines/reference/declarationEmitInferedTypeAlias9.types
+20
View File
@@ -0,0 +1,20 @@
=== tests/cases/compiler/declarationEmitInferedTypeAlias9.ts ===
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<number[]>;
>x : number[] | { x: number[] | any; }
>Foo : T | { x: T | any; }
export function returnSomeGlobalValue() {
>returnSomeGlobalValue : () => number[] | { x: number[] | any; }
return x;
>x : number[] | { x: number[] | any; }
}
tests/baselines/reference/genericTypeAliases.types
+23 -23
View File
@@ -215,60 +215,60 @@ p.tag = "test";
>"test" : "test"
function f<A>() {
>f : <A>() => Foo<A[]>
>f : <A>() => A[] | { x: A[] | any; }
>A : A
type Foo<T> = T | { x: Foo<T> };
>Foo : Foo<T>
>Foo : T | { x: T | any; }
>T : T
>T : T
>x : Foo<T>
>Foo : Foo<T>
>x : T | { x: T | any; }
>Foo : T | { x: T | any; }
>T : T
var x: Foo<A[]>;
>x : Foo<A[]>
>Foo : Foo<T>
>x : A[] | { x: A[] | any; }
>Foo : T | { x: T | any; }
>A : A
return x;
>x : Foo<A[]>
>x : A[] | { x: A[] | any; }
}
function g<B>() {
>g : <B>() => Bar<B[]>
>g : <B>() => B[] | { x: B[] | any; }
>B : B
type Bar<U> = U | { x: Bar<U> };
>Bar : Bar<U>
>Bar : U | { x: U | any; }
>U : U
>U : U
>x : Bar<U>
>Bar : Bar<U>
>x : U | { x: U | any; }
>Bar : U | { x: U | any; }
>U : U
var x: Bar<B[]>;
>x : Bar<B[]>
>Bar : Bar<U>
>x : B[] | { x: B[] | any; }
>Bar : U | { x: U | any; }
>B : B
return x;
>x : Bar<B[]>
>x : B[] | { x: B[] | any; }
}
// Deeply instantiated generics
var a = f<string>();
>a : Foo<string>
>f<string>() : Foo<string>
>f : <A>() => Foo<A[]>
>a : string[] | { x: string[] | any; }
>f<string>() : string[] | { x: string[] | any; }
>f : <A>() => A[] | { x: A[] | any; }
var b = g<string>();
>b : Bar<string>
>g<string>() : Bar<string>
>g : <B>() => Bar<B[]>
>b : string[] | { x: string[] | any; }
>g<string>() : string[] | { x: string[] | any; }
>g : <B>() => B[] | { x: B[] | any; }
a = b;
>a = b : Bar<string>
>a : Foo<string>
>b : Bar<string>
>a = b : string[] | { x: string[] | any; }
>a : string[] | { x: string[] | any; }
>b : string[] | { x: string[] | any; }
tests/baselines/reference/unusedLocalsAndParametersTypeAliases.types
+16 -16
View File
@@ -2,14 +2,14 @@
// used in a declaration
type handler1 = () => void;
>handler1 : handler1
>handler1 : () => void
export interface I1 {
>I1 : I1
getHandler: handler1;
>getHandler : handler1
>handler1 : handler1
>getHandler : () => void
>handler1 : () => void
}
// exported
@@ -18,12 +18,12 @@ export type handler2 = () => void;
// used in extends clause
type handler3 = () => void;
>handler3 : handler3
>handler3 : () => void
export interface I3<T extends handler3> {
>I3 : I3<T>
>T : T
>handler3 : handler3
>handler3 : () => void
getHandler: T;
>getHandler : T
@@ -32,32 +32,32 @@ export interface I3<T extends handler3> {
// used in another type alias declaration
type handler4 = () => void;
>handler4 : handler4
>handler4 : () => void
type handler5 = handler4 | (()=>number);
>handler5 : handler5
>handler4 : handler4
>handler5 : (() => void) | (() => number)
>handler4 : () => void
var x: handler5;
>x : handler5
>handler5 : handler5
>x : (() => void) | (() => number)
>handler5 : (() => void) | (() => number)
x();
>x() : number | void
>x : handler5
>x : (() => void) | (() => number)
// used as type argument
type handler6 = () => void;
>handler6 : handler6
>handler6 : () => void
var y: Array<handler6>;
>y : handler6[]
>y : (() => void)[]
>Array : T[]
>handler6 : handler6
>handler6 : () => void
y[0]();
>y[0]() : void
>y[0] : handler6
>y : handler6[]
>y[0] : () => void
>y : (() => void)[]
>0 : 0