Move the symbol classification and display parts writing to the Services and format the newlines correctly

Author: sheetalkamat

src/compiler/checker.ts

@@ -23,34 +23,32 @@ module ts {
         return undefined;
     }
 
-    interface SymbolWriter {
-        writeKind(text: string, kind: SymbolDisplayPartKind): void;
-        writeSymbol(text: string, symbol: Symbol): void;
-        writeLine(): void;
-        increaseIndent(): void;
-        decreaseIndent(): void;
-        clear(): void;
-
-        // Called when the symbol writer encounters a symbol to write.  Currently only used by the
-        // declaration emitter to help determine if it should patch up the final declaration file
-        // with import statements it previously saw (but chose not to emit).
-        trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
+    export interface StringSymbolWriter extends SymbolWriter {
+        string(): string;
     }
 
-    interface DisplayPartsSymbolWriter extends SymbolWriter {
-        displayParts(): SymbolDisplayPart[];
-    }
+    // Pool writers to avoid needing to allocate them for every symbol we write.
+    var stringWriters: StringSymbolWriter[] = [];
+    export function getSingleLineStringWriter(): StringSymbolWriter {
+        if (stringWriters.length == 0) {
+            var str = "";
 
-    interface StringSymbolWriter extends SymbolWriter {
-        string(): string;
-    }
+            return {
+                string: () => str,
+                writeKind: text => str += text,
+                writeSymbol: text => str += text,
+
+                // Completely ignore indentation for string writers.  And map newlines to
+                // a single space.
+                writeLine: () => str += " ",
+                increaseIndent: () => { },
+                decreaseIndent: () => { },
+                clear: () => str = "",
+                trackSymbol: () => { }
+            };
+        }
 
-    // TODO this should go back in services
-    export function getSymbolDisplayPart(text: string, kind: SymbolDisplayPartKind, symbol?: Symbol): SymbolDisplayPart {
-        return <SymbolDisplayPart> {
-            text: text,
-            kind: kind
-        };
+        return stringWriters.pop();
     }
 
     /// fullTypeCheck denotes if this instance of the typechecker will be used to get semantic diagnostics.
@@ -92,9 +90,9 @@ module ts {
             getTypeOfNode: getTypeOfNode,
             getApparentType: getApparentType,
             typeToString: typeToString,
-            typeToDisplayParts: typeToDisplayParts,
+            writeType: writeType,
             symbolToString: symbolToString,
-            symbolToDisplayParts: symbolToDisplayParts,
+            writeSymbol: writeSymbol,
             getAugmentedPropertiesOfApparentType: getAugmentedPropertiesOfApparentType,
             getRootSymbol: getRootSymbol,
             getContextualType: getContextualType,
@@ -930,58 +928,6 @@ module ts {
                 { accessibility: SymbolAccessibility.NotAccessible, errorSymbolName: firstIdentifierName };
         }
 
-        // Pool writers to avoid needing to allocate them for every symbol we write.
-        var displayPartWriters: DisplayPartsSymbolWriter[] = [];
-        var stringWriters: StringSymbolWriter[] = [];
-
-        function getDisplayPartWriter(): DisplayPartsSymbolWriter {
-            if (displayPartWriters.length == 0) {
-                var displayParts: SymbolDisplayPart[] = [];
-                return {
-                    displayParts: () => displayParts,
-                    writeKind: (text, kind) => displayParts.push(getSymbolDisplayPart(text, kind)),
-                    writeSymbol: (text, symbol) => displayParts.push(symbolPart(text, symbol)),
-
-                    // Completely ignore indentation for display part writers.  And map newlines to
-                    // a single space.
-                    writeLine: () => displayParts.push(spacePart()),
-                    increaseIndent: () => { },
-                    decreaseIndent: () => { },
-                    clear: () => displayParts = [],
-                    trackSymbol: () => { }
-                };
-            }
-
-            return displayPartWriters.pop();
-        }
-
-        function getStringWriter(): StringSymbolWriter {
-            if (stringWriters.length == 0) {
-                var str = "";
-
-                return {
-                    string: () => str,
-                    writeKind: text => str += text,
-                    writeSymbol: text => str += text,
-
-                    // Completely ignore indentation for string writers.  And map newlines to
-                    // a single space.
-                    writeLine: () => str += " ",
-                    increaseIndent: () => { },
-                    decreaseIndent: () => { },
-                    clear: () => str = "",
-                    trackSymbol: () => { }
-                };
-            }
-
-            return stringWriters.pop();
-        }
-
-        function releaseDisplayPartWriter(writer: DisplayPartsSymbolWriter) {
-            writer.clear();
-            displayPartWriters.push(writer);
-        }
-
         function releaseStringWriter(writer: StringSymbolWriter) {
             writer.clear()
             stringWriters.push(writer);
@@ -1004,7 +950,7 @@ module ts {
         }
 
         function symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string {
-            var writer = getStringWriter();
+            var writer = getSingleLineStringWriter();
             writeSymbol(symbol, writer, enclosingDeclaration, meaning);
 
             var result = writer.string();
@@ -1013,16 +959,6 @@ module ts {
             return result;
         }
 
-        function symbolToDisplayParts(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): SymbolDisplayPart[] {
-            var writer = getDisplayPartWriter();
-            writeSymbol(symbol, writer, enclosingDeclaration, meaning);
-
-            var result = writer.displayParts();
-            releaseDisplayPartWriter(writer);
-
-            return result;
-        }
-
         // Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
         // Meaning needs to be specified if the enclosing declaration is given
         function writeSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags): void {
@@ -1099,12 +1035,8 @@ module ts {
             return writeSymbolName(symbol);
         }
 
-        function writeSymbolToTextWriter(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags, writer: TextWriter) {
-            writer.write(symbolToString(symbol, enclosingDeclaration, meaning));
-        }
-
         function typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string {
-            var writer = getStringWriter();
+            var writer = getSingleLineStringWriter();
             writeType(type, writer, enclosingDeclaration, flags);
 
             var result = writer.string();
@@ -1118,16 +1050,6 @@ module ts {
             return result;
         }
 
-        function typeToDisplayParts(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[] {
-            var writer = getDisplayPartWriter();
-            writeType(type, writer, enclosingDeclaration, flags);
-
-            var result = writer.displayParts();
-            releaseDisplayPartWriter(writer);
-
-            return result;
-        }
-
         function writeType(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) {
             var typeStack: Type[];
             return writeType(type, /*allowFunctionOrConstructorTypeLiteral*/ true);
@@ -7620,34 +7542,17 @@ module ts {
             return undefined;
         }
 
-        // Create a single instance that we can wrap the underlying emitter TextWriter with.  That
-        // way we don't have to allocate a new wrapper every time writeTypeAtLocation and 
-        // writeReturnTypeOfSignatureDeclaration are called.
-        var emitSymbolWriter = {
-            writer: <TextWriter>undefined,
-
-            writeKind: function (text: string) { this.writer.write(text) },
-            writeSymbol: function (text: string) { this.writer.write(text) },
-            writeLine: function () { this.writer.writeLine() },
-            increaseIndent: function () { this.writer.increaseIndent() },
-            decreaseIndent: function () { this.writer.decreaseIndent() },
-            clear: function () { },
-            trackSymbol: function (symbol: Symbol, declaration: Node, meaning: SymbolFlags) { this.writer.trackSymbol(symbol, declaration, meaning) }
-        };
-
-        function writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: TextWriter) {
+        function writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) {
             // Get type of the symbol if this is the valid symbol otherwise get type at location
             var symbol = getSymbolOfNode(location);
             var type = symbol && !(symbol.flags & SymbolFlags.TypeLiteral) ? getTypeOfSymbol(symbol) : getTypeFromTypeNode(location);
 
-            emitSymbolWriter.writer = writer;
-            writeType(type, emitSymbolWriter, enclosingDeclaration, flags);
+            writeType(type, writer, enclosingDeclaration, flags);
         }
 
-        function writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: TextWriter) {
+        function writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) {
             var signature = getSignatureFromDeclaration(signatureDeclaration);
-            emitSymbolWriter.writer = writer;
-            writeType(getReturnTypeOfSignature(signature), emitSymbolWriter, enclosingDeclaration, flags);
+            writeType(getReturnTypeOfSignature(signature), writer, enclosingDeclaration, flags);
         }
 
         function invokeEmitter(targetSourceFile?: SourceFile) {
@@ -7705,49 +7610,4 @@ module ts {
 
         return checker;
     }
-
-    export function spacePart() {
-        return getSymbolDisplayPart(" ", SymbolDisplayPartKind.space, undefined);
-    }
-
-    export function keywordPart(kind: SyntaxKind) {
-        return getSymbolDisplayPart(tokenToString(kind), SymbolDisplayPartKind.keyword, undefined);
-    }
-
-    export function punctuationPart(kind: SyntaxKind) {
-        return getSymbolDisplayPart(tokenToString(kind), SymbolDisplayPartKind.punctuation, undefined);
-    }
-
-    export function operatorPart(kind: SyntaxKind) {
-        return getSymbolDisplayPart(tokenToString(kind), SymbolDisplayPartKind.operator, undefined);
-    }
-
-    export function textPart(text: string) {
-        return getSymbolDisplayPart(text, SymbolDisplayPartKind.text, undefined);
-    }
-
-    export function symbolPart(text: string, symbol: Symbol) {
-        return getSymbolDisplayPart(text, displayPartKind(symbol), symbol)
-    }
-
-    function displayPartKind(symbol: Symbol): SymbolDisplayPartKind {
-        var flags = symbol.flags;
-
-        if (flags & SymbolFlags.Variable) {
-            return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === SyntaxKind.Parameter
-                ? SymbolDisplayPartKind.parameterName
-                : SymbolDisplayPartKind.localName;
-        }
-        else if (flags & SymbolFlags.Property) { return SymbolDisplayPartKind.propertyName; }
-        else if (flags & SymbolFlags.EnumMember) { return SymbolDisplayPartKind.enumMemberName; }
-        else if (flags & SymbolFlags.Function) { return SymbolDisplayPartKind.functionName; }
-        else if (flags & SymbolFlags.Class) { return SymbolDisplayPartKind.className; }
-        else if (flags & SymbolFlags.Interface) { return SymbolDisplayPartKind.interfaceName; }
-        else if (flags & SymbolFlags.Enum) { return SymbolDisplayPartKind.enumName; }
-        else if (flags & SymbolFlags.Module) { return SymbolDisplayPartKind.moduleName; }
-        else if (flags & SymbolFlags.Method) { return SymbolDisplayPartKind.methodName; }
-        else if (flags & SymbolFlags.TypeParameter) { return SymbolDisplayPartKind.typeParameterName; }
-
-        return SymbolDisplayPartKind.text;
-    }
 }

src/compiler/emitter.ts

@@ -4,7 +4,9 @@
 /// <reference path="parser.ts"/>
 
 module ts {
-    interface EmitTextWriter extends TextWriter {
+    interface EmitTextWriter extends SymbolWriter {
+        write(s: string): void;
+        getText(): string;
         rawWrite(s: string): void;
         writeLiteral(s: string): void;
         getTextPos(): number;
@@ -14,7 +16,7 @@ module ts {
     }
 
     var indentStrings: string[] = ["", "    "];
-    function getIndentString(level: number) {
+    export function getIndentString(level: number) {
         if (indentStrings[level] === undefined) {
             indentStrings[level] = getIndentString(level - 1) + indentStrings[1];
         }
@@ -147,9 +149,17 @@ module ts {
                 }
             }
 
+            function writeKind(text: string, kind: SymbolDisplayPartKind) {
+                write(text);
+            }
+            function writeSymbol(text: string, symbol: Symbol) {
+                write(text);
+            }
             return {
                 write: write,
                 trackSymbol: trackSymbol,
+                writeKind: writeKind,
+                writeSymbol: writeSymbol,
                 rawWrite: rawWrite,
                 writeLiteral: writeLiteral,
                 writeLine: writeLine,
@@ -160,6 +170,7 @@ module ts {
                 getLine: () => lineCount + 1,
                 getColumn: () => lineStart ? indent * getIndentSize() + 1 : output.length - linePos + 1,
                 getText: () => output,
+                clear: () => { }
             };
         }
 

src/compiler/types.ts

@@ -643,9 +643,9 @@ module ts {
         getTypeOfNode(node: Node): Type;
         getApparentType(type: Type): ApparentType;
         typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
+        writeType(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
         symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
-        typeToDisplayParts(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[];
-        symbolToDisplayParts(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): SymbolDisplayPart[];
+        writeSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
         getFullyQualifiedName(symbol: Symbol): string;
         getAugmentedPropertiesOfApparentType(type: Type): Symbol[];
         getRootSymbol(symbol: Symbol): Symbol;
@@ -659,13 +659,18 @@ module ts {
         isValidPropertyAccess(node: PropertyAccess, propertyName: string): boolean;
     }
 
-    export interface TextWriter {
-        write(s: string): void;
-        trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
+    export interface SymbolWriter {
+        writeKind(text: string, kind: SymbolDisplayPartKind): void;
+        writeSymbol(text: string, symbol: Symbol): void;
         writeLine(): void;
         increaseIndent(): void;
         decreaseIndent(): void;
-        getText(): string;
+        clear(): void;
+
+        // Called when the symbol writer encounters a symbol to write.  Currently only used by the
+        // declaration emitter to help determine if it should patch up the final declaration file
+        // with import statements it previously saw (but chose not to emit).
+        trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
     }
 
     export enum TypeFormatFlags {
@@ -701,8 +706,8 @@ module ts {
         hasSemanticErrors(): boolean;
         isDeclarationVisible(node: Declaration): boolean;
         isImplementationOfOverload(node: FunctionDeclaration): boolean;
-        writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: TextWriter): void;
-        writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: TextWriter): void;
+        writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
+        writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
         isImportDeclarationEntityNameReferenceDeclarationVisibile(entityName: EntityName): SymbolAccessiblityResult;
 
@@ -1190,11 +1195,6 @@ module ts {
         verticalTab = 0x0B,           // \v
     }
 
-    export interface SymbolDisplayPart {
-        text: string;
-        kind: SymbolDisplayPartKind;
-    }
-
     export enum SymbolDisplayPartKind {
         aliasName,
         className,