Don't use UseTypeOfFunction in typeWriter

Author: JsonFreeman

src/harness/typeWriter.ts

@@ -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)
         });
     }
 

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.types

@@ -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
     }
 }

tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.types

@@ -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

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.types

@@ -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

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.types

@@ -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

tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.types

@@ -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; }

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.types

@@ -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 };

tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.types

@@ -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

tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.types

@@ -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 };

tests/baselines/reference/additionOperatorWithAnyAndEveryType.types

@@ -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