Truncate long types in error messages

src/compiler/checker.ts

@@ -943,20 +943,36 @@ module ts {
             writer.write(symbolToString(symbol, enclosingDeclaration, meaning));
         }
 
-        function createSingleLineTextWriter() {
+        function createSingleLineTextWriter(maxLength?: number) {
             var result = "";
+            var overflow = false;
+            function write(s: string) {
+                if (!overflow) {
+                    result += s;
+                    if (result.length > maxLength) {
+                        result = result.substr(0, maxLength - 3) + "...";
+                        overflow = true;
+                    }
+                }
+            }
             return {
-                write(s: string) { result += s; },
-                writeSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) { writeSymbolToTextWriter(symbol, enclosingDeclaration, meaning, this); },
-                writeLine() { result += " "; },
+                write: write,
+                writeSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) {
+                    writeSymbolToTextWriter(symbol, enclosingDeclaration, meaning, this);
+                },
+                writeLine() {
+                    write(" ");
+                },
                 increaseIndent() { },
                 decreaseIndent() { },
-                getText() { return result; }
+                getText() {
+                    return result;
+                }
             };
         }
 
         function typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string {
-            var stringWriter = createSingleLineTextWriter();
+            var stringWriter = createSingleLineTextWriter(flags & TypeFormatFlags.NoTruncation ? undefined : 100);
             // TODO(shkamat): typeToString should take enclosingDeclaration as input, once we have implemented enclosingDeclaration
             writeTypeToTextWriter(type, enclosingDeclaration, flags, stringWriter);
             return stringWriter.getText();

src/compiler/types.ts

@@ -631,12 +631,10 @@ module ts {
     }
 
     export enum TypeFormatFlags {
-        None                        = 0x00000000, 
-
-        /** writes Array<T> instead T[]  */
-        WriteArrayAsGenericType     = 0x00000001,  // Declarations
-
-        UseTypeOfFunction           = 0x00000002,  // instead of writing signature type of function use typeof
+        None                    = 0x00000000, 
+        WriteArrayAsGenericType = 0x00000001,  // Write Array<T> instead T[]
+        UseTypeOfFunction       = 0x00000002,  // Write typeof instead of function type literal
+        NoTruncation            = 0x00000004,  // Don't truncate typeToString result
     }
 
     export enum SymbolAccessibility {

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.None)
+            type: this.checker.typeToString(type, node.parent, ts.TypeFormatFlags.NoTruncation)
         });
     }