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

2026-02-15 03:23:08 -06:00 · 2014-09-29 09:45:39 -07:00 · 2014-09-29 09:45:39 -07:00 · 90e2c362a5
commit 90e2c362a5
parent 743046bf45
47 changed files with 373 additions and 369 deletions
--- a/src/compiler/checker.ts
+++ b/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;
-    }
-
-    interface DisplayPartsSymbolWriter extends SymbolWriter {
-        displayParts(): SymbolDisplayPart[];
-    }
-
-    interface StringSymbolWriter extends SymbolWriter {
+    export interface StringSymbolWriter extends SymbolWriter {
        string(): string;
    }

-    // TODO this should go back in services
-    export function getSymbolDisplayPart(text: string, kind: SymbolDisplayPartKind, symbol?: Symbol): SymbolDisplayPart {
-        return <SymbolDisplayPart> {
-            text: text,
-            kind: kind
-        };
+    // 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 = "";
+
+            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();
    }

    /// 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;
-    }
 }
--- a/src/compiler/emitter.ts
+++ b/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: () => { }
            };
        }

--- a/src/compiler/types.ts
+++ b/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,
--- a/src/services/services.ts
+++ b/src/services/services.ts
@ -252,7 +252,7 @@ module ts {
                var docComments = getJsDocCommentsSeparatedByNewLines(this);
                ts.forEach(docComments, docComment => {
                    if (this.documentationComment.length) {
-                        this.documentationComment.push(getSymbolDisplayPart("\n", SymbolDisplayPartKind.lineBreak));
+                        this.documentationComment.push(lineBreakPart());
                    }
                    this.documentationComment.push(docComment);
                });
@ -936,6 +936,11 @@ module ts {
        containerKind: string;
        containerName: string;
    }
+    
+    export interface SymbolDisplayPart {
+        text: string;
+        kind: SymbolDisplayPartKind;
+    }

    export interface QuickInfo {
        kind: string;
@ -1227,6 +1232,133 @@ module ts {
        });
        return result;
    }
