Get the JSDoc comments for the symbols

This also fixed type formatting for single function signatures in the types

Author: sheetalkamat

src/compiler/checker.ts

@@ -1243,13 +1243,13 @@ module ts {
 
                     if (allowFunctionOrConstructorTypeLiteral) {
                         if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) {
-                            writeSignature(resolved.callSignatures[0], /*arrowStyle*/ true);
+                            writeSignature(resolved.callSignatures[0], shouldTypeBeAllowStyleTypeLiteral());
                             return;
                         }
                         if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) {
                             writeKeyword(writer, SyntaxKind.NewKeyword);
                             writeSpace(writer);
-                            writeSignature(resolved.constructSignatures[0], /*arrowStyle*/ true);
+                            writeSignature(resolved.constructSignatures[0], shouldTypeBeAllowStyleTypeLiteral());
                             return;
                         }
                     }
@@ -1328,6 +1328,11 @@ module ts {
                 }
                 writer.decreaseIndent();
                 writePunctuation(writer, SyntaxKind.CloseBraceToken);
+
+                function shouldTypeBeAllowStyleTypeLiteral() {
+                    return !typeStack || typeStack.length !== 1 || typeStack[0] !== type || // If this is not a top level type we are writing, arrowStyle is ok
+                        !(flags & TypeFormatFlags.NoArrowStyleTopLevelSignature);
+                }
             }
 
             function writeSignature(signature: Signature, arrowStyle?: boolean) {

src/compiler/types.ts

@@ -673,6 +673,7 @@ module ts {
         WriteArrayAsGenericType = 0x00000001,  // Write Array<T> instead T[]
         UseTypeOfFunction       = 0x00000002,  // Write typeof instead of function type literal
         NoTruncation            = 0x00000004,  // Don't truncate typeToString result
+        NoArrowStyleTopLevelSignature = 0x00000008, // Do not write type global top level function or constructor literal
     }
 
     export enum SymbolAccessibility {

src/harness/fourslash.ts

@@ -772,35 +772,35 @@ module FourSlash {
             var actualQuickInfoSymbolName = actualQuickInfo ? actualQuickInfo.fullSymbolName : "";
             var actualQuickInfoKind = actualQuickInfo ? actualQuickInfo.kind : "";
 
-            function assertionMessage(name: string, actualValue: string, expectedValue: string) {
-                return "\nActual " + name + ":\n\t" + actualValue + "\nExpected value:\n\t" + expectedValue;
+            function assertionMessage(msg: string) {
+                return "\nMarker: " + currentTestState.lastKnownMarker + "\nChecking: " + msg + "\n\n";
             }
 
             if (negative) {
                 if (expectedTypeName !== undefined) {
-                    assert.notEqual(actualQuickInfoMemberName, expectedTypeName, assertionMessage("quick info member name", actualQuickInfoMemberName, expectedTypeName));
+                    assert.notEqual(actualQuickInfoMemberName, expectedTypeName, assertionMessage("quick info member name"));
                 }
                 if (docComment != undefined) {
-                    assert.notEqual(actualQuickInfoDocComment, docComment, assertionMessage("quick info doc comment", actualQuickInfoDocComment, docComment));
+                    assert.notEqual(actualQuickInfoDocComment, docComment, assertionMessage("quick info doc comment"));
                 }
                 if (symbolName !== undefined) {
-                    assert.notEqual(actualQuickInfoSymbolName, symbolName, assertionMessage("quick info symbol name", actualQuickInfoSymbolName, symbolName));
+                    assert.notEqual(actualQuickInfoSymbolName, symbolName, assertionMessage("quick info symbol name"));
                 }
                 if (kind !== undefined) {
-                    assert.notEqual(actualQuickInfoKind, kind, assertionMessage("quick info kind", actualQuickInfoKind, kind));
+                    assert.notEqual(actualQuickInfoKind, kind, assertionMessage("quick info kind"));
                 }
             } else {
                 if (expectedTypeName !== undefined) {
-                    assert.equal(actualQuickInfoMemberName, expectedTypeName, assertionMessage("quick info member", actualQuickInfoMemberName, expectedTypeName));
+                    assert.equal(actualQuickInfoMemberName, expectedTypeName, assertionMessage("quick info member"));
                 }
                 if (docComment != undefined) {
-                    assert.equal(actualQuickInfoDocComment, docComment, assertionMessage("quick info doc", actualQuickInfoDocComment, docComment));
+                    assert.equal(actualQuickInfoDocComment, docComment, assertionMessage("quick info doc"));
                 }
                 if (symbolName !== undefined) {
-                    assert.equal(actualQuickInfoSymbolName, symbolName, assertionMessage("quick info symbol name", actualQuickInfoSymbolName, symbolName));
+                    assert.equal(actualQuickInfoSymbolName, symbolName, assertionMessage("quick info symbol name"));
                 }
                 if (kind !== undefined) {
-                    assert.equal(actualQuickInfoKind, kind, assertionMessage("quick info kind", actualQuickInfoKind, kind));
+                    assert.equal(actualQuickInfoKind, kind, assertionMessage("quick info kind"));
                 }
             }
         }