1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
=== tests/cases/compiler/funcdecl.ts ===
function simpleFunc() {
>simpleFunc : () => string
return "this is my simple func";
>"this is my simple func" : "this is my simple func"
}
var simpleFuncVar = simpleFunc;
>simpleFuncVar : () => string
>simpleFunc : () => string
function anotherFuncNoReturn() {
>anotherFuncNoReturn : () => void
}
var anotherFuncNoReturnVar = anotherFuncNoReturn;
>anotherFuncNoReturnVar : () => void
>anotherFuncNoReturn : () => void
function withReturn() : string{
>withReturn : () => string
return "Hello";
>"Hello" : "Hello"
}
var withReturnVar = withReturn;
>withReturnVar : () => string
>withReturn : () => string
function withParams(a : string) : string{
>withParams : (a: string) => string
>a : string
return a;
>a : string
}
var withparamsVar = withParams;
>withparamsVar : (a: string) => string
>withParams : (a: string) => string
function withMultiParams(a : number, b, c: Object) {
>withMultiParams : (a: number, b: any, c: Object) => number
>a : number
>b : any
>c : Object
return a;
>a : number
}
var withMultiParamsVar = withMultiParams;
>withMultiParamsVar : (a: number, b: any, c: Object) => number
>withMultiParams : (a: number, b: any, c: Object) => number
function withOptionalParams(a?: string) {
>withOptionalParams : (a?: string) => void
>a : string
}
var withOptionalParamsVar = withOptionalParams;
>withOptionalParamsVar : (a?: string) => void
>withOptionalParams : (a?: string) => void
function withInitializedParams(a: string, b0, b = 30, c = "string value") {
>withInitializedParams : (a: string, b0: any, b?: number, c?: string) => void
>a : string
>b0 : any
>b : number
>30 : 30
>c : string
>"string value" : "string value"
}
var withInitializedParamsVar = withInitializedParams;
>withInitializedParamsVar : (a: string, b0: any, b?: number, c?: string) => void
>withInitializedParams : (a: string, b0: any, b?: number, c?: string) => void
function withOptionalInitializedParams(a: string, c: string = "hello string") {
>withOptionalInitializedParams : (a: string, c?: string) => void
>a : string
>c : string
>"hello string" : "hello string"
}
var withOptionalInitializedParamsVar = withOptionalInitializedParams;
>withOptionalInitializedParamsVar : (a: string, c?: string) => void
>withOptionalInitializedParams : (a: string, c?: string) => void
function withRestParams(a: string, ... myRestParameter : number[]) {
>withRestParams : (a: string, ...myRestParameter: number[]) => number[]
>a : string
>myRestParameter : number[]
return myRestParameter;
>myRestParameter : number[]
}
var withRestParamsVar = withRestParams;
>withRestParamsVar : (a: string, ...myRestParameter: number[]) => number[]
>withRestParams : (a: string, ...myRestParameter: number[]) => number[]
function overload1(n: number) : string;
>overload1 : { (n: number): string; (s: string): string; }
>n : number
function overload1(s: string) : string;
>overload1 : { (n: number): string; (s: string): string; }
>s : string
function overload1(ns: any) {
>overload1 : { (n: number): string; (s: string): string; }
>ns : any
return ns.toString();
>ns.toString() : any
>ns.toString : any
>ns : any
>toString : any
}
var withOverloadSignature = overload1;
>withOverloadSignature : { (n: number): string; (s: string): string; }
>overload1 : { (n: number): string; (s: string): string; }
function f(n: () => void) { }
>f : (n: () => void) => void
>n : () => void
module m2 {
>m2 : typeof m2
export function foo(n: () => void ) {
>foo : (n: () => void) => void
>n : () => void
}
}
m2.foo(() => {
>m2.foo(() => { var b = 30; return b;}) : void
>m2.foo : (n: () => void) => void
>m2 : typeof m2
>foo : (n: () => void) => void
>() => { var b = 30; return b;} : () => number
var b = 30;
>b : number
>30 : 30
return b;
>b : number
});
declare function fooAmbient(n: number): string;
>fooAmbient : (n: number) => string
>n : number
declare function overloadAmbient(n: number): string;
>overloadAmbient : { (n: number): string; (s: string): string; }
>n : number
declare function overloadAmbient(s: string): string;
>overloadAmbient : { (n: number): string; (s: string): string; }
>s : string
var f2 = () => {
>f2 : () => string
>() => { return "string";} : () => string
return "string";
>"string" : "string"
}
|
