Don't use UseTypeOfFunction in typeWriter

2025-11-18 17:21:48 +00:00 · 2014-08-28 12:52:44 -07:00
parent 46825ab05d
commit 44c2453ec6
468 changed files with 4147 additions and 4147 deletions
@@ -86,7 +86,7 @@ class TypeWriterWalker {
            column: lineAndCharacter.character,
            syntaxKind: ts.SyntaxKind[node.kind],
            sourceText: sourceText,
-            type: this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.UseTypeOfFunction)
+            type: this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.None)
        });
    }

@@ -18,7 +18,7 @@ module Point {
 >Point : typeof Point

    function Origin() { return ""; }// not an error, since not exported
->Origin : typeof Origin
+>Origin : () => string
 }


@@ -44,6 +44,6 @@ module A {
 >Point : typeof Point

        function Origin() { return ""; }// not an error since not exported
->Origin : typeof Origin
+>Origin : () => string
    }
 }
@@ -23,7 +23,7 @@ module A {
    }

    export function fromOrigin(p: Point): Line {
->fromOrigin : typeof fromOrigin
+>fromOrigin : (p: Point) => Line
 >p : Point
 >Point : Point
 >Line : Line
@@ -23,7 +23,7 @@ module A {
    }

    export function fromOrigin(p: Point): Line {
->fromOrigin : typeof fromOrigin
+>fromOrigin : (p: Point) => Line
 >p : Point
 >Point : Point
 >Line : Line
@@ -23,7 +23,7 @@ module A {
    }

    export function fromOrigin(p: Point): Line {
->fromOrigin : typeof fromOrigin
+>fromOrigin : (p: Point) => Line
 >p : Point
 >Point : Point
 >Line : Line
@@ -3,7 +3,7 @@ module A {
 >A : typeof A

    export function Point() {
->Point : typeof Point
+>Point : () => { x: number; y: number; }

        return { x: 0, y: 0 };
 >{ x: 0, y: 0 } : { x: number; y: number; }
@@ -35,9 +35,9 @@ var fn: () => { x: number; y: number };

 var fn = A.Point;
 >fn : () => { x: number; y: number; }
->A.Point : typeof A.Point
+>A.Point : () => { x: number; y: number; }
 >A : typeof A
->Point : typeof A.Point
+>Point : () => { x: number; y: number; }

 var cl: { x: number; y: number; }
 >cl : { x: number; y: number; }
@@ -16,7 +16,7 @@ module A {
 >Utils : typeof Utils

        export function mirror<T extends Point>(p: T) {
->mirror : typeof mirror
+>mirror : <T extends Point>(p: T) => { x: number; y: number; }
 >T : T
 >Point : Point
 >p : T
@@ -87,11 +87,11 @@ var o = A.Origin;
 var o = A.Utils.mirror(o);
 >o : { x: number; y: number; }
 >A.Utils.mirror(o) : { x: number; y: number; }
->A.Utils.mirror : typeof A.Utils.mirror
+>A.Utils.mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
 >A.Utils : typeof A.Utils
 >A : typeof A
 >Utils : typeof A.Utils
->mirror : typeof A.Utils.mirror
+>mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
 >o : { x: number; y: number; }

 var p: { tl: A.Point; br: A.Point };
@@ -19,7 +19,7 @@ module Root {
 >Utils : typeof Utils

            export function mirror<T extends Point>(p: T) {
->mirror : typeof mirror
+>mirror : <T extends Point>(p: T) => { x: number; y: number; }
 >T : T
 >Point : Point
 >p : T
@@ -16,7 +16,7 @@ module A {
 >Utils : typeof Utils

        export function mirror<T extends Point>(p: T) {
->mirror : typeof mirror
+>mirror : <T extends Point>(p: T) => { x: number; y: number; }
 >T : T
 >Point : Point
 >p : T
@@ -84,11 +84,11 @@ var o = A.Origin;
 var o = A.Utils.mirror(o);
 >o : { x: number; y: number; }
 >A.Utils.mirror(o) : { x: number; y: number; }
->A.Utils.mirror : typeof A.Utils.mirror
+>A.Utils.mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
 >A.Utils : typeof A.Utils
 >A : typeof A
 >Utils : typeof A.Utils
->mirror : typeof A.Utils.mirror
+>mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
 >o : { x: number; y: number; }

 var p: { tl: A.Point; br: A.Point };
@@ -1,6 +1,6 @@
 === tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithAnyAndEveryType.ts ===
 function foo() { }
->foo : typeof foo
+>foo : () => void

 class C {
 >C : C
@@ -98,14 +98,14 @@ var r10 = a + foo;
 >r10 : any
 >a + foo : any
 >a : any
->foo : typeof foo
+>foo : () => void

 var r11 = a + foo();
 >r11 : any
 >a + foo() : any
 >a : any
 >foo() : void
->foo : typeof foo
+>foo : () => void

 var r12 = a + C;
 >r12 : any
@@ -14,7 +14,7 @@ interface IHasVisualizationModel {
 >Model : typeof Backbone.Model
 }
 function foo<T extends { a: IHasVisualizationModel }>(x: T) {
->foo : typeof foo
+>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
 >T : T
 >a : IHasVisualizationModel
 >IHasVisualizationModel : IHasVisualizationModel
@@ -27,7 +27,7 @@ function foo<T extends { a: IHasVisualizationModel }>(x: T) {
 var r = foo({ a: moduleA });
 >r : { a: typeof moduleA; }
 >foo({ a: moduleA }) : { a: typeof moduleA; }
->foo : typeof foo
+>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
 >{ a: moduleA } : { a: typeof moduleA; }
 >a : typeof moduleA
 >moduleA : typeof moduleA
@@ -35,7 +35,7 @@ var r = foo({ a: moduleA });
 var r2 = foo({ a: <IHasVisualizationModel>null });
 >r2 : { a: IHasVisualizationModel; }
 >foo({ a: <IHasVisualizationModel>null }) : { a: IHasVisualizationModel; }
->foo : typeof foo
+>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
 >{ a: <IHasVisualizationModel>null } : { a: IHasVisualizationModel; }
 >a : IHasVisualizationModel
 ><IHasVisualizationModel>null : IHasVisualizationModel
@@ -14,9 +14,9 @@ export var a = function () {
    //var x = mod.id; // TODO needed hack that mod is loaded
    b.b(mod);
 >b.b(mod) : any
->b.b : typeof b.b
+>b.b : (a: any) => any
 >b : typeof b
->b : typeof b.b
+>b : (a: any) => any
 >mod : typeof mod
 }

@@ -26,6 +26,6 @@ export var id: number;

 === tests/cases/compiler/aliasUsedAsNameValue_1.ts ===
 export function b(a: any): any { return null; }
->b : typeof b
+>b : (a: any) => any
 >a : any

@@ -9,50 +9,50 @@ declare var m: string;

 // Ambient function with no type annotations
 declare function fn1();
->fn1 : typeof fn1
+>fn1 : () => any

 // Ambient function with type annotations
 declare function fn2(n: string): number;
->fn2 : typeof fn2
+>fn2 : (n: string) => number
 >n : string

 // Ambient function with valid overloads
 declare function fn3(n: string): number;
->fn3 : typeof fn3
+>fn3 : (n: string) => number
 >n : string

 declare function fn4(n: number, y: number): string;
->fn4 : typeof fn4
+>fn4 : (n: number, y: number) => string
 >n : number
 >y : number

 // Ambient function with optional parameters
 declare function fn5(x, y?);
->fn5 : typeof fn5
+>fn5 : (x: any, y?: any) => any
 >x : any
 >y : any

 declare function fn6(e?);
->fn6 : typeof fn6
+>fn6 : (e?: any) => any
 >e : any

 declare function fn7(x, y?, ...z);
->fn7 : typeof fn7
+>fn7 : (x: any, y?: any, ...z: any[]) => any
 >x : any
 >y : any
 >z : any[]

 declare function fn8(y?, ...z: number[]);
->fn8 : typeof fn8
+>fn8 : (y?: any, ...z: number[]) => any
 >y : any
 >z : number[]

 declare function fn9(...q: {}[]);
->fn9 : typeof fn9
+>fn9 : (...q: {}[]) => any
 >q : {}[]

 declare function fn10<T>(...q: T[]);
->fn10 : typeof fn10
+>fn10 : <T>(...q: T[]) => any
 >T : T
 >q : T[]
 >T : T
@@ -141,7 +141,7 @@ declare module M1 {
 >x : any

    function fn(): number;
->fn : typeof fn
+>fn : () => number
 }

 // Ambient module members are always exported with or without export keyword
@@ -154,9 +154,9 @@ var p = M1.x;
 var q = M1.fn();
 >q : number
 >M1.fn() : number
->M1.fn : typeof M1.fn
+>M1.fn : () => number
 >M1 : typeof M1
->fn : typeof M1.fn
+>fn : () => number

 // Ambient external module in the global module
 // Ambient external module with a string literal name that is a top level external module name
@@ -3,7 +3,7 @@ declare module Foo {
 >Foo : typeof Foo

 	function a():void;
->a : typeof a
+>a : () => void

 	var b:number;
 >b : number
@@ -14,9 +14,9 @@ declare module Foo {

 Foo.a();
 >Foo.a() : void
->Foo.a : typeof Foo.a
+>Foo.a : () => void
 >Foo : typeof Foo
->a : typeof Foo.a
+>a : () => void

 Foo.b;
 >Foo.b : number
@@ -34,7 +34,7 @@ declare module Foo2 {
 >Foo2 : typeof Foo2

    export function a(): void;
->a : typeof a
+>a : () => void

    export var b: number;
 >b : number
@@ -45,9 +45,9 @@ declare module Foo2 {

 Foo2.a();
 >Foo2.a() : void
->Foo2.a : typeof Foo2.a
+>Foo2.a : () => void
 >Foo2 : typeof Foo2
->a : typeof Foo2.a
+>a : () => void

 Foo2.b;
 >Foo2.b : number
@@ -8,14 +8,14 @@ class B extends A { x: number; }
 >x : number

 declare function f(p: A, q: B): number;
->f : typeof f
+>f : { (p: A, q: B): number; (p: B, q: A): string; }
 >p : A
 >A : A
 >q : B
 >B : B

 declare function f(p: B, q: A): string;
->f : typeof f
+>f : { (p: A, q: B): number; (p: B, q: A): string; }
 >p : B
 >B : B
 >q : A
@@ -28,7 +28,7 @@ var x: B;
 var t: number = f(x, x); // Not an error
 >t : number
 >f(x, x) : number
->f : typeof f
+>f : { (p: A, q: B): number; (p: B, q: A): string; }
 >x : B
 >x : B

@@ -1,6 +1,6 @@
 === tests/cases/compiler/anyAsReturnTypeForNewOnCall.ts ===
 function Point(x, y) {
->Point : typeof Point
+>Point : (x: any, y: any) => void
 >x : any
 >y : any

@@ -23,7 +23,7 @@ function Point(x, y) {
 var o = new Point(3, 4);
 >o : any
 >new Point(3, 4) : any
->Point : typeof Point
+>Point : (x: any, y: any) => void

 var xx = o.x;
 >xx : any
@@ -15,107 +15,107 @@ var a: any;
 >a : any

 declare function foo2(x: number): number;
->foo2 : typeof foo2
+>foo2 : { (x: number): number; (x: any): any; }
 >x : number

 declare function foo2(x: any): any;
->foo2 : typeof foo2
+>foo2 : { (x: number): number; (x: any): any; }
 >x : any

 var r3 = foo2(a); // any, not a subtype of number so it skips that overload, is a subtype of itself so it picks second (if truly ambiguous it would pick first overload)
 >r3 : any
 >foo2(a) : any
->foo2 : typeof foo2
+>foo2 : { (x: number): number; (x: any): any; }
 >a : any

 declare function foo3(x: string): string;
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >x : string

 declare function foo3(x: any): any;
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 declare function foo4(x: boolean): boolean;
->foo4 : typeof foo4
+>foo4 : { (x: boolean): boolean; (x: any): any; }
 >x : boolean

 declare function foo4(x: any): any;
->foo4 : typeof foo4
+>foo4 : { (x: boolean): boolean; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 declare function foo5(x: Date): Date;
->foo5 : typeof foo5
+>foo5 : { (x: Date): Date; (x: any): any; }
 >x : Date
 >Date : Date
 >Date : Date

 declare function foo5(x: any): any;
->foo5 : typeof foo5
+>foo5 : { (x: Date): Date; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 declare function foo6(x: RegExp): RegExp;
->foo6 : typeof foo6
+>foo6 : { (x: RegExp): RegExp; (x: any): any; }
 >x : RegExp
 >RegExp : RegExp
 >RegExp : RegExp

 declare function foo6(x: any): any;
->foo6 : typeof foo6
+>foo6 : { (x: RegExp): RegExp; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 declare function foo7(x: { bar: number }): { bar: number };
->foo7 : typeof foo7
+>foo7 : { (x: { bar: number; }): { bar: number; }; (x: any): any; }
 >x : { bar: number; }
 >bar : number
 >bar : number

 declare function foo7(x: any): any;
->foo7 : typeof foo7
+>foo7 : { (x: { bar: number; }): { bar: number; }; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 declare function foo8(x: number[]): number[];
->foo8 : typeof foo8
+>foo8 : { (x: number[]): number[]; (x: any): any; }
 >x : number[]

 declare function foo8(x: any): any;
->foo8 : typeof foo8
+>foo8 : { (x: number[]): number[]; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 interface I8 { foo: string }
@@ -123,19 +123,19 @@ interface I8 { foo: string }
 >foo : string

 declare function foo9(x: I8): I8;
->foo9 : typeof foo9
+>foo9 : { (x: I8): I8; (x: any): any; }
 >x : I8
 >I8 : I8
 >I8 : I8

 declare function foo9(x: any): any;
->foo9 : typeof foo9
+>foo9 : { (x: I8): I8; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 class A { foo: number; }
@@ -143,19 +143,19 @@ class A { foo: number; }
 >foo : number

 declare function foo10(x: A): A;
->foo10 : typeof foo10
+>foo10 : { (x: A): A; (x: any): any; }
 >x : A
 >A : A
 >A : A

 declare function foo10(x: any): any;
->foo10 : typeof foo10
+>foo10 : { (x: A): A; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 class A2<T> { foo: T; }
@@ -165,39 +165,39 @@ class A2<T> { foo: T; }
 >T : T

 declare function foo11(x: A2<string>): A2<string>;
->foo11 : typeof foo11
+>foo11 : { (x: A2<string>): A2<string>; (x: any): any; }
 >x : A2<string>
 >A2 : A2<T>
 >A2 : A2<T>

 declare function foo11(x: any): any;
->foo11 : typeof foo11
+>foo11 : { (x: A2<string>): A2<string>; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 declare function foo12(x: (x) => number): (x) => number;
->foo12 : typeof foo12
+>foo12 : { (x: (x: any) => number): (x: any) => number; (x: any): any; }
 >x : (x: any) => number
 >x : any
 >x : any

 declare function foo12(x: any): any;
->foo12 : typeof foo12
+>foo12 : { (x: (x: any) => number): (x: any) => number; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 declare function foo13(x: <T>(x: T) => T): <T>(x: T) => T;
->foo13 : typeof foo13
+>foo13 : { (x: <T>(x: T) => T): <T>(x: T) => T; (x: any): any; }
 >x : <T>(x: T) => T
 >T : T
 >x : T
@@ -209,13 +209,13 @@ declare function foo13(x: <T>(x: T) => T): <T>(x: T) => T;
 >T : T

 declare function foo13(x: any): any;
->foo13 : typeof foo13
+>foo13 : { (x: <T>(x: T) => T): <T>(x: T) => T; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 enum E { A }
@@ -223,19 +223,19 @@ enum E { A }
 >A : E

 declare function foo14(x: E): E;
->foo14 : typeof foo14
+>foo14 : { (x: E): E; (x: any): any; }
 >x : E
 >E : E
 >E : E

 declare function foo14(x: any): any;
->foo14 : typeof foo14
+>foo14 : { (x: E): E; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 function f() { }
@@ -248,19 +248,19 @@ module f {
 >bar : number
 }
 declare function foo15(x: typeof f): typeof f;
->foo15 : typeof foo15
+>foo15 : { (x: typeof f): typeof f; (x: any): any; }
 >x : typeof f
 >f : typeof f
 >f : typeof f

 declare function foo15(x: any): any;
->foo15 : typeof foo15
+>foo15 : { (x: typeof f): typeof f; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 class CC { baz: string }
@@ -274,48 +274,48 @@ module CC {
 >bar : number
 }
 declare function foo16(x: CC): CC;
->foo16 : typeof foo16
+>foo16 : { (x: CC): CC; (x: any): any; }
 >x : CC
 >CC : CC
 >CC : CC

 declare function foo16(x: any): any;
->foo16 : typeof foo16
+>foo16 : { (x: CC): CC; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 declare function foo17(x: Object): Object;
->foo17 : typeof foo17
+>foo17 : { (x: Object): Object; (x: any): any; }
 >x : Object
 >Object : Object
 >Object : Object

 declare function foo17(x: any): any;
->foo17 : typeof foo17
+>foo17 : { (x: Object): Object; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

 declare function foo18(x: {}): {};
->foo18 : typeof foo18
+>foo18 : { (x: {}): {}; (x: any): any; }
 >x : {}

 declare function foo18(x: any): any;
->foo18 : typeof foo18
+>foo18 : { (x: {}): {}; (x: any): any; }
 >x : any

 var r3 = foo3(a); // any
 >r3 : any
 >foo3(a) : any
->foo3 : typeof foo3
+>foo3 : { (x: string): string; (x: any): any; }
 >a : any

@@ -121,7 +121,7 @@ var q: String = a;
 >a : any

 function foo<T, U /*extends T*/, V extends Date>(x: T, y: U, z: V) {
->foo : typeof foo
+>foo : <T, U, V extends Date>(x: T, y: U, z: V) => void
 >T : T
 >U : U
 >V : V
@@ -1,6 +1,6 @@
 === tests/cases/compiler/arguments.ts ===
 function f() {
->f : typeof f
+>f : () => void

    var x=arguments[12];
 >x : any
@@ -1,11 +1,11 @@
 === tests/cases/compiler/arrayLiteralInNonVarArgParameter.ts ===
 function panic(val: string[], ...opt: string[]) { }
->panic : typeof panic
+>panic : (val: string[], ...opt: string[]) => void
 >val : string[]
 >opt : string[]

 panic([], 'one', 'two');
 >panic([], 'one', 'two') : void
->panic : typeof panic
+>panic : (val: string[], ...opt: string[]) => void
 >[] : string[]

@@ -118,7 +118,7 @@ var e: number;

 // Arrow function used in arrow function used in function
 function someFn() {
->someFn : typeof someFn
+>someFn : () => void

    var arr = (n: number) => (p: number) => p * n;
 >arr : (n: number) => (p: number) => number
@@ -141,7 +141,7 @@ function someFn() {

 // Arrow function used in function
 function someOtherFn() {
->someOtherFn : typeof someOtherFn
+>someOtherFn : () => void

    var arr = (n: number) => '' + n;
 >arr : (n: number) => string
@@ -160,7 +160,7 @@ function someOtherFn() {

 // Arrow function used in nested function in function
 function outerFn() {
->outerFn : typeof outerFn
+>outerFn : () => void

    function innerFn() {
 >innerFn : () => void
@@ -211,7 +211,7 @@ var g: string;

 // Arrow function used in nested function in arrow function in nested function
 function someOuterFn() {
->someOuterFn : typeof someOuterFn
+>someOuterFn : () => (n: string) => () => () => number

    var arr = (n: string) => {
 >arr : (n: string) => () => () => number
@@ -239,7 +239,7 @@ var h = someOuterFn()('')()();
 >someOuterFn()('')() : () => number
 >someOuterFn()('') : () => () => number
 >someOuterFn() : (n: string) => () => () => number
->someOuterFn : typeof someOuterFn
+>someOuterFn : () => (n: string) => () => () => number

 h.toExponential();
 >h.toExponential() : string
@@ -249,7 +249,7 @@ h.toExponential();

 // Arrow function used in try/catch/finally in function
 function tryCatchFn() {
->tryCatchFn : typeof tryCatchFn
+>tryCatchFn : () => void

    try {
        var x = () => this;
@@ -1,4 +1,4 @@
 === tests/cases/compiler/asiAmbientFunctionDeclaration.ts ===
 declare function foo()
->foo : typeof foo
+>foo : () => any

@@ -150,7 +150,7 @@ x = { f<T>(x: T) { return x; } }
 >x : T

 function j<T>(a: T) {
->j : typeof j
+>j : <T>(a: T) => void
 >T : T
 >a : T
 >T : T
@@ -10,16 +10,16 @@ var list = {};


 function returnType(): TokenType { return null; }
->returnType : typeof returnType
+>returnType : () => TokenType
 >TokenType : TokenType

 function foo() {
->foo : typeof foo
+>foo : () => void

    var x = returnType();
 >x : TokenType
 >returnType() : TokenType
->returnType : typeof returnType
+>returnType : () => TokenType

    var x: TokenType = list['one'];
 >x : TokenType
@@ -3,12 +3,12 @@ class Foo{};
 >Foo : Foo

 function bar(x: {new(): Foo;}){}
->bar : typeof bar
+>bar : (x: new () => Foo) => void
 >x : new () => Foo
 >Foo : Foo

 bar(Foo); // Error, but should be allowed
 >bar(Foo) : void
->bar : typeof bar
+>bar : (x: new () => Foo) => void
 >Foo : typeof Foo

@@ -1,6 +1,6 @@
 === tests/cases/compiler/assignmentCompatibilityForConstrainedTypeParameters.ts ===
 function foo<T extends { bar: string }>() {
->foo : typeof foo
+>foo : <T extends { bar: string; }>() => void
 >T : T
 >bar : string

@@ -12,7 +12,7 @@ x1 = value;
 >value : any

 function fn1(x2: number) {
->fn1 : typeof fn1
+>fn1 : (x2: number) => void
 >x2 : number

    x2 = value;
@@ -47,7 +47,7 @@ x3['a'] = value;
 >value : any

 function fn2(x4: number) {
->fn2 : typeof fn2
+>fn2 : (x4: number) => void
 >x4 : number

    (x4) = value;
@@ -1,6 +1,6 @@
 === tests/cases/compiler/avoid.ts ===
 function f() {
->f : typeof f
+>f : () => void

    var x=1;
 >x : number
@@ -9,12 +9,12 @@ function f() {
 var y=f();  // error void fn
 >y : void
 >f() : void
->f : typeof f
+>f : () => void

 var why:any=f(); // error void fn
 >why : any
 >f() : void
->f : typeof f
+>f : () => void

 var w:any;
 >w : any
@@ -23,7 +23,7 @@ w=f(); // error void fn
 >w=f() : void
 >w : any
 >f() : void
->f : typeof f
+>f : () => void

 class C {
 >C : C
@@ -45,6 +45,6 @@ var z=new C().g(); // error void fn
 var N=new f();  // ok with void fn
 >N : any
 >new f() : any
->f : typeof f
+>f : () => void


@@ -1,6 +1,6 @@
 === tests/cases/compiler/badOverloadError.ts ===
 function method() {
->method : typeof method
+>method : () => void

    var dictionary = <{ [index: string]: string; }>{};
 >dictionary : { [x: string]: string; }
@@ -1,10 +1,10 @@
 === tests/cases/compiler/badThisBinding.ts ===
 declare function foo(a:any): any;
->foo : typeof foo
+>foo : (a: any) => any
 >a : any

 declare function bar(a:any): any;
->bar : typeof bar
+>bar : (a: any) => any
 >a : any

 class Greeter {
@@ -13,12 +13,12 @@ class Greeter {
    constructor() {
 		foo(() => {
 >foo(() => {            bar(() => {                var x = this;			});		}) : any
->foo : typeof foo
+>foo : (a: any) => any
 >() => {            bar(() => {                var x = this;			});		} : () => void

            bar(() => {
 >bar(() => {                var x = this;			}) : any
->bar : typeof bar
+>bar : (a: any) => any
 >() => {                var x = this;			} : () => void

                var x = this;
@@ -102,7 +102,7 @@ var r11 = true ? base : derived2;
 >derived2 : Derived2

 function foo5<T, U>(t: T, u: U): Object {
->foo5 : typeof foo5
+>foo5 : <T, U>(t: T, u: U) => Object
 >T : T
 >U : U
 >t : T
@@ -14,23 +14,23 @@ interface IPromise<T> {
 }

 function f() {
->f : typeof f
+>f : () => IPromise<void>

    if (true) return b();
 >b() : IPromise<void>
->b : typeof b
+>b : () => IPromise<void>

    return d();
 >d() : IPromise<any>
->d : typeof d
+>d : () => IPromise<any>
 }


 function b(): IPromise<void> { return null; }
->b : typeof b
+>b : () => IPromise<void>
 >IPromise : IPromise<T>

 function d(): IPromise<any> { return null; }
->d : typeof d
+>d : () => IPromise<any>
 >IPromise : IPromise<T>

@@ -4,7 +4,7 @@ var BOOLEAN: boolean;
 >BOOLEAN : boolean

 function foo(): boolean { return true; }
->foo : typeof foo
+>foo : () => boolean

 class A {
 >A : A
@@ -64,7 +64,7 @@ var ResultIsNumber6 = ~foo();
 >ResultIsNumber6 : number
 >~foo() : number
 >foo() : boolean
->foo : typeof foo
+>foo : () => boolean

 var ResultIsNumber7 = ~A.foo();
 >ResultIsNumber7 : number
@@ -92,7 +92,7 @@ var ResultIsNumber8 = ~~BOOLEAN;
 ~foo();
 >~foo() : number
 >foo() : boolean
->foo : typeof foo
+>foo : () => boolean

 ~true, false;
 >~true, false : boolean
@@ -8,7 +8,7 @@ var NUMBER1: number[] = [1, 2];
 >[1, 2] : number[]

 function foo(): number { return 1; }
->foo : typeof foo
+>foo : () => number

 class A {
 >A : A
@@ -89,7 +89,7 @@ var ResultIsNumber9 = ~foo();
 >ResultIsNumber9 : number
 >~foo() : number
 >foo() : number
->foo : typeof foo
+>foo : () => number

 var ResultIsNumber10 = ~A.foo();
 >ResultIsNumber10 : number
@@ -136,7 +136,7 @@ var ResultIsNumber13 = ~~~(NUMBER + NUMBER);
 ~foo();
 >~foo() : number
 >foo() : number
->foo : typeof foo
+>foo : () => number

 ~objA.a;
 >~objA.a : number
@@ -8,7 +8,7 @@ var STRING1: string[] = ["", "abc"];
 >["", "abc"] : string[]

 function foo(): string { return "abc"; }
->foo : typeof foo
+>foo : () => string

 class A {
 >A : A
@@ -89,7 +89,7 @@ var ResultIsNumber9 = ~foo();
 >ResultIsNumber9 : number
 >~foo() : number
 >foo() : string
->foo : typeof foo
+>foo : () => string

 var ResultIsNumber10 = ~A.foo();
 >ResultIsNumber10 : number
@@ -144,7 +144,7 @@ var ResultIsNumber14 = ~~~(STRING + STRING);
 ~foo();
 >~foo() : number
 >foo() : string
->foo : typeof foo
+>foo : () => string

 ~objA.a,M.n;
 >~objA.a,M.n : string
@@ -2,7 +2,7 @@
 // valid invocations of generic functions with no explicit type arguments provided 

 function f<T>(x: T): T { return null; }
->f : typeof f
+>f : <T>(x: T) => T
 >T : T
 >x : T
 >T : T
@@ -11,7 +11,7 @@ function f<T>(x: T): T { return null; }
 var r = f(1);
 >r : number
 >f(1) : number
->f : typeof f
+>f : <T>(x: T) => T

 var f2 = <T>(x: T): T => { return null; }
 >f2 : <T>(x: T) => T
@@ -2,13 +2,13 @@
 // Call signatures without a return type annotation and function body return 'any'

 function foo(x) { }
->foo : typeof foo
+>foo : (x: any) => void
 >x : any

 var r = foo(1); // void since there's a body
 >r : void
 >foo(1) : void
->foo : typeof foo
+>foo : (x: any) => void

 interface I {
 >I : I
@@ -3,7 +3,7 @@

 // Simple types
 function foo(x) {
->foo : typeof foo
+>foo : (x: any) => number
 >x : any

    return 1;
@@ -11,36 +11,36 @@ function foo(x) {
 var r = foo(1);
 >r : number
 >foo(1) : number
->foo : typeof foo
+>foo : (x: any) => number

 function foo2(x) {
->foo2 : typeof foo2
+>foo2 : (x: any) => number
 >x : any

    return foo(x);
 >foo(x) : number
->foo : typeof foo
+>foo : (x: any) => number
 >x : any
 }
 var r2 = foo2(1);
 >r2 : number
 >foo2(1) : number
->foo2 : typeof foo2
+>foo2 : (x: any) => number

 function foo3() {
->foo3 : typeof foo3
+>foo3 : () => any

    return foo3();
 >foo3() : any
->foo3 : typeof foo3
+>foo3 : () => any
 }
 var r3 = foo3();
 >r3 : any
 >foo3() : any
->foo3 : typeof foo3
+>foo3 : () => any

 function foo4<T>(x: T) {
->foo4 : typeof foo4
+>foo4 : <T>(x: T) => T
 >T : T
 >x : T
 >T : T
@@ -51,10 +51,10 @@ function foo4<T>(x: T) {
 var r4 = foo4(1);
 >r4 : number
 >foo4(1) : number
->foo4 : typeof foo4
+>foo4 : <T>(x: T) => T

 function foo5(x) {
->foo5 : typeof foo5
+>foo5 : (x: any) => number
 >x : any

    if (true) {
@@ -66,10 +66,10 @@ function foo5(x) {
 var r5 = foo5(1);
 >r5 : number
 >foo5(1) : number
->foo5 : typeof foo5
+>foo5 : (x: any) => number

 function foo6(x) {
->foo6 : typeof foo6
+>foo6 : (x: any) => any[]
 >x : any

    try {
@@ -88,10 +88,10 @@ function foo6(x) {
 var r6 = foo6(1);
 >r6 : any[]
 >foo6(1) : any[]
->foo6 : typeof foo6
+>foo6 : (x: any) => any[]

 function foo7(x) {
->foo7 : typeof foo7
+>foo7 : (x: any) => string
 >x : any

    return typeof x;
@@ -101,11 +101,11 @@ function foo7(x) {
 var r7 = foo7(1);
 >r7 : string
 >foo7(1) : string
->foo7 : typeof foo7
+>foo7 : (x: any) => string

 // object types
 function foo8(x: number) {
->foo8 : typeof foo8
+>foo8 : (x: number) => { x: number; }
 >x : number

    return { x: x };
@@ -116,7 +116,7 @@ function foo8(x: number) {
 var r8 = foo8(1);
 >r8 : { x: number; }
 >foo8(1) : { x: number; }
->foo8 : typeof foo8
+>foo8 : (x: number) => { x: number; }

 interface I {
 >I : I
@@ -125,7 +125,7 @@ interface I {
 >foo : string
 }
 function foo9(x: number) {
->foo9 : typeof foo9
+>foo9 : (x: number) => I
 >x : number

    var i: I;
@@ -138,7 +138,7 @@ function foo9(x: number) {
 var r9 = foo9(1);
 >r9 : I
 >foo9(1) : I
->foo9 : typeof foo9
+>foo9 : (x: number) => I

 class C {
 >C : C
@@ -147,7 +147,7 @@ class C {
 >foo : string
 }
 function foo10(x: number) {
->foo10 : typeof foo10
+>foo10 : (x: number) => C
 >x : number

    var c: C;
@@ -160,7 +160,7 @@ function foo10(x: number) {
 var r10 = foo10(1);
 >r10 : C
 >foo10(1) : C
->foo10 : typeof foo10
+>foo10 : (x: number) => C

 module M {
 >M : typeof M
@@ -173,7 +173,7 @@ module M {
 >foo : string
 }
 function foo11() {
->foo11 : typeof foo11
+>foo11 : () => typeof M

    return M;
 >M : typeof M
@@ -181,7 +181,7 @@ function foo11() {
 var r11 = foo11();
 >r11 : typeof M
 >foo11() : typeof M
->foo11 : typeof foo11
+>foo11 : () => typeof M

 // merged declarations
 interface I2 {
@@ -197,7 +197,7 @@ interface I2 {
 >y : number
 }
 function foo12() {
->foo12 : typeof foo12
+>foo12 : () => I2

    var i2: I2;
 >i2 : I2
@@ -209,7 +209,7 @@ function foo12() {
 var r12 = foo12();
 >r12 : I2
 >foo12() : I2
->foo12 : typeof foo12
+>foo12 : () => I2

 function m1() { return 1; }
 >m1 : typeof m1
@@ -219,7 +219,7 @@ module m1 { export var y = 2; }
 >y : number

 function foo13() {
->foo13 : typeof foo13
+>foo13 : () => typeof m1

    return m1;
 >m1 : typeof m1
@@ -227,7 +227,7 @@ function foo13() {
 var r13 = foo13();
 >r13 : typeof m1
 >foo13() : typeof m1
->foo13 : typeof foo13
+>foo13 : () => typeof m1

 class c1 {
 >c1 : c1
@@ -245,7 +245,7 @@ module c1 {
 >x : number
 }
 function foo14() {
->foo14 : typeof foo14
+>foo14 : () => typeof c1

    return c1;
 >c1 : typeof c1
@@ -253,7 +253,7 @@ function foo14() {
 var r14 = foo14();
 >r14 : typeof c1
 >foo14() : typeof c1
->foo14 : typeof foo14
+>foo14 : () => typeof c1

 enum e1 { A }
 >e1 : e1
@@ -264,7 +264,7 @@ module e1 { export var y = 1; }
 >y : number

 function foo15() {
->foo15 : typeof foo15
+>foo15 : () => typeof e1

    return e1;
 >e1 : typeof e1
@@ -272,5 +272,5 @@ function foo15() {
 var r15 = foo15();
 >r15 : typeof e1
 >foo15() : typeof e1
->foo15 : typeof foo15
+>foo15 : () => typeof e1

@@ -2,7 +2,7 @@
 // Optional parameters should be valid in all the below casts

 function foo(x?: number) { }
->foo : typeof foo
+>foo : (x?: number) => void
 >x : number

 var f = function foo(x?: number) { }
@@ -19,11 +19,11 @@ var f2 = (x: number, y?: number) => { }

 foo(1);
 >foo(1) : void
->foo : typeof foo
+>foo : (x?: number) => void

 foo();
 >foo() : void
->foo : typeof foo
+>foo : (x?: number) => void

 f(1);
 >f(1) : void
@@ -2,42 +2,42 @@
 // Optional parameters should be valid in all the below casts

 function foo(x?: number);
->foo : typeof foo
+>foo : (x?: number) => any
 >x : number

 function foo(x?: number) { }
->foo : typeof foo
+>foo : (x?: number) => any
 >x : number

 foo(1);
 >foo(1) : any
->foo : typeof foo
+>foo : (x?: number) => any

 foo();
 >foo() : any
->foo : typeof foo
+>foo : (x?: number) => any

 function foo2(x: number);
->foo2 : typeof foo2
+>foo2 : { (x: number): any; (x: number, y?: number): any; }
 >x : number

 function foo2(x: number, y?: number);
->foo2 : typeof foo2
+>foo2 : { (x: number): any; (x: number, y?: number): any; }
 >x : number
 >y : number

 function foo2(x: number, y?: number) { }
->foo2 : typeof foo2
+>foo2 : { (x: number): any; (x: number, y?: number): any; }
 >x : number
 >y : number

 foo2(1);
 >foo2(1) : any
->foo2 : typeof foo2
+>foo2 : { (x: number): any; (x: number, y?: number): any; }

 foo2(1, 2);
 >foo2(1, 2) : any
->foo2 : typeof foo2
+>foo2 : { (x: number): any; (x: number, y?: number): any; }

 class C {
 >C : C
@@ -1,6 +1,6 @@
 === tests/cases/compiler/catch.ts ===
 function f() {
->f : typeof f
+>f : () => void

    try {} catch(e) { }
 >e : any
@@ -1,6 +1,6 @@
 === tests/cases/compiler/cf.ts ===
 function f() {
->f : typeof f
+>f : () => void

    var z;
 >z : any
@@ -8,17 +8,17 @@ import y = x;

 y.m.foo();
 >y.m.foo() : void
->y.m.foo : typeof x.m.foo
+>y.m.foo : () => void
 >y.m : typeof x.m
 >y : typeof x
 >m : typeof x.m
->foo : typeof x.m.foo
+>foo : () => void

 === tests/cases/compiler/chainedImportAlias_file0.ts ===
 export module m {
 >m : typeof m

    export function foo() { }
->foo : typeof foo
+>foo : () => void
 }

@@ -19,7 +19,7 @@
 >AjaxSettings : AjaxSettings
    }
    export function ajax(options: AjaxSettings) { }
->ajax : typeof ajax
+>ajax : (options: AjaxSettings) => void
 >options : AjaxSettings
 >AjaxSettings : AjaxSettings
  }
@@ -6,7 +6,7 @@ module M {
 >x : number

    function fn(M, p = x) { }
->fn : typeof fn
+>fn : (M: any, p?: number) => void
 >M : any
 >p : number
 >x : number
@@ -16,7 +16,7 @@ module M {
 >M : typeof M

    function fn2() {
->fn2 : typeof fn2
+>fn2 : () => void

        var M;
 >M : any
@@ -31,7 +31,7 @@ module M {
 >M : typeof M

    function fn3() {
->fn3 : typeof fn3
+>fn3 : () => void

        function M() {
 >M : () => void
@@ -44,7 +44,7 @@ module M {
 >m3 : typeof m3

        function M() {
->M : typeof M
+>M : () => void
        }
        var p = x;
 >p : number
@@ -53,7 +53,7 @@ module M {
        var p2 = M();
 >p2 : void
 >M() : void
->M : typeof M
+>M : () => void
    }
 }

@@ -1,11 +1,11 @@
 === tests/cases/compiler/collisionExportsRequireAndFunction.ts ===
 export function exports() {
->exports : typeof exports
+>exports : () => number

    return 1;
 }
 export function require() {
->require : typeof require
+>require : () => string

    return "require";
 }
@@ -10,7 +10,7 @@ export module require {
    }
 }
 export function foo(): require.I {
->foo : typeof foo
+>foo : () => require.I
 >require : unknown
 >I : require.I

@@ -27,7 +27,7 @@ export module exports {
    }
 }
 export function foo2(): exports.I {
->foo2 : typeof foo2
+>foo2 : () => exports.I
 >exports : unknown
 >I : exports.I

@@ -7,7 +7,7 @@ export module require { // no error
    }
 }
 export function foo(): require.I {
->foo : typeof foo
+>foo : () => require.I
 >require : unknown
 >I : require.I

@@ -21,7 +21,7 @@ export module exports { // no error
    }
 }
 export function foo2(): exports.I {
->foo2 : typeof foo2
+>foo2 : () => exports.I
 >exports : unknown
 >I : exports.I

@@ -1,6 +1,6 @@
 === tests/cases/compiler/collisionExportsRequireAndVar.ts ===
 export function foo() {
->foo : typeof foo
+>foo : () => void
 }
 var exports = 1;
 >exports : number
@@ -12,7 +12,7 @@ var v1 = ((1, 2, 3), 4, 5, (6, 7));
 >6, 7 : number

 function f1() {
->f1 : typeof f1
+>f1 : () => number

    var a = 1;
 >a : number
@@ -16,7 +16,7 @@ for (var i = 0, j = 10; i < j; i++, j--)

 //Comma operator in fuction arguments and return
 function foo(x: number, y: string)
->foo : typeof foo
+>foo : (x: number, y: string) => string
 >x : number
 >y : string
 {
@@ -28,11 +28,11 @@ function foo(x: number, y: string)
 var resultIsString = foo(1, "123");
 >resultIsString : string
 >foo(1, "123") : string
->foo : typeof foo
+>foo : (x: number, y: string) => string

 //TypeParameters
 function foo1<T1, T2>()
->foo1 : typeof foo1
+>foo1 : <T1, T2>() => void
 >T1 : T1
 >T2 : T2
 {
@@ -1,4 +1,4 @@
 === tests/cases/compiler/commentInEmptyParameterList1.ts ===
 function foo(/** nothing */) {
->foo : typeof foo
+>foo : () => void
 }
@@ -1,15 +1,15 @@
 === tests/cases/compiler/commentOnSignature1.ts ===
 /*! Keep this pinned comment */
 function foo(n: number): void;
->foo : typeof foo
+>foo : { (n: number): void; (s: string): void; }
 >n : number

 // Don't keep this comment.
 function foo(s: string): void;
->foo : typeof foo
+>foo : { (n: number): void; (s: string): void; }
 >s : string

 function foo(a: any): void {
->foo : typeof foo
+>foo : { (n: number): void; (s: string): void; }
 >a : any
 }
@@ -1,13 +1,13 @@
 === tests/cases/compiler/commentOnSimpleArrowFunctionBody1.ts ===
 function Foo(x: any)
->Foo : typeof Foo
+>Foo : (x: any) => void
 >x : any
 {
 }
 
 Foo(() =>
 >Foo(() =>    // do something    127) : void
->Foo : typeof Foo
+>Foo : (x: any) => void
 >() =>    // do something    127 : () => number

    // do something
@@ -2,41 +2,41 @@

 /// This is simple /// comments
 function simple() {
->simple : typeof simple
+>simple : () => void
 }

 simple();
 >simple() : void
->simple : typeof simple
+>simple : () => void

 /// multiLine /// Comments
 /// This is example of multiline /// comments
 /// Another multiLine
 function multiLine() {
->multiLine : typeof multiLine
+>multiLine : () => void
 }
 multiLine();
 >multiLine() : void
->multiLine : typeof multiLine
+>multiLine : () => void

 /** this is eg of single line jsdoc style comment */
 function jsDocSingleLine() {
->jsDocSingleLine : typeof jsDocSingleLine
+>jsDocSingleLine : () => void
 }
 jsDocSingleLine();
 >jsDocSingleLine() : void
->jsDocSingleLine : typeof jsDocSingleLine
+>jsDocSingleLine : () => void


 /** this is multiple line jsdoc stule comment
 *New line1
 *New Line2*/
 function jsDocMultiLine() {
->jsDocMultiLine : typeof jsDocMultiLine
+>jsDocMultiLine : () => void
 }
 jsDocMultiLine();
 >jsDocMultiLine() : void
->jsDocMultiLine : typeof jsDocMultiLine
+>jsDocMultiLine : () => void

 /** this is multiple line jsdoc stule comment
 *New line1
@@ -44,60 +44,60 @@ jsDocMultiLine();
 /** Shoul mege this line as well
 * and this too*/ /** Another this one too*/
 function jsDocMultiLineMerge() {
->jsDocMultiLineMerge : typeof jsDocMultiLineMerge
+>jsDocMultiLineMerge : () => void
 }
 jsDocMultiLineMerge();
 >jsDocMultiLineMerge() : void
->jsDocMultiLineMerge : typeof jsDocMultiLineMerge
+>jsDocMultiLineMerge : () => void


 /// Triple slash comment
 /** jsdoc comment */
 function jsDocMixedComments1() {
->jsDocMixedComments1 : typeof jsDocMixedComments1
+>jsDocMixedComments1 : () => void
 }
 jsDocMixedComments1();
 >jsDocMixedComments1() : void
->jsDocMixedComments1 : typeof jsDocMixedComments1
+>jsDocMixedComments1 : () => void

 /// Triple slash comment
 /** jsdoc comment */ /*** another jsDocComment*/
 function jsDocMixedComments2() {
->jsDocMixedComments2 : typeof jsDocMixedComments2
+>jsDocMixedComments2 : () => void
 }
 jsDocMixedComments2();
 >jsDocMixedComments2() : void
->jsDocMixedComments2 : typeof jsDocMixedComments2
+>jsDocMixedComments2 : () => void

 /** jsdoc comment */ /*** another jsDocComment*/
 /// Triple slash comment
 function jsDocMixedComments3() {
->jsDocMixedComments3 : typeof jsDocMixedComments3
+>jsDocMixedComments3 : () => void
 }
 jsDocMixedComments3();
 >jsDocMixedComments3() : void
->jsDocMixedComments3 : typeof jsDocMixedComments3
+>jsDocMixedComments3 : () => void

 /** jsdoc comment */ /*** another jsDocComment*/
 /// Triple slash comment
 /// Triple slash comment 2
 function jsDocMixedComments4() {
->jsDocMixedComments4 : typeof jsDocMixedComments4
+>jsDocMixedComments4 : () => void
 }
 jsDocMixedComments4();
 >jsDocMixedComments4() : void
->jsDocMixedComments4 : typeof jsDocMixedComments4
+>jsDocMixedComments4 : () => void

 /// Triple slash comment 1
 /** jsdoc comment */ /*** another jsDocComment*/
 /// Triple slash comment
 /// Triple slash comment 2
 function jsDocMixedComments5() {
->jsDocMixedComments5 : typeof jsDocMixedComments5
+>jsDocMixedComments5 : () => void
 }
 jsDocMixedComments5();
 >jsDocMixedComments5() : void
->jsDocMixedComments5 : typeof jsDocMixedComments5
+>jsDocMixedComments5 : () => void

 /*** another jsDocComment*/
 /// Triple slash comment 1
@@ -105,41 +105,41 @@ jsDocMixedComments5();
 /// Triple slash comment 2
 /** jsdoc comment */
 function jsDocMixedComments6() {
->jsDocMixedComments6 : typeof jsDocMixedComments6
+>jsDocMixedComments6 : () => void
 }
 jsDocMixedComments6();
 >jsDocMixedComments6() : void
->jsDocMixedComments6 : typeof jsDocMixedComments6
+>jsDocMixedComments6 : () => void

 // This shoulnot be help comment
 function noHelpComment1() {
->noHelpComment1 : typeof noHelpComment1
+>noHelpComment1 : () => void
 }
 noHelpComment1();
 >noHelpComment1() : void
->noHelpComment1 : typeof noHelpComment1
+>noHelpComment1 : () => void

 /* This shoulnot be help comment */
 function noHelpComment2() {
->noHelpComment2 : typeof noHelpComment2
+>noHelpComment2 : () => void
 }
 noHelpComment2();
 >noHelpComment2() : void
->noHelpComment2 : typeof noHelpComment2
+>noHelpComment2 : () => void

 function noHelpComment3() {
->noHelpComment3 : typeof noHelpComment3
+>noHelpComment3 : () => void
 }
 noHelpComment3();
 >noHelpComment3() : void
->noHelpComment3 : typeof noHelpComment3
+>noHelpComment3 : () => void

 /** Adds two integers and returns the result
  * @param {number} a first number
  * @param b second number
  */
 function sum(a: number, b: number) {
->sum : typeof sum
+>sum : (a: number, b: number) => number
 >a : number
 >b : number

@@ -150,7 +150,7 @@ function sum(a: number, b: number) {
 }
 sum(10, 20);
 >sum(10, 20) : number
->sum : typeof sum
+>sum : (a: number, b: number) => number

 /** This is multiplication function*/
 /** @param */
@@ -160,7 +160,7 @@ sum(10, 20);
 @param d @anotherTag*/
 /** @param e LastParam @anotherTag*/
 function multiply(a: number, b: number, c?: number, d?, e?) {
->multiply : typeof multiply
+>multiply : (a: number, b: number, c?: number, d?: any, e?: any) => void
 >a : number
 >b : number
 >c : number
@@ -171,16 +171,16 @@ function multiply(a: number, b: number, c?: number, d?, e?) {
 * @param { string} b about b
 */
 function f1(a: number);
->f1 : typeof f1
+>f1 : { (a: number): any; (b: string): any; }
 >a : number

 function f1(b: string);
->f1 : typeof f1
+>f1 : { (a: number): any; (b: string): any; }
 >b : string

 /**@param opt optional parameter*/
 function f1(aOrb, opt?) {
->f1 : typeof f1
+>f1 : { (a: number): any; (b: string): any; }
 >aOrb : any
 >opt : any

@@ -196,7 +196,7 @@ function f1(aOrb, opt?) {
@param { { { () => string; } } f this is optional param f
 */
 function subtract(a: number, b: number, c?: () => string, d?: () => string, e?: () => string, f?: () => string) {
->subtract : typeof subtract
+>subtract : (a: number, b: number, c?: () => string, d?: () => string, e?: () => string, f?: () => string) => void
 >a : number
 >b : number
 >c : () => string
@@ -210,7 +210,7 @@ function subtract(a: number, b: number, c?: () => string, d?: () => string, e?:
@returnType { number } it is return type
 */
 function square(a: number) {
->square : typeof square
+>square : (a: number) => number
 >a : number

    return a * a;
@@ -224,7 +224,7 @@ function square(a: number) {
@param { number} b this is b
 */
 function divide(a: number, b: number) {
->divide : typeof divide
+>divide : (a: number, b: number) => void
 >a : number
 >b : number
 }
@@ -233,7 +233,7 @@ function divide(a: number, b: number) {
 *@param c it is third parameter
 */
 function jsDocParamTest(/** this is inline comment for a */a: number, /** this is inline comment for b*/ b: number, c: number, d: number) {
->jsDocParamTest : typeof jsDocParamTest
+>jsDocParamTest : (a: number, b: number, c: number, d: number) => number
 >a : number
 >b : number
 >c : number
@@ -5,11 +5,11 @@ import extMod = require("commentsExternalModules_0"); // trailing comment1

 extMod.m1.fooExport();
 >extMod.m1.fooExport() : number
->extMod.m1.fooExport : typeof extMod.m1.fooExport
+>extMod.m1.fooExport : () => number
 >extMod.m1 : typeof extMod.m1
 >extMod : typeof extMod
 >m1 : typeof extMod.m1
->fooExport : typeof extMod.m1.fooExport
+>fooExport : () => number

 var newVar = new extMod.m1.m2.c();
 >newVar : extMod.m1.m2.c
@@ -24,11 +24,11 @@ var newVar = new extMod.m1.m2.c();

 extMod.m4.fooExport();
 >extMod.m4.fooExport() : number
->extMod.m4.fooExport : typeof extMod.m4.fooExport
+>extMod.m4.fooExport : () => number
 >extMod.m4 : typeof extMod.m4
 >extMod : typeof extMod
 >m4 : typeof extMod.m4
->fooExport : typeof extMod.m4.fooExport
+>fooExport : () => number

 var newVar2 = new extMod.m4.m2.c();
 >newVar2 : extMod.m4.m2.c
@@ -53,7 +53,7 @@ export module m1 {

    /** foo's comment*/
    function foo() {
->foo : typeof foo
+>foo : () => number

        return b;
 >b : number
@@ -75,18 +75,18 @@ export module m1 {
    }
    /** exported function*/
    export function fooExport() {
->fooExport : typeof fooExport
+>fooExport : () => number

        return foo();
 >foo() : number
->foo : typeof foo
+>foo : () => number
    }
 }
 m1.fooExport();
 >m1.fooExport() : number
->m1.fooExport : typeof m1.fooExport
+>m1.fooExport : () => number
 >m1 : typeof m1
->fooExport : typeof m1.fooExport
+>fooExport : () => number

 var myvar = new m1.m2.c();
 >myvar : m1.m2.c
@@ -108,7 +108,7 @@ export module m4 {
    /** foo's comment
    */
    function foo() {
->foo : typeof foo
+>foo : () => number

        return b;
 >b : number
@@ -131,18 +131,18 @@ export module m4 {
    }
    /** exported function */
    export function fooExport() {
->fooExport : typeof fooExport
+>fooExport : () => number

        return foo();
 >foo() : number
->foo : typeof foo
+>foo : () => number
    }
 }
 m4.fooExport();
 >m4.fooExport() : number
->m4.fooExport : typeof m4.fooExport
+>m4.fooExport : () => number
 >m4 : typeof m4
->fooExport : typeof m4.fooExport
+>fooExport : () => number

 var myvar2 = new m4.m2.c();
 >myvar2 : m4.m2.c
@@ -5,11 +5,11 @@ import extMod = require("commentsExternalModules2_0"); // trailing comment 1

 extMod.m1.fooExport();
 >extMod.m1.fooExport() : number
->extMod.m1.fooExport : typeof extMod.m1.fooExport
+>extMod.m1.fooExport : () => number
 >extMod.m1 : typeof extMod.m1
 >extMod : typeof extMod
 >m1 : typeof extMod.m1
->fooExport : typeof extMod.m1.fooExport
+>fooExport : () => number

 export var newVar = new extMod.m1.m2.c();
 >newVar : extMod.m1.m2.c
@@ -24,11 +24,11 @@ export var newVar = new extMod.m1.m2.c();

 extMod.m4.fooExport();
 >extMod.m4.fooExport() : number
->extMod.m4.fooExport : typeof extMod.m4.fooExport
+>extMod.m4.fooExport : () => number
 >extMod.m4 : typeof extMod.m4
 >extMod : typeof extMod
 >m4 : typeof extMod.m4
->fooExport : typeof extMod.m4.fooExport
+>fooExport : () => number

 export var newVar2 = new extMod.m4.m2.c();
 >newVar2 : extMod.m4.m2.c
@@ -53,7 +53,7 @@ export module m1 {

    /** foo's comment*/
    function foo() {
->foo : typeof foo
+>foo : () => number

        return b;
 >b : number
@@ -75,18 +75,18 @@ export module m1 {
    }
    /** exported function*/
    export function fooExport() {
->fooExport : typeof fooExport
+>fooExport : () => number

        return foo();
 >foo() : number
->foo : typeof foo
+>foo : () => number
    }
 }
 m1.fooExport();
 >m1.fooExport() : number
->m1.fooExport : typeof m1.fooExport
+>m1.fooExport : () => number
 >m1 : typeof m1
->fooExport : typeof m1.fooExport
+>fooExport : () => number

 var myvar = new m1.m2.c();
 >myvar : m1.m2.c
@@ -108,7 +108,7 @@ export module m4 {
    /** foo's comment
    */
    function foo() {
->foo : typeof foo
+>foo : () => number

        return b;
 >b : number
@@ -131,18 +131,18 @@ export module m4 {
    }
    /** exported function */
    export function fooExport() {
->fooExport : typeof fooExport
+>fooExport : () => number

        return foo();
 >foo() : number
->foo : typeof foo
+>foo : () => number
    }
 }
 m4.fooExport();
 >m4.fooExport() : number
->m4.fooExport : typeof m4.fooExport
+>m4.fooExport : () => number
 >m4 : typeof m4
->fooExport : typeof m4.fooExport
+>fooExport : () => number

 var myvar2 = new m4.m2.c();
 >myvar2 : m4.m2.c
@@ -5,11 +5,11 @@ import extMod = require("commentsExternalModules2_0"); // trailing comment 1

 extMod.m1.fooExport();
 >extMod.m1.fooExport() : number
->extMod.m1.fooExport : typeof extMod.m1.fooExport
+>extMod.m1.fooExport : () => number
 >extMod.m1 : typeof extMod.m1
 >extMod : typeof extMod
 >m1 : typeof extMod.m1
->fooExport : typeof extMod.m1.fooExport
+>fooExport : () => number

 export var newVar = new extMod.m1.m2.c();
 >newVar : extMod.m1.m2.c
@@ -24,11 +24,11 @@ export var newVar = new extMod.m1.m2.c();

 extMod.m4.fooExport();
 >extMod.m4.fooExport() : number
->extMod.m4.fooExport : typeof extMod.m4.fooExport
+>extMod.m4.fooExport : () => number
 >extMod.m4 : typeof extMod.m4
 >extMod : typeof extMod
 >m4 : typeof extMod.m4
->fooExport : typeof extMod.m4.fooExport
+>fooExport : () => number

 export var newVar2 = new extMod.m4.m2.c();
 >newVar2 : extMod.m4.m2.c
@@ -53,7 +53,7 @@ export module m1 {

    /** foo's comment*/
    function foo() {
->foo : typeof foo
+>foo : () => number

        return b;
 >b : number
@@ -75,18 +75,18 @@ export module m1 {
    }
    /** exported function*/
    export function fooExport() {
->fooExport : typeof fooExport
+>fooExport : () => number

        return foo();
 >foo() : number
->foo : typeof foo
+>foo : () => number
    }
 }
 m1.fooExport();
 >m1.fooExport() : number
->m1.fooExport : typeof m1.fooExport
+>m1.fooExport : () => number
 >m1 : typeof m1
->fooExport : typeof m1.fooExport
+>fooExport : () => number

 var myvar = new m1.m2.c();
 >myvar : m1.m2.c
@@ -108,7 +108,7 @@ export module m4 {
    /** foo's comment
    */
    function foo() {
->foo : typeof foo
+>foo : () => number

        return b;
 >b : number
@@ -131,18 +131,18 @@ export module m4 {
    }
    /** exported function */
    export function fooExport() {
->fooExport : typeof fooExport
+>fooExport : () => number

        return foo();
 >foo() : number
->foo : typeof foo
+>foo : () => number
    }
 }
 m4.fooExport();
 >m4.fooExport() : number
->m4.fooExport : typeof m4.fooExport
+>m4.fooExport : () => number
 >m4 : typeof m4
->fooExport : typeof m4.fooExport
+>fooExport : () => number

 var myvar2 = new m4.m2.c();
 >myvar2 : m4.m2.c
@@ -2,16 +2,16 @@

 /** This comment should appear for foo*/
 function foo() {
->foo : typeof foo
+>foo : () => void

 } /* trailing comment of function */
 foo();
 >foo() : void
->foo : typeof foo
+>foo : () => void

 /** This is comment for function signature*/
 function fooWithParameters(/** this is comment about a*/a: string,
->fooWithParameters : typeof fooWithParameters
+>fooWithParameters : (a: string, b: number) => void
 >a : string

    /** this is comment for b*/
@@ -25,7 +25,7 @@ function fooWithParameters(/** this is comment about a*/a: string,
 } // trailing comment of function
 fooWithParameters("a", 10);
 >fooWithParameters("a", 10) : void
->fooWithParameters : typeof fooWithParameters
+>fooWithParameters : (a: string, b: number) => void

 /** fooFunc
 * comment
@@ -68,19 +68,19 @@ lambddaNoVarComment(10, 20);
 >lambddaNoVarComment : (a: number, b: number) => number

 function blah(a: string /* multiline trailing comment 
->blah : typeof blah
+>blah : (a: string) => void
 >a : string

 multiline */) {
 }

 function blah2(a: string /* single line multiple trailing comments */ /* second */) {
->blah2 : typeof blah2
+>blah2 : (a: string) => void
 >a : string
 }

 function blah3(a: string // trailing commen single line
->blah3 : typeof blah3
+>blah3 : (a: string) => void
 >a : string

    ) {
@@ -104,19 +104,19 @@ lambdaFoo = (a, b) => a * b; // This is trailing comment
 >() => 0 : () => number

 function blah4(/*1*/a: string/*2*/,/*3*/b: string/*4*/) {
->blah4 : typeof blah4
+>blah4 : (a: string, b: string) => void
 >a : string
 >b : string
 }

 function foo1() {
->foo1 : typeof foo1
+>foo1 : () => void

    // should emit this
 }

 function foo2() {
->foo2 : typeof foo2
+>foo2 : () => void

    /// This is some detached comment

@@ -9,7 +9,7 @@ module m1 {

    /** foo's comment*/
    function foo() {
->foo : typeof foo
+>foo : () => number

        return b;
 >b : number
@@ -31,16 +31,16 @@ module m1 {
    }
    /** exported function*/
    export function fooExport() {
->fooExport : typeof fooExport
+>fooExport : () => number

        return foo();
 >foo() : number
->foo : typeof foo
+>foo : () => number
    }

    // shouldn't appear
    export function foo2Export(/**hm*/ a: string) {
->foo2Export : typeof foo2Export
+>foo2Export : (a: string) => void
 >a : string
    }

@@ -48,21 +48,21 @@ module m1 {
     * comment
     */
    export function foo3Export() {
->foo3Export : typeof foo3Export
+>foo3Export : () => void
    }

    /** foo4Export
     * comment
     */
    function foo4Export() {
->foo4Export : typeof foo4Export
+>foo4Export : () => void
    }
 } // trailing comment module
 m1.fooExport();
 >m1.fooExport() : number
->m1.fooExport : typeof m1.fooExport
+>m1.fooExport : () => number
 >m1 : typeof m1
->fooExport : typeof m1.fooExport
+>fooExport : () => number

 var myvar = new m1.m2.c();
 >myvar : m1.m2.c
@@ -1,96 +1,96 @@
 === tests/cases/compiler/commentsOverloads.ts ===
 /** this is signature 1*/
 function f1(/**param a*/a: number): number;
->f1 : typeof f1
+>f1 : { (a: number): number; (b: string): number; }
 >a : number

 function f1(b: string): number;
->f1 : typeof f1
+>f1 : { (a: number): number; (b: string): number; }
 >b : string

 function f1(aOrb: any) {
->f1 : typeof f1
+>f1 : { (a: number): number; (b: string): number; }
 >aOrb : any

    return 10;
 }
 f1("hello");
 >f1("hello") : number
->f1 : typeof f1
+>f1 : { (a: number): number; (b: string): number; }

 f1(10);
 >f1(10) : number
->f1 : typeof f1
+>f1 : { (a: number): number; (b: string): number; }

 function f2(a: number): number;
->f2 : typeof f2
+>f2 : { (a: number): number; (b: string): number; }
 >a : number

 /** this is signature 2*/
 function f2(b: string): number;
->f2 : typeof f2
+>f2 : { (a: number): number; (b: string): number; }
 >b : string

 /** this is f2 var comment*/
 function f2(aOrb: any) {
->f2 : typeof f2
+>f2 : { (a: number): number; (b: string): number; }
 >aOrb : any

    return 10;
 }
 f2("hello");
 >f2("hello") : number
->f2 : typeof f2
+>f2 : { (a: number): number; (b: string): number; }

 f2(10);
 >f2(10) : number
->f2 : typeof f2
+>f2 : { (a: number): number; (b: string): number; }

 function f3(a: number): number;
->f3 : typeof f3
+>f3 : { (a: number): number; (b: string): number; }
 >a : number

 function f3(b: string): number;
->f3 : typeof f3
+>f3 : { (a: number): number; (b: string): number; }
 >b : string

 function f3(aOrb: any) {
->f3 : typeof f3
+>f3 : { (a: number): number; (b: string): number; }
 >aOrb : any

    return 10;
 }
 f3("hello");
 >f3("hello") : number
->f3 : typeof f3
+>f3 : { (a: number): number; (b: string): number; }

 f3(10);
 >f3(10) : number
->f3 : typeof f3
+>f3 : { (a: number): number; (b: string): number; }

 /** this is signature 4 - with number parameter*/
 function f4(/**param a*/a: number): number;
->f4 : typeof f4
+>f4 : { (a: number): number; (b: string): number; }
 >a : number

 /** this is signature 4 - with string parameter*/
 function f4(b: string): number;
->f4 : typeof f4
+>f4 : { (a: number): number; (b: string): number; }
 >b : string

 function f4(aOrb: any) {
->f4 : typeof f4
+>f4 : { (a: number): number; (b: string): number; }
 >aOrb : any

    return 10;
 }
 f4("hello");
 >f4("hello") : number
->f4 : typeof f4
+>f4 : { (a: number): number; (b: string): number; }

 f4(10);
 >f4(10) : number
->f4 : typeof f4
+>f4 : { (a: number): number; (b: string): number; }

 interface i1 {
 >i1 : i1
@@ -33,7 +33,7 @@ class C</**docComment for type parameter*/ T> {
 }

 function compare</**type*/T>(a: T, b: T) {
->compare : typeof compare
+>compare : <T>(a: T, b: T) => boolean
 >T : T
 >a : T
 >T : T
@@ -6,7 +6,7 @@ var myVariable = 10;

 /** function comments*/
 function foo(/** parameter comment*/p: number) {
->foo : typeof foo
+>foo : (p: number) => void
 >p : number
 }

@@ -16,7 +16,7 @@ var fooVar: () => void;

 foo(50);
 >foo(50) : void
->foo : typeof foo
+>foo : (p: number) => void

 fooVar();
 >fooVar() : void
@@ -6,7 +6,7 @@ var myVariable = 10;

 /** function comments*/
 function foo(/** parameter comment*/p: number) {
->foo : typeof foo
+>foo : (p: number) => void
 >p : number
 }

@@ -16,7 +16,7 @@ var fooVar: () => void;

 foo(50);
 >foo(50) : void
->foo : typeof foo
+>foo : (p: number) => void

 fooVar();
 >fooVar() : void
@@ -1,6 +1,6 @@
 === tests/cases/conformance/expressions/binaryOperators/comparisonOperator/comparisonOperatorWithIdenticalTypeParameter.ts ===
 function foo<T>(t: T) {
->foo : typeof foo
+>foo : <T>(t: T) => void
 >T : T
 >t : T
 >T : T
@@ -9,7 +9,7 @@ enum E { a, b, c }
 >c : E

 function foo<T>(t: T) {
->foo : typeof foo
+>foo : <T>(t: T) => void
 >T : T
 >t : T
 >T : T
@@ -6,7 +6,7 @@ enum E { a, b, c }
 >c : E

 function foo<T>(t: T) {
->foo : typeof foo
+>foo : <T>(t: T) => void
 >T : T
 >t : T
 >T : T
@@ -10,7 +10,7 @@ enum E { a, b, c }
 >c : E

 function foo<T>(t: T) {
->foo : typeof foo
+>foo : <T>(t: T) => void
 >T : T
 >t : T
 >T : T
@@ -1,13 +1,13 @@
 === tests/cases/compiler/compositeGenericFunction.ts ===
 function f<T>(value: T) { return value; };
->f : typeof f
+>f : <T>(value: T) => T
 >T : T
 >value : T
 >T : T
 >value : T

 function h<R>(func: (x: number) => R): R { return null; }
->h : typeof h
+>h : <R>(func: (x: number) => R) => R
 >R : R
 >func : (x: number) => R
 >x : number
@@ -17,12 +17,12 @@ function h<R>(func: (x: number) => R): R { return null; }
 var z: number = h<number>(f);
 >z : number
 >h<number>(f) : number
->h : typeof h
->f : typeof f
+>h : <R>(func: (x: number) => R) => R
+>f : <T>(value: T) => T

 var z: number = h(f);
 >z : number
 >h(f) : number
->h : typeof h
->f : typeof f
+>h : <R>(func: (x: number) => R) => R
+>f : <T>(value: T) => T

@@ -17,7 +17,7 @@ x1 += value;
 >value : any

 function fn1(x2: number) {
->fn1 : typeof fn1
+>fn1 : (x2: number) => void
 >x2 : number

    x2 *= value;
@@ -76,7 +76,7 @@ x3['a'] += value;
 >value : any

 function fn2(x4: number) {
->fn2 : typeof fn2
+>fn2 : (x4: number) => void
 >x4 : number

    (x4) *= value;
@@ -38,7 +38,7 @@ var h = [{h:5}, null];
 >h : number

 function i() { if (true) { return { x: 5 }; } else { return null; } }
->i : typeof i
+>i : () => { x: number; }
 >{ x: 5 } : { x: number; }
 >x : number

@@ -95,7 +95,7 @@ condNumber ? exprIsObject1 : exprIsObject2;

 //Cond is a number type expression
 function foo() { return 1 };
->foo : typeof foo
+>foo : () => number

 var array = [1, 2, 3];
 >array : number[]
@@ -123,7 +123,7 @@ var array = [1, 2, 3];
 foo() ? exprString1 : exprString2;
 >foo() ? exprString1 : exprString2 : string
 >foo() : number
->foo : typeof foo
+>foo : () => number
 >exprString1 : string
 >exprString2 : string

@@ -131,7 +131,7 @@ foo() / array[1] ? exprIsObject1 : exprIsObject2;
 >foo() / array[1] ? exprIsObject1 : exprIsObject2 : Object
 >foo() / array[1] : number
 >foo() : number
->foo : typeof foo
+>foo : () => number
 >array[1] : number
 >array : number[]
 >exprIsObject1 : Object
@@ -230,7 +230,7 @@ var resultIsString3 = foo() ? exprString1 : exprString2;
 >resultIsString3 : string
 >foo() ? exprString1 : exprString2 : string
 >foo() : number
->foo : typeof foo
+>foo : () => number
 >exprString1 : string
 >exprString2 : string

@@ -239,7 +239,7 @@ var resultIsObject3 = foo() / array[1] ? exprIsObject1 : exprIsObject2;
 >foo() / array[1] ? exprIsObject1 : exprIsObject2 : Object
 >foo() / array[1] : number
 >foo() : number
->foo : typeof foo
+>foo : () => number
 >array[1] : number
 >array : number[]
 >exprIsObject1 : Object
@@ -37,7 +37,7 @@ var exprIsObject2: Object;
 >Object : Object

 function foo() { };
->foo : typeof foo
+>foo : () => void

 class C { static doIt: () => void };
 >C : C
@@ -126,7 +126,7 @@ condObject ? exprIsObject1 : exprIsObject2;
 foo() ? exprAny1 : exprAny2;
 >foo() ? exprAny1 : exprAny2 : any
 >foo() : void
->foo : typeof foo
+>foo : () => void
 >exprAny1 : any
 >exprAny2 : any

@@ -254,7 +254,7 @@ var resultIsAny3 = foo() ? exprAny1 : exprAny2;
 >resultIsAny3 : any
 >foo() ? exprAny1 : exprAny2 : any
 >foo() : void
->foo : typeof foo
+>foo : () => void
 >exprAny1 : any
 >exprAny2 : any

@@ -94,7 +94,7 @@ condString ? exprIsObject1 : exprIsObject2;

 //Cond is a string type expression
 function foo() { return "string" };
->foo : typeof foo
+>foo : () => string

 var array = ["1", "2", "3"];
 >array : string[]
@@ -125,7 +125,7 @@ condString + "string" ? exprNumber1 : exprNumber2;
 foo() ? exprString1 : exprString2;
 >foo() ? exprString1 : exprString2 : string
 >foo() : string
->foo : typeof foo
+>foo : () => string
 >exprString1 : string
 >exprString2 : string

@@ -231,7 +231,7 @@ var resultIsString3 = foo() ? exprString1 : exprString2;
 >resultIsString3 : string
 >foo() ? exprString1 : exprString2 : string
 >foo() : string
->foo : typeof foo
+>foo : () => string
 >exprString1 : string
 >exprString2 : string

@@ -1,12 +1,12 @@
 === tests/cases/compiler/conditionallyDuplicateOverloadsCausedByOverloadResolution.ts ===
 declare function foo(func: (x: string, y: string) => any): boolean;
->foo : typeof foo
+>foo : { (func: (x: string, y: string) => any): boolean; (func: (x: string, y: number) => any): string; }
 >func : (x: string, y: string) => any
 >x : string
 >y : string

 declare function foo(func: (x: string, y: number) => any): string;
->foo : typeof foo
+>foo : { (func: (x: string, y: string) => any): boolean; (func: (x: string, y: number) => any): string; }
 >func : (x: string, y: number) => any
 >x : string
 >y : number
@@ -14,7 +14,7 @@ declare function foo(func: (x: string, y: number) => any): string;
 var out = foo((x, y) => {
 >out : boolean
 >foo((x, y) => {    function bar(a: typeof x): void;    function bar(b: typeof y): void;    function bar() { }    return bar;}) : boolean
->foo : typeof foo
+>foo : { (func: (x: string, y: string) => any): boolean; (func: (x: string, y: number) => any): string; }
 >(x, y) => {    function bar(a: typeof x): void;    function bar(b: typeof y): void;    function bar() { }    return bar;} : (x: string, y: string) => { (a: string): void; (b: string): void; }
 >x : string
 >y : string
@@ -38,13 +38,13 @@ var out = foo((x, y) => {
 });

 declare function foo2(func: (x: string, y: string) => any): boolean;
->foo2 : typeof foo2
+>foo2 : { (func: (x: string, y: string) => any): boolean; (func: (x: string, y: number) => any): string; }
 >func : (x: string, y: string) => any
 >x : string
 >y : string

 declare function foo2(func: (x: string, y: number) => any): string;
->foo2 : typeof foo2
+>foo2 : { (func: (x: string, y: string) => any): boolean; (func: (x: string, y: number) => any): string; }
 >func : (x: string, y: number) => any
 >x : string
 >y : number
@@ -52,7 +52,7 @@ declare function foo2(func: (x: string, y: number) => any): string;
 var out2 = foo2((x, y) => {
 >out2 : boolean
 >foo2((x, y) => {    var bar: {        (a: typeof x): void;        (b: typeof y): void;    };    return bar;}) : boolean
->foo2 : typeof foo2
+>foo2 : { (func: (x: string, y: string) => any): boolean; (func: (x: string, y: number) => any): string; }
 >(x, y) => {    var bar: {        (a: typeof x): void;        (b: typeof y): void;    };    return bar;} : (x: string, y: string) => { (a: string): void; (b: string): void; }
 >x : string
 >y : string
@@ -19,27 +19,27 @@ class Derived3 extends Base { biz() { } }
 >biz : () => void

 function foo(tagName: 'canvas'): Derived1;
->foo : typeof foo
+>foo : { (tagName: 'canvas'): Derived1; (tagName: 'div'): Derived2; (tagName: 'span'): Derived3; (tagName: string): Base; }
 >tagName : 'canvas'
 >Derived1 : Derived1

 function foo(tagName:  'div'): Derived2;
->foo : typeof foo
+>foo : { (tagName: 'canvas'): Derived1; (tagName: 'div'): Derived2; (tagName: 'span'): Derived3; (tagName: string): Base; }
 >tagName : 'div'
 >Derived2 : Derived2

 function foo(tagName: 'span'): Derived3;
->foo : typeof foo
+>foo : { (tagName: 'canvas'): Derived1; (tagName: 'div'): Derived2; (tagName: 'span'): Derived3; (tagName: string): Base; }
 >tagName : 'span'
 >Derived3 : Derived3

 function foo(tagName: string): Base;
->foo : typeof foo
+>foo : { (tagName: 'canvas'): Derived1; (tagName: 'div'): Derived2; (tagName: 'span'): Derived3; (tagName: string): Base; }
 >tagName : string
 >Base : Base

 function foo(tagName: any): Base {
->foo : typeof foo
+>foo : { (tagName: 'canvas'): Derived1; (tagName: 'div'): Derived2; (tagName: 'span'): Derived3; (tagName: string): Base; }
 >tagName : any
 >Base : Base

@@ -1,6 +1,6 @@
 === tests/cases/compiler/constraintPropagationThroughReturnTypes.ts ===
 function g<T>(x: T): T {
->g : typeof g
+>g : <T>(x: T) => T
 >T : T
 >x : T
 >T : T
@@ -11,7 +11,7 @@ function g<T>(x: T): T {
 }
 
 function f<S extends { foo: string }>(x: S) {
->f : typeof f
+>f : <S extends { foo: string; }>(x: S) => void
 >S : S
 >foo : string
 >x : S
@@ -20,7 +20,7 @@ function f<S extends { foo: string }>(x: S) {
  var y = g(x);
 >y : S
 >g(x) : S
->g : typeof g
+>g : <T>(x: T) => T
 >x : S

  y;
@@ -2,7 +2,7 @@
 // any is not a valid type argument unless there is no constraint, or the constraint is any

 function foo<T extends String>(x: T): T { return null; }
->foo : typeof foo
+>foo : <T extends String>(x: T) => T
 >T : T
 >String : String
 >x : T
@@ -10,7 +10,7 @@ function foo<T extends String>(x: T): T { return null; }
 >T : T

 function foo2<T extends { x: number }>(x: T): T { return null; }
->foo2 : typeof foo2
+>foo2 : <T extends { x: number; }>(x: T) => T
 >T : T
 >x : number
 >x : T
@@ -19,7 +19,7 @@ function foo2<T extends { x: number }>(x: T): T { return null; }

 //function foo3<T extends T[]>(x: T): T { return null; }
 function foo4<T extends <T>(x: T) => void>(x: T): T { return null; }
->foo4 : typeof foo4
+>foo4 : <T extends <T>(x: T) => void>(x: T) => T
 >T : T
 >T : T
 >x : T
@@ -33,18 +33,18 @@ var a;

 foo(a);
 >foo(a) : any
->foo : typeof foo
+>foo : <T extends String>(x: T) => T
 >a : any

 foo2(a);
 >foo2(a) : any
->foo2 : typeof foo2
+>foo2 : <T extends { x: number; }>(x: T) => T
 >a : any

 //foo3(a);
 foo4(a);
 >foo4(a) : any
->foo4 : typeof foo4
+>foo4 : <T extends <T>(x: T) => void>(x: T) => T
 >a : any

 var b: number;
@@ -52,18 +52,18 @@ var b: number;

 foo<any>(b);
 >foo<any>(b) : any
->foo : typeof foo
+>foo : <T extends String>(x: T) => T
 >b : number

 foo2<any>(b);
 >foo2<any>(b) : any
->foo2 : typeof foo2
+>foo2 : <T extends { x: number; }>(x: T) => T
 >b : number

 //foo3<any>(b);
 foo4<any>(b);
 >foo4<any>(b) : any
->foo4 : typeof foo4
+>foo4 : <T extends <T>(x: T) => void>(x: T) => T
 >b : number

 //function foo5<T extends String, U extends T>(x: T, y: U): T { return null; }
@@ -3,7 +3,7 @@

 // Object constraint
 function foo<T extends Object>(x: T) { }
->foo : typeof foo
+>foo : <T extends Object>(x: T) => void
 >T : T
 >Object : Object
 >x : T
@@ -12,7 +12,7 @@ function foo<T extends Object>(x: T) { }
 var r = foo({});
 >r : void
 >foo({}) : void
->foo : typeof foo
+>foo : <T extends Object>(x: T) => void
 >{} : {}

 var a = {};
@@ -22,7 +22,7 @@ var a = {};
 var r = foo({});
 >r : void
 >foo({}) : void
->foo : typeof foo
+>foo : <T extends Object>(x: T) => void
 >{} : {}

 class C<T extends Object> {
@@ -56,7 +56,7 @@ var i: I<{}>;

 // {} constraint
 function foo2<T extends {}>(x: T) { }
->foo2 : typeof foo2
+>foo2 : <T extends {}>(x: T) => void
 >T : T
 >x : T
 >T : T
@@ -64,7 +64,7 @@ function foo2<T extends {}>(x: T) { }
 var r = foo2({});
 >r : void
 >foo2({}) : void
->foo2 : typeof foo2
+>foo2 : <T extends {}>(x: T) => void
 >{} : {}

 var a = {};
@@ -74,7 +74,7 @@ var a = {};
 var r = foo2({});
 >r : void
 >foo2({}) : void
->foo2 : typeof foo2
+>foo2 : <T extends {}>(x: T) => void
 >{} : {}

 class C2<T extends {}> {
@@ -20,7 +20,7 @@ module Test {
    }
 
 export function F(func: MyFunc) { }
->F : typeof F
+>F : (func: MyFunc) => void
 >func : MyFunc
 >MyFunc : MyFunc
 }
@@ -31,9 +31,9 @@ var func: Test.MyFunc;

 Test.F(func); // OK
 >Test.F(func) : void
->Test.F : typeof Test.F
+>Test.F : (func: Test.MyFunc) => void
 >Test : typeof Test
->F : typeof Test.F
+>F : (func: Test.MyFunc) => void
 >func : Test.MyFunc

 var test = new Test.MyClass(func); // Should be OK
@@ -1,6 +1,6 @@
 === tests/cases/compiler/contextualSigInstantiationRestParams.ts ===
 declare function toInstantiate<A, B>(a?: A, b?: B): B;
->toInstantiate : typeof toInstantiate
+>toInstantiate : <A, B>(a?: A, b?: B) => B
 >A : A
 >B : B
 >a : A
@@ -10,11 +10,11 @@ declare function toInstantiate<A, B>(a?: A, b?: B): B;
 >B : B

 declare function contextual(...s: string[]): string
->contextual : typeof contextual
+>contextual : (...s: string[]) => string
 >s : string[]

 var sig: typeof contextual = toInstantiate;
->sig : typeof contextual
->contextual : typeof contextual
->toInstantiate : typeof toInstantiate
+>sig : (...s: string[]) => string
+>contextual : (...s: string[]) => string
+>toInstantiate : <A, B>(a?: A, b?: B) => B

@@ -1,6 +1,6 @@
 === tests/cases/compiler/contextualSignatureInstantiation1.ts ===
 declare function map<S, T>(f: (x: S) => T): (a: S[]) => T[];
->map : typeof map
+>map : <S, T>(f: (x: S) => T) => (a: S[]) => T[]
 >S : S
 >T : T
 >f : (x: S) => T
@@ -25,11 +25,11 @@ var e = <K>(x: string, y?: K) => x.length;
 var r99 = map(e); // should be {}[] for S since a generic lambda is not inferentially typed
 >r99 : (a: {}[]) => number[]
 >map(e) : (a: {}[]) => number[]
->map : typeof map
+>map : <S, T>(f: (x: S) => T) => (a: S[]) => T[]
 >e : <K>(x: string, y?: K) => number

 declare function map2<S extends { length: number }, T>(f: (x: S) => T): (a: S[]) => T[];
->map2 : typeof map2
+>map2 : <S extends { length: number; }, T>(f: (x: S) => T) => (a: S[]) => T[]
 >S : S
 >length : number
 >T : T
@@ -55,6 +55,6 @@ var e2 = <K>(x: string, y?: K) => x.length;
 var r100 = map2(e2); // type arg inference should fail for S since a generic lambda is not inferentially typed. Falls back to { length: number }
 >r100 : (a: { length: number; }[]) => number[]
 >map2(e2) : (a: { length: number; }[]) => number[]
->map2 : typeof map2
+>map2 : <S extends { length: number; }, T>(f: (x: S) => T) => (a: S[]) => T[]
 >e2 : <K>(x: string, y?: K) => number

@@ -1,6 +1,6 @@
 === tests/cases/compiler/contextualSignatureInstantiation3.ts ===
 function map<T, U>(items: T[], f: (x: T) => U): U[]{
->map : typeof map
+>map : <T, U>(items: T[], f: (x: T) => U) => U[]
 >T : T
 >U : U
 >items : T[]
@@ -20,7 +20,7 @@ function map<T, U>(items: T[], f: (x: T) => U): U[]{
 }

 function identity<T>(x: T) {
->identity : typeof identity
+>identity : <T>(x: T) => T
 >T : T
 >x : T
 >T : T
@@ -30,7 +30,7 @@ function identity<T>(x: T) {
 }

 function singleton<T>(x: T) {
->singleton : typeof singleton
+>singleton : <T>(x: T) => T[]
 >T : T
 >x : T
 >T : T
@@ -54,14 +54,14 @@ var v1 = xs.map(identity);      // Error if not number[]
 >xs.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >xs : number[]
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->identity : typeof identity
+>identity : <T>(x: T) => T

 var v1 = map(xs, identity);     // Error if not number[]
 >v1 : number[]
 >map(xs, identity) : number[]
->map : typeof map
+>map : <T, U>(items: T[], f: (x: T) => U) => U[]
 >xs : number[]
->identity : typeof identity
+>identity : <T>(x: T) => T

 var v2: number[][];         
 >v2 : number[][]
@@ -72,12 +72,12 @@ var v2 = xs.map(singleton);     // Error if not number[][]
 >xs.map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >xs : number[]
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
->singleton : typeof singleton
+>singleton : <T>(x: T) => T[]

 var v2 = map(xs, singleton);    // Error if not number[][]
 >v2 : number[][]
 >map(xs, singleton) : number[][]
->map : typeof map
+>map : <T, U>(items: T[], f: (x: T) => U) => U[]
 >xs : number[]
->singleton : typeof singleton
+>singleton : <T>(x: T) => T[]

@@ -1,6 +1,6 @@
 === tests/cases/compiler/contextualSignatureInstantiationWithTypeParameterConstrainedToOuterTypeParameter.ts ===
 function f<T>() {
->f : typeof f
+>f : <T>() => <U extends T>(u: U) => U
 >T : T

    function g<U extends T>(u: U): U { return null }
@@ -31,5 +31,5 @@ var x = h("", f<string>()); // Call should succeed and x should be string. All t
 >h("", f<string>()) : string
 >h : <V, W>(v: V, func: (v: V) => W) => W
 >f<string>() : <U extends string>(u: U) => U
->f : typeof f
+>f : <T>() => <U extends T>(u: U) => U

@@ -1,6 +1,6 @@
 === tests/cases/compiler/contextualTypeAppliedToVarArgs.ts ===
 function delegate(instance: any, method: (...args: any[]) => any, data?: any): (...args: any[]) => any {
->delegate : typeof delegate
+>delegate : (instance: any, method: (...args: any[]) => any, data?: any) => (...args: any[]) => any
 >instance : any
 >method : (...args: any[]) => any
 >args : any[]
@@ -20,7 +20,7 @@ class Foo{

        delegate(this, function (source, args2)
 >delegate(this, function (source, args2)        {            var a = source.node;            var b = args2.node;        } ) : (...args: any[]) => any
->delegate : typeof delegate
+>delegate : (instance: any, method: (...args: any[]) => any, data?: any) => (...args: any[]) => any
 >this : Foo
 >function (source, args2)        {            var a = source.node;            var b = args2.node;        } : (source: any, args2: any) => void
 >source : any
@@ -1,10 +1,10 @@
 === tests/cases/compiler/contextualTyping25.ts ===
 function foo(param:{id:number;}){}; foo(<{id:number;}>({}));
->foo : typeof foo
+>foo : (param: { id: number; }) => void
 >param : { id: number; }
 >id : number
 >foo(<{id:number;}>({})) : void
->foo : typeof foo
+>foo : (param: { id: number; }) => void
 ><{id:number;}>({}) : { id: number; }
 >id : number
 >({}) : {}
@@ -1,10 +1,10 @@
 === tests/cases/compiler/contextualTyping26.ts ===
 function foo(param:{id:number;}){}; foo(<{id:number;}>({}));
->foo : typeof foo
+>foo : (param: { id: number; }) => void
 >param : { id: number; }
 >id : number
 >foo(<{id:number;}>({})) : void
->foo : typeof foo
+>foo : (param: { id: number; }) => void
 ><{id:number;}>({}) : { id: number; }
 >id : number
 >({}) : {}
@@ -1,10 +1,10 @@
 === tests/cases/compiler/contextualTyping27.ts ===
 function foo(param:{id:number;}){}; foo(<{id:number;}>({}));
->foo : typeof foo
+>foo : (param: { id: number; }) => void
 >param : { id: number; }
 >id : number
 >foo(<{id:number;}>({})) : void
->foo : typeof foo
+>foo : (param: { id: number; }) => void
 ><{id:number;}>({}) : { id: number; }
 >id : number
 >({}) : {}
@@ -1,8 +1,8 @@
 === tests/cases/compiler/contextualTyping28.ts ===
 function foo(param:number[]){}; foo([1]);
->foo : typeof foo
+>foo : (param: number[]) => void
 >param : number[]
 >foo([1]) : void
->foo : typeof foo
+>foo : (param: number[]) => void
 >[1] : number[]

@@ -1,8 +1,8 @@
 === tests/cases/compiler/contextualTyping29.ts ===
 function foo(param:number[]){}; foo([1, 3]);
->foo : typeof foo
+>foo : (param: number[]) => void
 >param : number[]
 >foo([1, 3]) : void
->foo : typeof foo
+>foo : (param: number[]) => void
 >[1, 3] : number[]

@@ -1,8 +1,8 @@
 === tests/cases/compiler/contextualTyping31.ts ===
 function foo(param:number[]){}; foo([1]);
->foo : typeof foo
+>foo : (param: number[]) => void
 >param : number[]
 >foo([1]) : void
->foo : typeof foo
+>foo : (param: number[]) => void
 >[1] : number[]

@@ -1,10 +1,10 @@
 === tests/cases/compiler/contextualTyping32.ts ===
 function foo(param: {():number; (i:number):number; }[]) { }; foo([function(){return 1;}, function(){return 4}]);
->foo : typeof foo
+>foo : (param: { (): number; (i: number): number; }[]) => void
 >param : { (): number; (i: number): number; }[]
 >i : number
 >foo([function(){return 1;}, function(){return 4}]) : void
->foo : typeof foo
+>foo : (param: { (): number; (i: number): number; }[]) => void
 >[function(){return 1;}, function(){return 4}] : { (): number; (i: number): number; }[]
 >function(){return 1;} : () => number
 >function(){return 4} : () => number
@@ -1,6 +1,6 @@
 === tests/cases/compiler/contextualTypingTwoInstancesOfSameTypeParameter.ts ===
 function f6<T>(x: (a: T) => T) {
->f6 : typeof f6
+>f6 : <T>(x: (a: T) => T) => any
 >T : T
 >x : (a: T) => T
 >a : T
@@ -11,11 +11,11 @@ function f6<T>(x: (a: T) => T) {
 } 
 f6(x => f6(y => x = y));
 >f6(x => f6(y => x = y)) : any
->f6 : typeof f6
+>f6 : <T>(x: (a: T) => T) => any
 >x => f6(y => x = y) : (x: {}) => any
 >x : {}
 >f6(y => x = y) : any
->f6 : typeof f6
+>f6 : <T>(x: (a: T) => T) => any
 >y => x = y : (y: {}) => {}
 >y : {}
 >x = y : {}
@@ -56,7 +56,7 @@ var declare = 0;
 >declare : number

 function bigGeneric<
->bigGeneric : typeof bigGeneric
+>bigGeneric : <constructor, implements, interface, let, module, package, private, protected, public, set, static, get, yield, declare>(c: constructor, a: any, b2: boolean, i: implements, i2: interface, l: let, m: module, n: number, p: package, p2: private, p3: protected, p4: public, s: set, s2: static, s3: string, g: get, y: yield, d: declare) => void

    constructor,
 >constructor : constructor
@@ -17,7 +17,7 @@ module M {
 >X : X

    export function f(y:Y) { }
->f : typeof f
+>f : (y: Y) => void
 >y : Y
 >Y : Y

@@ -27,7 +27,7 @@ module M {

    f({x:a}); // ok
 >f({x:a}) : void
->f : typeof f
+>f : (y: Y) => void
 >{x:a} : { x: X; }
 >x : X
 >a : X
@@ -38,7 +38,7 @@ module M {

    f({x:b}); // ok covariant subtype
 >f({x:b}) : void
->f : typeof f
+>f : (y: Y) => void
 >{x:b} : { x: XX; }
 >x : XX
 >b : XX
@@ -22,7 +22,7 @@ class CreateCopyOfWorkItemDialog {
    }
 }
 function createWorkItemDialog<P0>(dialogType: P0) {
->createWorkItemDialog : typeof createWorkItemDialog
+>createWorkItemDialog : <P0>(dialogType: P0) => void
 >P0 : P0
 >dialogType : P0
 >P0 : P0
@@ -35,7 +35,7 @@ class WITDialogs {

        createWorkItemDialog(CreateCopyOfWorkItemDialog);
 >createWorkItemDialog(CreateCopyOfWorkItemDialog) : void
->createWorkItemDialog : typeof createWorkItemDialog
+>createWorkItemDialog : <P0>(dialogType: P0) => void
 >CreateCopyOfWorkItemDialog : typeof CreateCopyOfWorkItemDialog
    }
 }
@@ -2,7 +2,7 @@
 debugger;

 function foo() {
->foo : typeof foo
+>foo : () => void

    debugger;

@@ -2,11 +2,11 @@

 /** This comment should appear for foo*/
 export function foo() {
->foo : typeof foo
+>foo : () => void
 }
 /** This is comment for function signature*/
 export function fooWithParameters(/** this is comment about a*/a: string,
->fooWithParameters : typeof fooWithParameters
+>fooWithParameters : (a: string, b: number) => void
 >a : string

    /** this is comment for b*/
@@ -18,7 +18,7 @@ export function fooWithParameters(/** this is comment about a*/a: string,
 >a : string
 }
 export function fooWithRestParameters(a: string, ...rests: string[]) {
->fooWithRestParameters : typeof fooWithRestParameters
+>fooWithRestParameters : (a: string, ...rests: string[]) => string
 >a : string
 >rests : string[]

@@ -32,15 +32,15 @@ export function fooWithRestParameters(a: string, ...rests: string[]) {
 }

 export function fooWithOverloads(a: string): string;
->fooWithOverloads : typeof fooWithOverloads
+>fooWithOverloads : { (a: string): string; (a: number): number; }
 >a : string

 export function fooWithOverloads(a: number): number;
->fooWithOverloads : typeof fooWithOverloads
+>fooWithOverloads : { (a: string): string; (a: number): number; }
 >a : number

 export function fooWithOverloads(a: any): any {
->fooWithOverloads : typeof fooWithOverloads
+>fooWithOverloads : { (a: string): string; (a: number): number; }
 >a : any

    return a;
@@ -49,11 +49,11 @@ export function fooWithOverloads(a: any): any {

 /** This comment should appear for nonExportedFoo*/
 function nonExportedFoo() {
->nonExportedFoo : typeof nonExportedFoo
+>nonExportedFoo : () => void
 }
 /** This is comment for function signature*/
 function nonExportedFooWithParameters(/** this is comment about a*/a: string,
->nonExportedFooWithParameters : typeof nonExportedFooWithParameters
+>nonExportedFooWithParameters : (a: string, b: number) => void
 >a : string

    /** this is comment for b*/
@@ -65,7 +65,7 @@ function nonExportedFooWithParameters(/** this is comment about a*/a: string,
 >a : string
 }
 function nonExportedFooWithRestParameters(a: string, ...rests: string[]) {
->nonExportedFooWithRestParameters : typeof nonExportedFooWithRestParameters
+>nonExportedFooWithRestParameters : (a: string, ...rests: string[]) => string
 >a : string
 >rests : string[]

@@ -79,15 +79,15 @@ function nonExportedFooWithRestParameters(a: string, ...rests: string[]) {
 }

 function nonExportedFooWithOverloads(a: string): string;
->nonExportedFooWithOverloads : typeof nonExportedFooWithOverloads
+>nonExportedFooWithOverloads : { (a: string): string; (a: number): number; }
 >a : string

 function nonExportedFooWithOverloads(a: number): number;
->nonExportedFooWithOverloads : typeof nonExportedFooWithOverloads
+>nonExportedFooWithOverloads : { (a: string): string; (a: number): number; }
 >a : number

 function nonExportedFooWithOverloads(a: any): any {
->nonExportedFooWithOverloads : typeof nonExportedFooWithOverloads
+>nonExportedFooWithOverloads : { (a: string): string; (a: number): number; }
 >a : any

    return a;
@@ -97,11 +97,11 @@ function nonExportedFooWithOverloads(a: any): any {
 === tests/cases/compiler/declFileFunctions_1.ts ===
 /** This comment should appear for foo*/
 function globalfoo() {
->globalfoo : typeof globalfoo
+>globalfoo : () => void
 }
 /** This is comment for function signature*/
 function globalfooWithParameters(/** this is comment about a*/a: string,
->globalfooWithParameters : typeof globalfooWithParameters
+>globalfooWithParameters : (a: string, b: number) => void
 >a : string

    /** this is comment for b*/
@@ -113,7 +113,7 @@ function globalfooWithParameters(/** this is comment about a*/a: string,
 >a : string
 }
 function globalfooWithRestParameters(a: string, ...rests: string[]) {
->globalfooWithRestParameters : typeof globalfooWithRestParameters
+>globalfooWithRestParameters : (a: string, ...rests: string[]) => string
 >a : string
 >rests : string[]

@@ -126,15 +126,15 @@ function globalfooWithRestParameters(a: string, ...rests: string[]) {
 >join : (separator?: string) => string
 }
 function globalfooWithOverloads(a: string): string;
->globalfooWithOverloads : typeof globalfooWithOverloads
+>globalfooWithOverloads : { (a: string): string; (a: number): number; }
 >a : string

 function globalfooWithOverloads(a: number): number;
->globalfooWithOverloads : typeof globalfooWithOverloads
+>globalfooWithOverloads : { (a: string): string; (a: number): number; }
 >a : number

 function globalfooWithOverloads(a: any): any {
->globalfooWithOverloads : typeof globalfooWithOverloads
+>globalfooWithOverloads : { (a: string): string; (a: number): number; }
 >a : any

    return a;
@@ -10,7 +10,7 @@ export module C {
 >B : B
    
    export function F<T>(x: T): A<B> { return null; }
->F : typeof F
+>F : <T>(x: T) => A<B>
 >T : T
 >x : T
 >T : T
@@ -18,7 +18,7 @@ export module C {
 >B : B

    export function F2<T>(x: T): C.A<C.B> { return null; }
->F2 : typeof F2
+>F2 : <T>(x: T) => A<B>
 >T : T
 >x : T
 >T : T
@@ -28,7 +28,7 @@ export module C {
 >B : B

    export function F3<T>(x: T): C.A<C.B>[] { return null; }
->F3 : typeof F3
+>F3 : <T>(x: T) => A<B>[]
 >T : T
 >x : T
 >T : T
@@ -38,7 +38,7 @@ export module C {
 >B : B

    export function F4<T extends A<B>>(x: T): Array<C.A<C.B>> { return null; }
->F4 : typeof F4
+>F4 : <T extends A<B>>(x: T) => A<B>[]
 >T : T
 >A : A<T>
 >B : B
@@ -51,12 +51,12 @@ export module C {
 >B : B

    export function F5<T>(): T { return null; }
->F5 : typeof F5
+>F5 : <T>() => T
 >T : T
 >T : T

    export function F6<T extends A<B>>(x: T): T { return null; }
->F6 : typeof F6
+>F6 : <T extends A<B>>(x: T) => T
 >T : T
 >A : A<T>
 >B : B
@@ -83,28 +83,28 @@ export var a: C.A<C.B>;
 >B : C.B

 export var b = C.F;
->b : typeof C.F
->C.F : typeof C.F
+>b : <T>(x: T) => C.A<C.B>
+>C.F : <T>(x: T) => C.A<C.B>
 >C : typeof C
->F : typeof C.F
+>F : <T>(x: T) => C.A<C.B>

 export var c = C.F2;
->c : typeof C.F2
->C.F2 : typeof C.F2
+>c : <T>(x: T) => C.A<C.B>
+>C.F2 : <T>(x: T) => C.A<C.B>
 >C : typeof C
->F2 : typeof C.F2
+>F2 : <T>(x: T) => C.A<C.B>

 export var d = C.F3;
->d : typeof C.F3
->C.F3 : typeof C.F3
+>d : <T>(x: T) => C.A<C.B>[]
+>C.F3 : <T>(x: T) => C.A<C.B>[]
 >C : typeof C
->F3 : typeof C.F3
+>F3 : <T>(x: T) => C.A<C.B>[]

 export var e = C.F4;
->e : typeof C.F4
->C.F4 : typeof C.F4
+>e : <T extends C.A<C.B>>(x: T) => C.A<C.B>[]
+>C.F4 : <T extends C.A<C.B>>(x: T) => C.A<C.B>[]
 >C : typeof C
->F4 : typeof C.F4
+>F4 : <T extends C.A<C.B>>(x: T) => C.A<C.B>[]

 export var x = (new C.D<C.A<C.B>>(new C.A<C.B>())).val;
 >x : C.A<C.B>
@@ -127,7 +127,7 @@ export var x = (new C.D<C.A<C.B>>(new C.A<C.B>())).val;
 >val : C.A<C.B>

 export function f<T extends C.A<C.B>>() { }
->f : typeof f
+>f : <T extends C.A<C.B>>() => void
 >T : T
 >C : unknown
 >A : C.A<T>
@@ -137,9 +137,9 @@ export function f<T extends C.A<C.B>>() { }
 export var g = C.F5<C.A<C.B>>();
 >g : C.A<C.B>
 >C.F5<C.A<C.B>>() : C.A<C.B>
->C.F5 : typeof C.F5
+>C.F5 : <T>() => T
 >C : typeof C
->F5 : typeof C.F5
+>F5 : <T>() => T
 >C : unknown
 >A : C.A<T>
 >C : unknown
@@ -160,8 +160,8 @@ export interface i extends C.A<C.B> { }
 >B : C.B

 export var j = C.F6;
->j : typeof C.F6
->C.F6 : typeof C.F6
+>j : <T extends C.A<C.B>>(x: T) => T
+>C.F6 : <T extends C.A<C.B>>(x: T) => T
 >C : typeof C
->F6 : typeof C.F6
+>F6 : <T extends C.A<C.B>>(x: T) => T

--- a/Show More
+++ b/Show More