+
+    interface DisplayPartsSymbolWriter extends SymbolWriter {
+        displayParts(): SymbolDisplayPart[];
+    }
+
+    var displayPartWriters: DisplayPartsSymbolWriter[] = [];
+    function getDisplayPartWriter(): DisplayPartsSymbolWriter {
+        if (displayPartWriters.length !== 0) {
+            return displayPartWriters.pop();
+        }
+
+        var displayParts: SymbolDisplayPart[] = [];
+        var lineStart = true;
+        var indent = 0;
+
+        return {
+            displayParts: () => displayParts,
+            writeKind: writeKind,
+            writeSymbol: writeSymbol,
+            writeLine: writeLine,
+            increaseIndent: () => { indent++; },
+            decreaseIndent: () => { indent--; },
+            clear: () => displayParts = [],
+            trackSymbol: () => { }
+        };
+
+        function writeIndent() {
+            if (lineStart) {
+                displayParts.push(displayPart(getIndentString(indent), SymbolDisplayPartKind.space));
+                lineStart = false;
+            }
+        }
+
+        function writeKind(text: string, kind: SymbolDisplayPartKind) {
+            writeIndent();
+            displayParts.push(displayPart(text, kind));
+        }
+
+        function writeSymbol(text: string, symbol: Symbol) {
+            writeIndent();
+            displayParts.push(symbolPart(text, symbol));
+        }
+
+        function writeLine() {
+            displayParts.push(lineBreakPart());
+            lineStart = true;
+        }
+    }
+
+    function releaseDisplayPartWriter(writer: DisplayPartsSymbolWriter) {
+        writer.clear();
+        displayPartWriters.push(writer);
+    }
+
+    function displayPart(text: string, kind: SymbolDisplayPartKind, symbol?: Symbol): SymbolDisplayPart {
+        return <SymbolDisplayPart> {
+            text: text,
+            kind: kind
+        };
+    }
+    
+    export function spacePart() {
+        return displayPart(" ", SymbolDisplayPartKind.space);
+    }
+
+    export function keywordPart(kind: SyntaxKind) {
+        return displayPart(tokenToString(kind), SymbolDisplayPartKind.keyword);
+    }
+
+    export function punctuationPart(kind: SyntaxKind) {
+        return displayPart(tokenToString(kind), SymbolDisplayPartKind.punctuation);
+    }
+
+    export function operatorPart(kind: SyntaxKind) {
+        return displayPart(tokenToString(kind), SymbolDisplayPartKind.operator);
+    }
+
+    export function textPart(text: string) {
+        return displayPart(text, SymbolDisplayPartKind.text);
+    }
+
+    export function lineBreakPart() {
+        return displayPart("\n", SymbolDisplayPartKind.lineBreak);
+    }
+
+    export function symbolPart(text: string, symbol: Symbol) {
+        return displayPart(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;
+        }
+    }
+
+    export function typeToDisplayParts(typechecker: TypeChecker, type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[] {
+        var displayPartWriter = getDisplayPartWriter();
+        typechecker.writeType(type, displayPartWriter, enclosingDeclaration, flags);
+        var result = displayPartWriter.displayParts();
+        releaseDisplayPartWriter(displayPartWriter);
+        return result;
+    }
+
+    export function symbolToDisplayParts(typeChecker: TypeChecker, symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): SymbolDisplayPart[] {
+        var displayPartWriter = getDisplayPartWriter();
+        typeChecker.writeSymbol(symbol, displayPartWriter, enclosingDeclaration, meaning);
+        var result = displayPartWriter.displayParts();
+        releaseDisplayPartWriter(displayPartWriter);
+
+        return result;
+    }
+
    export function getDefaultCompilerOptions(): CompilerOptions {
        // Set "ES5" target by default for language service
        return {
@ -2367,7 +2499,7 @@ module ts {
                    name: entryName,
                    kind: ScriptElementKind.keyword,
                    kindModifiers: ScriptElementKindModifier.none,
-                    displayParts: [getSymbolDisplayPart(entryName, SymbolDisplayPartKind.keyword)],
+                    displayParts: [displayPart(entryName, SymbolDisplayPartKind.keyword)],
                    documentation: undefined
                };
            }
@ -2481,33 +2613,28 @@ module ts {

        function getSymbolDisplayPartsofSymbol(symbol: Symbol, sourceFile: SourceFile, enclosingDeclaration: Node, typeResolver: TypeChecker): SymbolDisplayPart[] {
            var displayParts: SymbolDisplayPart[] = [];
-            function addNewLineIfDisplayPartsExist() {
-                if (displayParts.length) {
-                    displayParts.push(getSymbolDisplayPart("\n", SymbolDisplayPartKind.lineBreak));
-                }
-            }
            if (symbol.flags & SymbolFlags.Class) {
                displayParts.push(keywordPart(SyntaxKind.ClassKeyword));
                displayParts.push(spacePart());
-                displayParts.push.apply(displayParts, typeResolver.symbolToDisplayParts(symbol, sourceFile));
+                displayParts.push.apply(displayParts, symbolToDisplayParts(typeResolver, symbol, sourceFile));
            }
            if (symbol.flags & SymbolFlags.Interface) {
                addNewLineIfDisplayPartsExist();
                displayParts.push(keywordPart(SyntaxKind.InterfaceKeyword));
                displayParts.push(spacePart());
-                displayParts.push.apply(displayParts, typeResolver.symbolToDisplayParts(symbol, sourceFile));
+                displayParts.push.apply(displayParts, symbolToDisplayParts(typeResolver, symbol, sourceFile));
            }
            if (symbol.flags & SymbolFlags.Enum) {
                addNewLineIfDisplayPartsExist();
                displayParts.push(keywordPart(SyntaxKind.EnumKeyword));
                displayParts.push(spacePart());
-                displayParts.push.apply(displayParts, typeResolver.symbolToDisplayParts(symbol, sourceFile));
+                displayParts.push.apply(displayParts, symbolToDisplayParts(typeResolver, symbol, sourceFile));
            }
            if (symbol.flags & SymbolFlags.Module) {
                addNewLineIfDisplayPartsExist();
                displayParts.push(keywordPart(SyntaxKind.ModuleKeyword));
                displayParts.push(spacePart());
-                displayParts.push.apply(displayParts, typeResolver.symbolToDisplayParts(symbol, sourceFile));
+                displayParts.push.apply(displayParts, symbolToDisplayParts(typeResolver, symbol, sourceFile));
            }
            if (symbol.flags & SymbolFlags.TypeParameter) {
                addNewLineIfDisplayPartsExist();
@ -2515,7 +2642,7 @@ module ts {
                displayParts.push(textPart("type parameter"));
                displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
                displayParts.push(spacePart());
-                displayParts.push.apply(displayParts, typeResolver.symbolToDisplayParts(symbol, enclosingDeclaration));
+                displayParts.push.apply(displayParts, symbolToDisplayParts(typeResolver, symbol, enclosingDeclaration));
            }
            else {
                //public static string FormatSymbolName(string name, string fullSymbolName, string kind, out bool useTypeName)
@ -2558,7 +2685,7 @@ module ts {
                        displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
                        displayParts.push(spacePart());

-                        displayParts.push.apply(displayParts, typeResolver.symbolToDisplayParts(symbol, enclosingDeclaration));
+                        displayParts.push.apply(displayParts, symbolToDisplayParts(typeResolver, symbol, sourceFile));
                    }

                    var type = typeResolver.getTypeOfSymbol(symbol);
@ -2567,7 +2694,7 @@ module ts {
                        if (type) {
                            displayParts.push(punctuationPart(SyntaxKind.ColonToken));
                            displayParts.push(spacePart());
-                            displayParts.push.apply(displayParts, typeResolver.typeToDisplayParts(type, enclosingDeclaration, TypeFormatFlags.NoTruncation));
+                            displayParts.push.apply(displayParts, typeToDisplayParts(typeResolver, type, enclosingDeclaration, TypeFormatFlags.NoTruncation));
                        }
                    }
                    else if (symbol.flags & SymbolFlags.Function ||
@ -2575,7 +2702,7 @@ module ts {
                        symbol.flags & SymbolFlags.Signature ||
                        symbol.flags & SymbolFlags.Accessor) {
                        if (type) {
-                            displayParts.push.apply(displayParts, typeResolver.typeToDisplayParts(type, enclosingDeclaration, TypeFormatFlags.NoTruncation | TypeFormatFlags.NoArrowStyleTopLevelSignature));
+                            displayParts.push.apply(displayParts, typeToDisplayParts(typeResolver, type, enclosingDeclaration, TypeFormatFlags.NoTruncation | TypeFormatFlags.NoArrowStyleTopLevelSignature));
                        }
                    }
                    else if (symbol.flags & SymbolFlags.EnumMember) {
@ -2586,7 +2713,7 @@ module ts {
                                displayParts.push(spacePart());
                                displayParts.push(operatorPart(SyntaxKind.EqualsToken));
                                displayParts.push(spacePart());
-                                displayParts.push(getSymbolDisplayPart(constantValue.toString(), SymbolDisplayPartKind.numericLiteral));
+                                displayParts.push(displayPart(constantValue.toString(), SymbolDisplayPartKind.numericLiteral));
                            }
                        }
                    }
@ -2594,6 +2721,12 @@ module ts {
            }

            return displayParts;
+
+            function addNewLineIfDisplayPartsExist() {
+                if (displayParts.length) {
+                    displayParts.push(lineBreakPart());
+                }
+            }
        }

        function getQuickInfoAtPosition(fileName: string, position: number): QuickInfo {
--- a/src/services/signatureHelp.ts
+++ b/src/services/signatureHelp.ts
@ -268,7 +268,7 @@ module ts.SignatureHelp {
                    displayParts.push(punctuationPart(SyntaxKind.ColonToken));
                    displayParts.push(spacePart());

-                    var typeParts = typeInfoResolver.typeToDisplayParts(typeInfoResolver.getTypeOfSymbol(p), argumentListOrTypeArgumentList);
+                    var typeParts = typeToDisplayParts(typeInfoResolver, typeInfoResolver.getTypeOfSymbol(p), argumentListOrTypeArgumentList);
                    displayParts.push.apply(displayParts, typeParts);

                    return {
@ -282,7 +282,7 @@ module ts.SignatureHelp {
                var callTargetNode = (<CallExpression>argumentListOrTypeArgumentList.parent).func;
                var callTargetSymbol = typeInfoResolver.getSymbolInfo(callTargetNode);

-                var prefixParts = callTargetSymbol ? typeInfoResolver.symbolToDisplayParts(callTargetSymbol, /*enclosingDeclaration*/ undefined, /*meaning*/ undefined) : [];
+                var prefixParts = callTargetSymbol ? symbolToDisplayParts(typeInfoResolver, callTargetSymbol, /*enclosingDeclaration*/ undefined, /*meaning*/ undefined) : [];

                var separatorParts = [punctuationPart(SyntaxKind.CommaToken), spacePart()];

@ -308,7 +308,7 @@ module ts.SignatureHelp {
                suffixParts.push(punctuationPart(SyntaxKind.ColonToken));
                suffixParts.push(spacePart());

-                var typeParts = typeInfoResolver.typeToDisplayParts(candidateSignature.getReturnType(), argumentListOrTypeArgumentList);
+                var typeParts = typeToDisplayParts(typeInfoResolver, candidateSignature.getReturnType(), argumentListOrTypeArgumentList);
                suffixParts.push.apply(suffixParts, typeParts);
                
                return {
--- a/tests/cases/fourslash/addInterfaceMemberAboveClass.ts
+++ b/tests/cases/fourslash/addInterfaceMemberAboveClass.ts
@ -11,11 +11,11 @@
 //// }

 goTo.marker('className');
-verify.quickInfoSymbolNameIs('Sphere');
+verify.quickInfoIs('class Sphere');

 goTo.marker('insertHere');
 edit.insert("ray: Ray;");

 goTo.marker('className');

-verify.quickInfoSymbolNameIs('Sphere');
+verify.quickInfoIs('class Sphere');
--- a/tests/cases/fourslash/addMemberToInterface.ts
+++ b/tests/cases/fourslash/addMemberToInterface.ts
@ -12,10 +12,10 @@ edit.disableFormatting();
 diagnostics.setEditValidation(IncrementalEditValidation.SyntacticOnly);

 goTo.marker('check');
-verify.quickInfoSymbolNameIs('Mod');
+verify.quickInfoIs('module Mod');

 goTo.marker('insert');
 edit.insert("x: number;\n");

 goTo.marker('check');
-verify.quickInfoSymbolNameIs('Mod');
+verify.quickInfoIs('module Mod');
--- a/tests/cases/fourslash/argumentsAreAvailableAfterEditsAtEndOfFunction.ts
+++ b/tests/cases/fourslash/argumentsAreAvailableAfterEditsAtEndOfFunction.ts
@ -12,4 +12,4 @@
 goTo.marker();
 var text = "this.children = ch";
 edit.insert(text);
-verify.completionListContains("children", "string[]");
+verify.completionListContains("children", "(parameter) children: string[]");
--- a/tests/cases/fourslash/arrayCallAndConstructTypings.ts
+++ b/tests/cases/fourslash/arrayCallAndConstructTypings.ts
@ -13,31 +13,31 @@


 goTo.marker('1');
-verify.quickInfoIs('any[]');
+verify.quickInfoIs('(var) a1: any[]');

 goTo.marker('2');
-verify.quickInfoIs('any[]');
+verify.quickInfoIs('(var) a2: any[]');

 goTo.marker('3');
-verify.quickInfoIs('boolean[]');
+verify.quickInfoIs('(var) a3: boolean[]');

 goTo.marker('4');
-verify.quickInfoIs('boolean[]');
+verify.quickInfoIs('(var) a4: boolean[]');

 goTo.marker('5');
-verify.quickInfoIs('string[]');
+verify.quickInfoIs('(var) a5: string[]');

 goTo.marker('6');
-verify.quickInfoIs('any[]');
+verify.quickInfoIs('(var) a6: any[]');

 goTo.marker('7');
-verify.quickInfoIs('any[]');
+verify.quickInfoIs('(var) a7: any[]');

 goTo.marker('8');
-verify.quickInfoIs('boolean[]');
+verify.quickInfoIs('(var) a8: boolean[]');

 goTo.marker('9');
-verify.quickInfoIs('boolean[]');
+verify.quickInfoIs('(var) a9: boolean[]');

 goTo.marker('10');
-verify.quickInfoIs('string[]');
+verify.quickInfoIs('(var) a10: string[]');
--- a/tests/cases/fourslash/assertContextualType.ts
+++ b/tests/cases/fourslash/assertContextualType.ts
@ -6,4 +6,4 @@
 edit.insert('');

 goTo.marker();
-verify.quickInfoIs('any');
+verify.quickInfoIs('(parameter) bb: any');
--- a/tests/cases/fourslash/classInterfaceInsert.ts
+++ b/tests/cases/fourslash/classInterfaceInsert.ts
@ -10,10 +10,10 @@
 //// }

 goTo.marker('className');
-verify.quickInfoSymbolNameIs('Sphere');
+verify.quickInfoIs('class Sphere');

 goTo.marker('interfaceGoesHere');
 edit.insert("\r\ninterface Surface {\r\n    reflect: () => number;\r\n}\r\n");

 goTo.marker('className');
-verify.quickInfoSymbolNameIs('Sphere');
+verify.quickInfoIs('class Sphere');
--- a/tests/cases/fourslash/completionEntryForPrimitive.ts
+++ b/tests/cases/fourslash/completionEntryForPrimitive.ts
@ -6,4 +6,4 @@ diagnostics.setEditValidation(IncrementalEditValidation.None);
 goTo.marker();
 verify.not.completionListIsEmpty();
 edit.insert("nu");
-verify.completionListContains("number", undefined, undefined, undefined, "keyword");
+verify.completionListContains("number", undefined, undefined, "keyword");
--- a/tests/cases/fourslash/completionListForDerivedType1.ts
+++ b/tests/cases/fourslash/completionListForDerivedType1.ts
@ -12,10 +12,10 @@
 ////f2./*2*/ // here bar has return type any, but bar2 is Foo2

 goTo.marker('1');
-verify.completionListContains('bar', '() => IFoo');
+verify.completionListContains('bar', '(method) IFoo.bar(): IFoo');
 verify.not.completionListContains('bar2');
 edit.insert('bar();'); // just to make the file valid before checking next completion location

 goTo.marker('2');
-verify.completionListContains('bar', '() => IFoo');
-verify.completionListContains('bar2', '() => IFoo2');
+verify.completionListContains('bar', '(method) IFoo.bar(): IFoo');
+verify.completionListContains('bar2', '(method) IFoo2.bar2(): IFoo2');
--- a/tests/cases/fourslash/completionListForGenericInstance1.ts
+++ b/tests/cases/fourslash/completionListForGenericInstance1.ts
@ -7,4 +7,4 @@
 ////i/**/

 goTo.marker();
-verify.completionListContains('i', 'Iterator<string, number>', '', 'i');
+verify.completionListContains('i', '(var) i: Iterator<string, number>');
--- a/tests/cases/fourslash/completionListFunctionMembers.ts
+++ b/tests/cases/fourslash/completionListFunctionMembers.ts
@ -8,4 +8,4 @@
 ////fnc1./**/

 goTo.marker();
-verify.memberListContains('arguments', 'any');
+verify.memberListContains('arguments', '(property) Function.arguments: any');
--- a/tests/cases/fourslash/completionListInNamedFunctionExpression.ts
+++ b/tests/cases/fourslash/completionListInNamedFunctionExpression.ts
@ -24,9 +24,9 @@ goTo.marker("insideFunctionExpression");
 verify.memberListContains("foo");

 goTo.marker("referenceInsideFunctionExpression");
-verify.quickInfoIs("() => number");
+verify.quickInfoIs("(function) foo(): number");

 goTo.marker("referenceInGlobalScope");
-verify.quickInfoIs("(a: number) => string");
+verify.quickInfoIs("(function) foo(a: number): string");


--- a/tests/cases/fourslash/completionListInsideTargetTypedFunction.ts
+++ b/tests/cases/fourslash/completionListInsideTargetTypedFunction.ts
@ -6,4 +6,4 @@
 ////}

 goTo.marker();
-verify.completionListContains("elem", "string");
+verify.completionListContains("elem", "(parameter) elem: string");
--- a/tests/cases/fourslash/completionListOfGnericSymbol.ts
+++ b/tests/cases/fourslash/completionListOfGnericSymbol.ts
@ -6,6 +6,6 @@
 ////a./**/

 goTo.marker();
-verify.memberListContains('length', "number", /*docComments*/ undefined, /*fullSymbolName*/ undefined,/*kind*/ "property");
-verify.memberListContains('toString', "() => string", /*docComments*/ undefined, /*fullSymbolName*/ undefined,/*kind*/ "method");
+verify.memberListContains('length', "number", /*docComments*/ undefined, /*kind*/ "property");
+verify.memberListContains('toString', "() => string", /*docComments*/ undefined, /*kind*/ "method");

--- a/tests/cases/fourslash/completionListOnPrivateVariableInModule.ts
+++ b/tests/cases/fourslash/completionListOnPrivateVariableInModule.ts
@ -3,4 +3,4 @@
 //// module Foo {     var testing = "";     test/**/ }

 goTo.marker();
-verify.completionListContains('testing', 'string');
+verify.completionListContains('testing', '(var) testing: string');
--- a/tests/cases/fourslash/constructorQuickInfo.ts
+++ b/tests/cases/fourslash/constructorQuickInfo.ts
@ -7,10 +7,10 @@
 ////var x/*3*/3 = new SS;

 goTo.marker('1');
-verify.quickInfoIs('SS<number>');
+verify.quickInfoIs('(var) x1: SS<number>');

 goTo.marker('2');
-verify.quickInfoIs('SS<{}>');
+verify.quickInfoIs('(var) x2: SS<{}>');

 goTo.marker('3');
-verify.quickInfoIs('SS<{}>');
+verify.quickInfoIs('(var) x3: SS<{}>');
--- a/tests/cases/fourslash/contextuallyTypedFunctionExpressionGeneric1.ts
+++ b/tests/cases/fourslash/contextuallyTypedFunctionExpressionGeneric1.ts
@ -10,13 +10,13 @@
 ////var max2: Comparer = (x/*1*/x, y/*2*/y) => { return x/*3*/x.compareTo(y/*4*/y) };

 goTo.marker('1');
-verify.quickInfoIs('any', null, 'xx');
+verify.quickInfoIs('(parameter) xx: any', null);

 goTo.marker('2');
-verify.quickInfoIs('any', null, 'yy');
+verify.quickInfoIs('(parameter) yy: any', null);

 goTo.marker('3');
-verify.quickInfoIs('any', null, 'xx');
+verify.quickInfoIs('(parameter) xx: any', null);

 goTo.marker('4');
-verify.quickInfoIs('any', null, 'yy');
+verify.quickInfoIs('(parameter) yy: any', null);
--- a/tests/cases/fourslash/enumAddition.ts
+++ b/tests/cases/fourslash/enumAddition.ts
@ -5,4 +5,4 @@

 goTo.marker();
 verify.quickInfoExists();
-verify.quickInfoIs('number');
+verify.quickInfoIs('(var) t: number');
--- a/tests/cases/fourslash/forIn.ts
+++ b/tests/cases/fourslash/forIn.ts
@ -5,4 +5,4 @@

 goTo.marker();

-verify.quickInfoIs('any', "", "p", "var");
+verify.quickInfoIs('(var) p: any', "");
--- a/tests/cases/fourslash/fourslash.ts
+++ b/tests/cases/fourslash/fourslash.ts
@ -226,10 +226,6 @@ module FourSlashInterface {
            FourSlash.currentTestState.verifyQuickInfo(this.negative, expectedText, expectedDocumentation);
        }

-        public quickInfoSymbolNameIs(expectedSymbolInfo: string) {
-            FourSlash.currentTestState.verifyQuickInfo(this.negative, expectedSymbolInfo);
-        }
-
        public quickInfoExists() {
            FourSlash.currentTestState.verifyQuickInfoExists(this.negative);
        }
--- a/tests/cases/fourslash/genericFunctionWithGenericParams1.ts
+++ b/tests/cases/fourslash/genericFunctionWithGenericParams1.ts
@ -6,4 +6,7 @@
 ////};

 goTo.marker();
-verify.quickInfoIs('T', null, 'xx')
+// TODO (local var)
+//verify.quickInfoIs('(local var) xx: T', null);
+verify.quickInfoIs('(var) xx: T', null);
+
--- a/tests/cases/fourslash/genericInterfacePropertyInference1.ts
+++ b/tests/cases/fourslash/genericInterfacePropertyInference1.ts
@ -90,98 +90,98 @@
 verify.numberOfErrorsInCurrentFile(0);

 goTo.marker('a1');
-verify.quickInfoIs('number');
+verify.quickInfoIs('(var) f_r1: number');
 goTo.marker('a2');
-verify.quickInfoIs('string');
+verify.quickInfoIs('(var) f_r2: string');
 goTo.marker('a3');
-verify.quickInfoIs('any');
+verify.quickInfoIs('(var) f_r3: any');
 goTo.marker('a4');
-verify.quickInfoIs('Foo<number>');
+verify.quickInfoIs('(var) f_r5: Foo<number>');
 goTo.marker('a5');
-verify.quickInfoIs('I');
+verify.quickInfoIs('(var) f_r8: I');
 goTo.marker('a6');
-verify.quickInfoIs('{ x: number; }');
+verify.quickInfoIs('(var) f_r12: {\n    x: number;\n}');
 goTo.marker('a7');
-verify.quickInfoIs('{ x: any; }');
+verify.quickInfoIs('(var) f_r14: {\n    x: any;\n}');
 goTo.marker('a8');
-verify.quickInfoIs('C<number>');
+verify.quickInfoIs('(var) f_r18: C<number>');
 goTo.marker('a9');
-verify.quickInfoIs('C<{ x: any; }>');
+verify.quickInfoIs('(var) f_r20: C<{\n    x: any;\n}>');

 goTo.marker('b1');
-verify.quickInfoIs('number');
+verify.quickInfoIs('(var) f2_r1: number');
 goTo.marker('b2');
-verify.quickInfoIs('string');
+verify.quickInfoIs('(var) f2_r2: string');
 goTo.marker('b3');
-verify.quickInfoIs('number');
+verify.quickInfoIs('(var) f2_r3: number');
 goTo.marker('b4');
-verify.quickInfoIs('Foo<number>'); 
+verify.quickInfoIs('(var) f2_r5: Foo<number>'); 
 goTo.marker('b5');
-verify.quickInfoIs('I');
+verify.quickInfoIs('(var) f2_r8: I');
 goTo.marker('b6');
-verify.quickInfoIs('{ x: number; }');
+verify.quickInfoIs('(var) f2_r12: {\n    x: number;\n}');
 goTo.marker('b7');
-verify.quickInfoIs('{ x: number; }');
+verify.quickInfoIs('(var) f2_r14: {\n    x: number;\n}');
 goTo.marker('b8');
-verify.quickInfoIs('C<number>');
+verify.quickInfoIs('(var) f2_r18: C<number>');
 goTo.marker('b9');
-verify.quickInfoIs('C<{ x: number; }>');
+verify.quickInfoIs('(var) f2_r20: C<{\n    x: number;\n}>');

 goTo.marker('c1');
-verify.quickInfoIs('number');
+verify.quickInfoIs('(var) f3_r1: number');
 goTo.marker('c2');
-verify.quickInfoIs('string');
+verify.quickInfoIs('(var) f3_r2: string');
 goTo.marker('c3');
-verify.quickInfoIs('I');
+verify.quickInfoIs('(var) f3_r3: I');
 goTo.marker('c4');
-verify.quickInfoIs('Foo<number>');
+verify.quickInfoIs('(var) f3_r5: Foo<number>');
 goTo.marker('c5');
-verify.quickInfoIs('I');
+verify.quickInfoIs('(var) f3_r8: I');
 goTo.marker('c6');
-verify.quickInfoIs('{ x: number; }');
+verify.quickInfoIs('(var) f3_r12: {\n    x: number;\n}');
 goTo.marker('c7');
-verify.quickInfoIs('{ x: I; }');
+verify.quickInfoIs('(var) f3_r14: {\n    x: I;\n}');
 goTo.marker('c8');
-verify.quickInfoIs('C<number>');
+verify.quickInfoIs('(var) f3_r18: C<number>');
 goTo.marker('c9');
-verify.quickInfoIs('C<{ x: I; }>');
+verify.quickInfoIs('(var) f3_r20: C<{\n    x: I;\n}>');

 goTo.marker('d1');
-verify.quickInfoIs('number');
+verify.quickInfoIs('(var) f4_r1: number');
 goTo.marker('d2');
-verify.quickInfoIs('string');
+verify.quickInfoIs('(var) f4_r2: string');
 goTo.marker('d3');
-verify.quickInfoIs('{ x: number; }');
+verify.quickInfoIs('(var) f4_r3: {\n    x: number;\n}');
 goTo.marker('d4');
-verify.quickInfoIs('Foo<number>');
+verify.quickInfoIs('(var) f4_r5: Foo<number>');
 goTo.marker('d5');
-verify.quickInfoIs('I');
+verify.quickInfoIs('(var) f4_r8: I');
 goTo.marker('d6');
-verify.quickInfoIs('{ x: number; }');
+verify.quickInfoIs('(var) f4_r12: {\n    x: number;\n}');
 goTo.marker('d7');
-verify.quickInfoIs('{ x: { x: number; }; }');
+verify.quickInfoIs('(var) f4_r14: {\n    x: {\n        x: number;\n    };\n}');
 goTo.marker('d8');
-verify.quickInfoIs('C<number>');
+verify.quickInfoIs('(var) f4_r18: C<number>');
 goTo.marker('d9');
-verify.quickInfoIs('C<{ x: { x: number; }; }>');
+verify.quickInfoIs('(var) f4_r20: C<{\n    x: {\n        x: number;\n    };\n}>');

 goTo.marker('e1');
-verify.quickInfoIs('number');
+verify.quickInfoIs('(var) f5_r1: number');
 goTo.marker('e2');
-verify.quickInfoIs('string');
+verify.quickInfoIs('(var) f5_r2: string');
 goTo.marker('e3');
-verify.quickInfoIs('Foo<number>');
+verify.quickInfoIs('(var) f5_r3: Foo<number>');
 goTo.marker('e4');
-verify.quickInfoIs('Foo<number>');
+verify.quickInfoIs('(var) f5_r5: Foo<number>');
 goTo.marker('e5');
-verify.quickInfoIs('I');
+verify.quickInfoIs('(var) f5_r8: I');
 goTo.marker('e6');
-verify.quickInfoIs('{ x: number; }');
+verify.quickInfoIs('(var) f5_r12: {\n    x: number;\n}');
 goTo.marker('e7');
-verify.quickInfoIs('{ x: Foo<number>; }');
+verify.quickInfoIs('(var) f5_r14: {\n    x: Foo<number>;\n}');
 goTo.marker('e8');
-verify.quickInfoIs('C<number>');
+verify.quickInfoIs('(var) f5_r18: C<number>');
 goTo.marker('e9');
-verify.quickInfoIs('C<{ x: Foo<number>; }>');
+verify.quickInfoIs('(var) f5_r20: C<{\n    x: Foo<number>;\n}>');


--- a/tests/cases/fourslash/genericInterfacePropertyInference2.ts
+++ b/tests/cases/fourslash/genericInterfacePropertyInference2.ts
@ -66,56 +66,56 @@
 verify.numberOfErrorsInCurrentFile(0);

 goTo.marker('a1');
-verify.quickInfoIs('Foo<any>');
+verify.quickInfoIs('(var) f_r4: Foo<any>');
 goTo.marker('a2');
-verify.quickInfoIs('Foo<Foo<number>>');
+verify.quickInfoIs('(var) f_r7: Foo<Foo<number>>');
 goTo.marker('a3');
-verify.quickInfoIs('IG<any>');
+verify.quickInfoIs('(var) f_r9: IG<any>');
 goTo.marker('a5');
-verify.quickInfoIs('{ x: Foo<any>; }');
+verify.quickInfoIs('(var) f_r13: {\n    x: Foo<any>;\n}');
 goTo.marker('a7');
-verify.quickInfoIs('C<any>');
+verify.quickInfoIs('(var) f_r17: C<any>');

 goTo.marker('b1');
-verify.quickInfoIs('Foo<number>');
+verify.quickInfoIs('(var) f2_r4: Foo<number>');
 goTo.marker('b2');
-verify.quickInfoIs('Foo<Foo<number>>'); 
+verify.quickInfoIs('(var) f2_r7: Foo<Foo<number>>'); 
 goTo.marker('b3');
-verify.quickInfoIs('IG<number>');
+verify.quickInfoIs('(var) f2_r9: IG<number>');
 goTo.marker('b5');
-verify.quickInfoIs('{ x: Foo<number>; }');
+verify.quickInfoIs('(var) f2_r13: {\n    x: Foo<number>;\n}');
 goTo.marker('b7');
-verify.quickInfoIs('C<number>');
+verify.quickInfoIs('(var) f2_r17: C<number>');

 goTo.marker('c1');
-verify.quickInfoIs('Foo<I>');
+verify.quickInfoIs('(var) f3_r4: Foo<I>');
 goTo.marker('c2');
-verify.quickInfoIs('Foo<Foo<number>>');
+verify.quickInfoIs('(var) f3_r7: Foo<Foo<number>>');
 goTo.marker('c3');
-verify.quickInfoIs('IG<I>');
+verify.quickInfoIs('(var) f3_r9: IG<I>');
 goTo.marker('c5');
-verify.quickInfoIs('{ x: Foo<I>; }');
+verify.quickInfoIs('(var) f3_r13: {\n    x: Foo<I>;\n}');
 goTo.marker('c7');
-verify.quickInfoIs('C<I>');
+verify.quickInfoIs('(var) f3_r17: C<I>');

 goTo.marker('d1');
-verify.quickInfoIs('Foo<{ x: number; }>');
+verify.quickInfoIs('(var) f4_r4: Foo<{\n    x: number;\n}>');
 goTo.marker('d2');
-verify.quickInfoIs('Foo<Foo<number>>');
+verify.quickInfoIs('(var) f4_r7: Foo<Foo<number>>');
 goTo.marker('d3');
-verify.quickInfoIs('IG<{ x: number; }>');
+verify.quickInfoIs('(var) f4_r9: IG<{\n    x: number;\n}>');
 goTo.marker('d5');
-verify.quickInfoIs('{ x: Foo<{ x: number; }>; }');
+verify.quickInfoIs('(var) f4_r13: {\n    x: Foo<{\n        x: number;\n    }>;\n}');
 goTo.marker('d7');
-verify.quickInfoIs('C<{ x: number; }>');
+verify.quickInfoIs('(var) f4_r17: C<{\n    x: number;\n}>');

 goTo.marker('e1');
-verify.quickInfoIs('Foo<Foo<number>>');
+verify.quickInfoIs('(var) f5_r4: Foo<Foo<number>>');
 goTo.marker('e2');
-verify.quickInfoIs('Foo<Foo<number>>');
+verify.quickInfoIs('(var) f5_r7: Foo<Foo<number>>');
 goTo.marker('e3');
-verify.quickInfoIs('IG<Foo<number>>');
+verify.quickInfoIs('(var) f5_r9: IG<Foo<number>>');
 goTo.marker('e5');
-verify.quickInfoIs('{ x: Foo<Foo<number>>; }');
+verify.quickInfoIs('(var) f5_r13: {\n    x: Foo<Foo<number>>;\n}');
 goTo.marker('e7');
-verify.quickInfoIs('C<Foo<number>>');
+verify.quickInfoIs('(var) f5_r17: C<Foo<number>>');
--- a/tests/cases/fourslash/genericInterfacesWithConstraints1.ts
+++ b/tests/cases/fourslash/genericInterfacesWithConstraints1.ts
@ -12,8 +12,8 @@
 ////var v/*3*/3: G<G<A, B>, C>;         // Ok

 goTo.marker('1');
-verify.quickInfoIs('G<A, C>', null, 'v1');
+verify.quickInfoIs('(var) v1: G<A, C>', null);
 goTo.marker('2');
-verify.quickInfoIs('G<{ a: string; }, C>', null, 'v2');
+verify.quickInfoIs('(var) v2: G<{\n    a: string;\n}, C>', null);
 goTo.marker('3');
-verify.quickInfoIs('G<G<A, B>, C>', null, 'v3');
+verify.quickInfoIs('(var) v3: G<G<A, B>, C>', null);
--- a/tests/cases/fourslash/genericTypeWithMultipleBases1MultiFile.ts
+++ b/tests/cases/fourslash/genericTypeWithMultipleBases1MultiFile.ts
@ -18,6 +18,7 @@
 ////x./**/

 goTo.marker();
-verify.completionListContains('watch', '() => void');
-verify.completionListContains('moveUp', '() => void');
-verify.completionListContains('family', 'number');
+verify.completionListContains('watch', '(property) iBaseScope.watch: () => void');
+verify.completionListContains('moveUp', '(property) iMover.moveUp: () => void');
+//verify.completionListContains('family', '(property) iScope<number>.family: number');
+// TODO
--- a/tests/cases/fourslash/getCompletionEntryDetails.ts
+++ b/tests/cases/fourslash/getCompletionEntryDetails.ts
@ -17,17 +17,17 @@ verify.completionListContains("ccc");
 verify.completionListContains("ddd");

 // Checking for completion details before edit should work
-verify.completionEntryDetailIs("aaa", "number");
-verify.completionEntryDetailIs("ccc", "number");
+verify.completionEntryDetailIs("aaa", "(var) aaa: number");
+verify.completionEntryDetailIs("ccc", "(var) ccc: number");

 // Make an edit
 edit.insert("a");
 edit.backspace();

 // Checking for completion details after edit should work too
-verify.completionEntryDetailIs("bbb", "string");
-verify.completionEntryDetailIs("ddd", "string");
+verify.completionEntryDetailIs("bbb", "(var) bbb: string");
+verify.completionEntryDetailIs("ddd", "(var) ddd: string");

 // Checking for completion details again before edit should work
-verify.completionEntryDetailIs("aaa", "number");
-verify.completionEntryDetailIs("ccc", "number");
+verify.completionEntryDetailIs("aaa", "(var) aaa: number");
+verify.completionEntryDetailIs("ccc", "(var) ccc: number");
--- a/tests/cases/fourslash/getCompletionEntryDetails2.ts
+++ b/tests/cases/fourslash/getCompletionEntryDetails2.ts
@ -15,4 +15,4 @@ edit.insert("a");
 edit.backspace();

 // Checking for completion details after edit should work too
-verify.completionEntryDetailIs("x", "number");
+verify.completionEntryDetailIs("x", "(var) Foo.x: number");
--- a/tests/cases/fourslash/incrementalResolveConstructorDeclaration.ts
+++ b/tests/cases/fourslash/incrementalResolveConstructorDeclaration.ts
@ -13,7 +13,7 @@ diagnostics.setEditValidation(IncrementalEditValidation.None);

 // Do resolve without typeCheck
 goTo.marker('1');
-verify.quickInfoIs("c1");
+verify.quickInfoIs("(var) val: c1");

 // TypeCheck
 verify.numberOfErrorsInCurrentFile(1);
--- a/tests/cases/fourslash/incrementalResolveFunctionPropertyAssignment.ts
+++ b/tests/cases/fourslash/incrementalResolveFunctionPropertyAssignment.ts
@ -25,7 +25,7 @@ diagnostics.setEditValidation(IncrementalEditValidation.None);

 // Do resolve without typeCheck
 goTo.marker('1');
-verify.quickInfoIs("string");
+verify.quickInfoIs("(var) val: string");

 // TypeCheck
 verify.numberOfErrorsInCurrentFile(1);
--- a/tests/cases/fourslash/memberCompletionOnTypeParameters.ts
+++ b/tests/cases/fourslash/memberCompletionOnTypeParameters.ts
@ -17,17 +17,17 @@ goTo.marker("S");
 verify.memberListIsEmpty();

 goTo.marker("T");
-verify.memberListContains("x", "number");
-verify.memberListContains("y", "string");
+verify.memberListContains("x", "(property) IFoo.x: number");
+verify.memberListContains("y", "(property) IFoo.y: string");
 verify.memberListCount(2);

 goTo.marker("U");
-verify.memberListContains("toString", "() => string");
+verify.memberListContains("toString", "(method) Object.toString(): string");
 verify.memberListCount(7); // constructor, toString, toLocaleString, valueOf, hasOwnProperty, isPrototypeOf, propertyIsEnumerable

 goTo.marker("V");
-verify.memberListContains("x", "number");
-verify.memberListContains("y", "string");
+verify.memberListContains("x", "(property) IFoo.x: number");
+verify.memberListContains("y", "(property) IFoo.y: string");
 verify.memberListCount(2);


--- a/tests/cases/fourslash/memberListInReopenedEnum.ts
+++ b/tests/cases/fourslash/memberListInReopenedEnum.ts
@ -12,7 +12,7 @@


 goTo.marker('1');
-verify.memberListContains('A', 'E', undefined, "E.A");
-verify.memberListContains('B', 'E', undefined, "E.B");
-verify.memberListContains('C', 'E', undefined, "E.C");
-verify.memberListContains('D', 'E', undefined, "E.D");
+verify.memberListContains('A', '(enum member) E.A = 0');
+verify.memberListContains('B', '(enum member) E.B = 1');
+verify.memberListContains('C', '(enum member) E.C = 0');
+verify.memberListContains('D', '(enum member) E.D = 1');
--- a/tests/cases/fourslash/memberListInsideObjectLiterals.ts
+++ b/tests/cases/fourslash/memberListInsideObjectLiterals.ts
@ -26,16 +26,16 @@

 // Literal member completion inside empty literal.
 goTo.marker("1");
-verify.memberListContains("x1", "number");
-verify.memberListContains("y1", "number");
+verify.memberListContains("x1", "(property) MyPoint.x1: number");
+verify.memberListContains("y1", "(property) MyPoint.y1: number");

 // Literal member completion for 2nd member name.
 goTo.marker("2");
-verify.memberListContains("y1", "number");
+verify.memberListContains("y1", "(property) MyPoint.y1: number");

 // Literal member completion at existing member name location.
 goTo.marker("3");
-verify.memberListContains("y1", "number");
+verify.memberListContains("y1", "(property) MyPoint.y1: number");

 goTo.marker("4");
-verify.memberListContains("x1", "number");
+verify.memberListContains("x1", "(property) MyPoint.x1: number");
--- a/tests/cases/fourslash/memberListOfClass.ts
+++ b/tests/cases/fourslash/memberListOfClass.ts
@ -11,5 +11,5 @@

 goTo.marker();
 verify.memberListCount(2);
-verify.memberListContains('pubMeth', '() => void');
-verify.memberListContains('pubProp', 'number');
+verify.memberListContains('pubMeth', '(method) C1.pubMeth(): void');
+verify.memberListContains('pubProp', '(property) C1.pubProp: number');
--- a/tests/cases/fourslash/memberListOfExportedClass.ts
+++ b/tests/cases/fourslash/memberListOfExportedClass.ts
@ -12,4 +12,4 @@

 goTo.marker();
 verify.memberListCount(1);
-verify.memberListContains('pub', 'number');
+verify.memberListContains('pub', '(property) M.C.pub: number');
--- a/tests/cases/fourslash/memberListOfModuleAfterInvalidCharater.ts
+++ b/tests/cases/fourslash/memberListOfModuleAfterInvalidCharater.ts
@ -7,4 +7,4 @@
 ////testModule./**/

 goTo.marker();
-verify.completionListContains('foo', 'number');
+verify.completionListContains('foo', '(var) testModule.foo: number');
--- a/tests/cases/fourslash/memberListOnThisInClassWithPrivates.ts
+++ b/tests/cases/fourslash/memberListOnThisInClassWithPrivates.ts
@ -8,6 +8,6 @@
 ////}

 goTo.marker();
-verify.memberListContains('privMeth', '() => void');
-verify.memberListContains('pubMeth', '() => void');
-verify.memberListContains('pubProp', 'number');
+verify.memberListContains('privMeth', '(method) C1.privMeth(): void');
+verify.memberListContains('pubMeth', '(method) C1.pubMeth(): void');
+verify.memberListContains('pubProp', '(property) C1.pubProp: number');
--- a/tests/cases/fourslash/moduleMembersOfGenericType.ts
+++ b/tests/cases/fourslash/moduleMembersOfGenericType.ts
@ -6,4 +6,4 @@
 ////var r = M./**/;

 goTo.marker();
-verify.completionListContains('x', '<T>(x: T) => T');
+verify.completionListContains('x', '(var) M.x: <T>(x: T) => T');
--- a/tests/cases/fourslash/quickInfoFromEmptyBlockComment.ts
+++ b/tests/cases/fourslash/quickInfoFromEmptyBlockComment.ts
@ -7,4 +7,4 @@
 ////var f/*A*/ff = new Foo();

 goTo.marker('A');
-verify.quickInfoIs('Foo');
+verify.quickInfoIs('(var) fff: Foo');
--- a/tests/cases/fourslash/quickInfoOnCircularTypes.ts
+++ b/tests/cases/fourslash/quickInfoOnCircularTypes.ts
@ -15,7 +15,7 @@
 ////x/*B*/x = y/*C*/y;

 goTo.marker('B');
-verify.quickInfoIs('B');
+verify.quickInfoIs('(var) xx: B');

 goTo.marker('C');
-verify.quickInfoIs('C');
+verify.quickInfoIs('(var) yy: C');
--- a/tests/cases/fourslash/quickInfoOnMergedInterfaces.ts
+++ b/tests/cases/fourslash/quickInfoOnMergedInterfaces.ts
@ -19,4 +19,4 @@
 diagnostics.setEditValidation(IncrementalEditValidation.None);

 goTo.marker('1');
-verify.quickInfoIs("number", undefined, "r4", "var");
+verify.quickInfoIs("(var) r4: number");
--- a/tests/cases/fourslash/quickinfoIsConsistent.ts
+++ b/tests/cases/fourslash/quickinfoIsConsistent.ts
@ -8,5 +8,5 @@

 [1, 2, 3].forEach((val) => {
    goTo.marker("" + val);
-    verify.quickInfoIs("(x: number) => number", "", "f", "var");
+    verify.quickInfoIs("(var) f: (x: number) => number", "");
 } );
--- a/tests/cases/fourslash/recursiveWrappedTypeParameters1.ts
+++ b/tests/cases/fourslash/recursiveWrappedTypeParameters1.ts
@ -15,22 +15,22 @@
 ////var f/*7*/f = x.c.c; 

 goTo.marker('1');
-verify.quickInfoIs('I<I<I<I<I<I<number>>>>>>');
+verify.quickInfoIs('(var) yy: I<I<I<I<I<I<number>>>>>>');

 goTo.marker('2');
-verify.quickInfoIs('number');
+verify.quickInfoIs('(var) aa: number');

 goTo.marker('3');
-verify.quickInfoIs('I<number>');
+verify.quickInfoIs('(var) bb: I<number>');

 goTo.marker('4');
-verify.quickInfoIs('I<I<number>>');
+verify.quickInfoIs('(var) cc: I<I<number>>');

 goTo.marker('5');
-verify.quickInfoIs('I<number>');
+verify.quickInfoIs('(var) dd: I<number>');

 goTo.marker('6');
-verify.quickInfoIs('I<I<number>>');
+verify.quickInfoIs('(var) ee: I<I<number>>');

 goTo.marker('7');
-verify.quickInfoIs('I<I<I<number>>>');
+verify.quickInfoIs('(var) ff: I<I<I<number>>>');
--- a/tests/cases/fourslash/returnRecursiveType.ts
+++ b/tests/cases/fourslash/returnRecursiveType.ts
@ -8,4 +8,4 @@
 ////var My/**/Var = MyFn();

 goTo.marker();
-verify.quickInfoIs('MyInt');
+verify.quickInfoIs('(var) MyVar: MyInt');