Merge branch 'useBaselinesForQuickInfoTests' into literalTypesAlways

.travis.yml

@@ -23,7 +23,7 @@ matrix:
 branches:
   only:
   - master
-  - transforms
+  - release.2.0
 
 install:
   - npm uninstall typescript

Jakefile.js

@@ -120,16 +120,27 @@ var servicesSources = [
 ].map(function (f) {
     return path.join(compilerDirectory, f);
 }).concat([
+    "types.ts",
+    "utilities.ts",
     "breakpoints.ts",
+    "classifier.ts",
+    "completions.ts",
+    "documentHighlights.ts",
+    "findAllReferences.ts",
+    "goToDefinition.ts",
+    "jsDoc.ts",
+    "jsTyping.ts",
     "navigateTo.ts",
     "navigationBar.ts",
     "outliningElementsCollector.ts",
     "patternMatcher.ts",
+    "preProcess.ts",
+    "rename.ts",
     "services.ts",
     "shims.ts",
     "signatureHelp.ts",
-    "types.ts",
-    "utilities.ts",
+    "symbolDisplay.ts",
+    "transpile.ts",
     "formatting/formatting.ts",
     "formatting/formattingContext.ts",
     "formatting/formattingRequestKind.ts",

package.json

@@ -77,7 +77,7 @@
         "ts-node": "latest",
         "tsd": "latest",
         "tslint": "next",
-        "typescript": "2.1.0-dev.20160906"
+        "typescript": "next"
     },
     "scripts": {
         "pretest": "jake tests",

scripts/tslint/preferConstRule.ts

@@ -9,44 +9,12 @@ export class Rule extends Lint.Rules.AbstractRule {
     }
 }
 
-function isBindingPattern(node: ts.Node): node is ts.BindingPattern {
-    return !!node && (node.kind === ts.SyntaxKind.ArrayBindingPattern || node.kind === ts.SyntaxKind.ObjectBindingPattern);
-}
-
-function walkUpBindingElementsAndPatterns(node: ts.Node): ts.Node {
-    while (node && (node.kind === ts.SyntaxKind.BindingElement || isBindingPattern(node))) {
-        node = node.parent;
-    }
-
-    return node;
-}
-
-function getCombinedNodeFlags(node: ts.Node): ts.NodeFlags {
-    node = walkUpBindingElementsAndPatterns(node);
-
-    let flags = node.flags;
-    if (node.kind === ts.SyntaxKind.VariableDeclaration) {
-        node = node.parent;
-    }
-
-    if (node && node.kind === ts.SyntaxKind.VariableDeclarationList) {
-        flags |= node.flags;
-        node = node.parent;
-    }
-
-    if (node && node.kind === ts.SyntaxKind.VariableStatement) {
-        flags |= node.flags;
-    }
-
-    return flags;
-}
-
 function isLet(node: ts.Node) {
-    return !!(getCombinedNodeFlags(node) & ts.NodeFlags.Let);
+    return !!(ts.getCombinedNodeFlags(node) & ts.NodeFlags.Let);
 }
 
 function isExported(node: ts.Node) {
-    return !!(getCombinedNodeFlags(node) & ts.NodeFlags.Export);
+    return !!(ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export);
 }
 
 function isAssignmentOperator(token: ts.SyntaxKind): boolean {

src/compiler/checker.ts

@@ -10060,6 +10060,10 @@ namespace ts {
             return isTypeAny(type) || isTypeOfKind(type, kind);
         }
 
+        function isInfinityOrNaNString(name: string): boolean {
+            return name === "Infinity" || name === "-Infinity" || name === "NaN";
+        }
+
         function isNumericLiteralName(name: string) {
             // The intent of numeric names is that
             //     - they are names with text in a numeric form, and that
@@ -16839,7 +16843,7 @@ namespace ts {
                     }
                     else {
                         const text = getTextOfPropertyName(<PropertyName>member.name);
-                        if (isNumericLiteralName(text)) {
+                        if (isNumericLiteralName(text) && !isInfinityOrNaNString(text)) {
                             error(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
                         }
                     }

src/compiler/commandLineParser.ts

@@ -858,14 +858,13 @@ namespace ts {
                 errors.push(createCompilerDiagnostic(Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
             }
             else {
-                // By default, exclude common package folders
+                // By default, exclude common package folders and the outDir
                 excludeSpecs = ["node_modules", "bower_components", "jspm_packages"];
-            }
 
-            // Always exclude the output directory unless explicitly included
-            const outDir = json["compilerOptions"] && json["compilerOptions"]["outDir"];
-            if (outDir) {
-                excludeSpecs.push(outDir);
+                const outDir = json["compilerOptions"] && json["compilerOptions"]["outDir"];
+                if (outDir) {
+                    excludeSpecs.push(outDir);
+                }
             }
 
             if (fileNames === undefined && includeSpecs === undefined) {

src/compiler/emitter.ts

@@ -2030,7 +2030,7 @@ const _super = (function (geti, seti) {
                 emitTrailingCommentsOfPosition(commentRange.pos);
             }
 
-            emitExpression(node.initializer);
+            emitExpression(initializer);
         }
 
         function emitShorthandPropertyAssignment(node: ShorthandPropertyAssignment) {

src/compiler/parser.ts

@@ -905,6 +905,10 @@ namespace ts {
             return currentToken = scanner.scanJsxToken();
         }
 
+        function scanJsxAttributeValue(): SyntaxKind {
+            return currentToken = scanner.scanJsxAttributeValue();
+        }
+
         function speculationHelper<T>(callback: () => T, isLookAhead: boolean): T {
             // Keep track of the state we'll need to rollback to if lookahead fails (or if the
             // caller asked us to always reset our state).
@@ -3831,8 +3835,8 @@ namespace ts {
             scanJsxIdentifier();
             const node = <JsxAttribute>createNode(SyntaxKind.JsxAttribute);
             node.name = parseIdentifierName();
-            if (parseOptional(SyntaxKind.EqualsToken)) {
-                switch (token()) {
+            if (token() === SyntaxKind.EqualsToken) {
+                switch (scanJsxAttributeValue()) {
                     case SyntaxKind.StringLiteral:
                         node.initializer = parseLiteralNode();
                         break;

src/compiler/scanner.ts

@@ -27,6 +27,7 @@ namespace ts {
         reScanSlashToken(): SyntaxKind;
         reScanTemplateToken(): SyntaxKind;
         scanJsxIdentifier(): SyntaxKind;
+        scanJsxAttributeValue(): SyntaxKind;
         reScanJsxToken(): SyntaxKind;
         scanJsxToken(): SyntaxKind;
         scanJSDocToken(): SyntaxKind;
@@ -817,6 +818,7 @@ namespace ts {
             reScanSlashToken,
             reScanTemplateToken,
             scanJsxIdentifier,
+            scanJsxAttributeValue,
             reScanJsxToken,
             scanJsxToken,
             scanJSDocToken,
@@ -911,7 +913,7 @@ namespace ts {
             return value;
         }
 
-        function scanString(): string {
+        function scanString(allowEscapes = true): string {
             const quote = text.charCodeAt(pos);
             pos++;
             let result = "";
@@ -929,7 +931,7 @@ namespace ts {
                     pos++;
                     break;
                 }
-                if (ch === CharacterCodes.backslash) {
+                if (ch === CharacterCodes.backslash && allowEscapes) {
                     result += text.substring(start, pos);
                     result += scanEscapeSequence();
                     start = pos;
@@ -1737,6 +1739,20 @@ namespace ts {
             return token;
         }
 
+        function scanJsxAttributeValue(): SyntaxKind {
+            startPos = pos;
+
+            switch (text.charCodeAt(pos)) {
+                case CharacterCodes.doubleQuote:
+                case CharacterCodes.singleQuote:
+                    tokenValue = scanString(/*allowEscapes*/ false);
+                    return token = SyntaxKind.StringLiteral;
+                default:
+                    // If this scans anything other than `{`, it's a parse error.
+                    return scan();
+            }
+        }
+
         function scanJSDocToken(): SyntaxKind {
             if (pos >= end) {
                 return token = SyntaxKind.EndOfFileToken;

src/compiler/transformers/jsx.ts

@@ -140,7 +140,8 @@ namespace ts {
                 return createLiteral(true);
             }
             else if (node.kind === SyntaxKind.StringLiteral) {
-                return node;
+                const decoded = tryDecodeEntities((<StringLiteral>node).text);
+                return decoded ? createLiteral(decoded, /*location*/ node) : node;
             }
             else if (node.kind === SyntaxKind.JsxExpression) {
                 return visitJsxExpression(<JsxExpression>node);
@@ -210,19 +211,31 @@ namespace ts {
         }
 
         /**
-         * Decodes JSX entities.
+         * Replace entities like "&nbsp;", "&#123;", and "&#xDEADBEEF;" with the characters they encode.
+         * See https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references
          */
-        function decodeEntities(text: string) {
-            return text.replace(/&(\w+);/g, function(s: any, m: string) {
-                if (entities[m] !== undefined) {
-                    return String.fromCharCode(entities[m]);
+        function decodeEntities(text: string): string {
+            return text.replace(/&((#((\d+)|x([\da-fA-F]+)))|(\w+));/g, (match, _all, _number, _digits, decimal, hex, word) => {
+                if (decimal) {
+                    return String.fromCharCode(parseInt(decimal, 10));
+                }
+                else if (hex) {
+                    return String.fromCharCode(parseInt(hex, 16));
                 }
                 else {
-                    return s;
+                    const ch = entities[word];
+                    // If this is not a valid entity, then just use `match` (replace it with itself, i.e. don't replace)
+                    return ch ? String.fromCharCode(ch) : match;
                 }
             });
         }
 
+        /** Like `decodeEntities` but returns `undefined` if there were no entities to decode. */
+        function tryDecodeEntities(text: string): string | undefined {
+            const decoded = decodeEntities(text);
+            return decoded === text ? undefined : decoded;
+        }
+
         function getTagName(node: JsxElement | JsxOpeningLikeElement): Expression {
             if (node.kind === SyntaxKind.JsxElement) {
                 return getTagName((<JsxElement>node).openingElement);

src/harness/fourslash.ts

@@ -1294,6 +1294,22 @@ namespace FourSlash {
                 });
         }
 
+        public baselineQuickInfo() {
+            let baselineFile = this.testData.globalOptions[metadataOptionNames.baselineFile];
+            if (!baselineFile) {
+                baselineFile = ts.getBaseFileName(this.activeFile.fileName).replace(".ts", ".baseline");
+            }
+
+            Harness.Baseline.runBaseline(
+                baselineFile,
+                () => stringify(
+                    this.testData.markers.map(marker => ({
+                        marker: marker,
+                        quickInfo: this.languageService.getQuickInfoAtPosition(marker.fileName, marker.position)
+                    }))
+                ));
+        }
+
         public printBreakpointLocation(pos: number) {
             Harness.IO.log("\n**Pos: " + pos + " " + this.spanInfoToString(pos, this.getBreakpointStatementLocation(pos), "  "));
         }
@@ -3103,6 +3119,10 @@ namespace FourSlashInterface {
             this.state.baselineGetEmitOutput();
         }
 
+        public baselineQuickInfo() {
+            this.state.baselineQuickInfo();
+        }
+
         public nameOrDottedNameSpanTextIs(text: string) {
             this.state.verifyCurrentNameOrDottedNameSpanText(text);
         }

src/harness/harnessLanguageService.ts

@@ -232,8 +232,8 @@ namespace Harness.LanguageService {
         }
         getHost() { return this.host; }
         getLanguageService(): ts.LanguageService { return ts.createLanguageService(this.host); }
-        getClassifier(): ts.Classifier { return ts.createClassifier(); }
-        getPreProcessedFileInfo(fileName: string, fileContents: string): ts.PreProcessedFileInfo { return ts.preProcessFile(fileContents, /* readImportFiles */ true, ts.hasJavaScriptFileExtension(fileName)); }
+        getClassifier(): ts.Classifier { return ts.Classifier.createClassifier(); }
+        getPreProcessedFileInfo(fileName: string, fileContents: string): ts.PreProcessedFileInfo { return ts.PreProcess.preProcessFile(fileContents, /* readImportFiles */ true, ts.hasJavaScriptFileExtension(fileName)); }
     }
 
     /// Shim adapter
@@ -258,7 +258,7 @@ namespace Harness.LanguageService {
                 };
                 this.getModuleResolutionsForFile = (fileName) => {
                     const scriptInfo = this.getScriptInfo(fileName);
-                    const preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ true);
+                    const preprocessInfo = ts.PreProcess.preProcessFile(scriptInfo.content, /*readImportFiles*/ true);
                     const imports = ts.createMap<string>();
                     for (const module of preprocessInfo.importedFiles) {
                         const resolutionInfo = ts.resolveModuleName(module.fileName, fileName, compilerOptions, moduleResolutionHost);
@@ -271,7 +271,7 @@ namespace Harness.LanguageService {
                 this.getTypeReferenceDirectiveResolutionsForFile = (fileName) => {
                     const scriptInfo = this.getScriptInfo(fileName);
                     if (scriptInfo) {
-                        const preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ false);
+                        const preprocessInfo = ts.PreProcess.preProcessFile(scriptInfo.content, /*readImportFiles*/ false);
                         const resolutions = ts.createMap<ts.ResolvedTypeReferenceDirective>();
                         const settings = this.nativeHost.getCompilationSettings();
                         for (const typeReferenceDirective of preprocessInfo.typeReferenceDirectives) {

src/harness/unittests/services/preProcessFile.ts

@@ -2,7 +2,7 @@
 
 describe("PreProcessFile:", function () {
     function test(sourceText: string, readImportFile: boolean, detectJavaScriptImports: boolean, expectedPreProcess: ts.PreProcessedFileInfo): void {
-        const resultPreProcess = ts.preProcessFile(sourceText, readImportFile, detectJavaScriptImports);
+        const resultPreProcess = ts.PreProcess.preProcessFile(sourceText, readImportFile, detectJavaScriptImports);
 
         assert.equal(resultPreProcess.isLibFile, expectedPreProcess.isLibFile, "Pre-processed file has different value for isLibFile. Expected: " + expectedPreProcess.isLibFile + ". Actual: " + resultPreProcess.isLibFile);
 

src/harness/unittests/tsconfigParsing.ts

@@ -151,7 +151,7 @@ namespace ts {
             );
         });
 
-        it("always exclude outDir", () => {
+        it("exclude outDir unless overridden", () => {
             const tsconfigWithoutExclude =
             `{
                 "compilerOptions": {
@@ -169,7 +169,7 @@ namespace ts {
             const allFiles = ["/bin/a.ts", "/b.ts"];
             const expectedFiles = ["/b.ts"];
             assertParseFileList(tsconfigWithoutExclude, "tsconfig.json", rootDir, allFiles, expectedFiles);
-            assertParseFileList(tsconfigWithExclude, "tsconfig.json", rootDir, allFiles, expectedFiles);
+            assertParseFileList(tsconfigWithExclude, "tsconfig.json", rootDir, allFiles, allFiles);
         });
 
         it("implicitly exclude common package folders", () => {

src/server/editorServices.ts

@@ -1566,7 +1566,7 @@ namespace ts.server {
                 this.setCompilerOptions(defaultOpts);
             }
             this.languageService = ts.createLanguageService(this.host, this.documentRegistry);
-            this.classifier = ts.createClassifier();
+            this.classifier = ts.Classifier.createClassifier();
         }
 
         setCompilerOptions(opt: ts.CompilerOptions) {

src/services/classifier.ts

@@ -0,0 +1,982 @@
+/* @internal */
+namespace ts.Classifier {
+    /// Classifier
+    export function createClassifier(): Classifier {
+        const scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false);
+
+        /// We do not have a full parser support to know when we should parse a regex or not
+        /// If we consider every slash token to be a regex, we could be missing cases like "1/2/3", where
+        /// we have a series of divide operator. this list allows us to be more accurate by ruling out
+        /// locations where a regexp cannot exist.
+        const noRegexTable: boolean[] = [];
+        noRegexTable[SyntaxKind.Identifier] = true;
+        noRegexTable[SyntaxKind.StringLiteral] = true;
+        noRegexTable[SyntaxKind.NumericLiteral] = true;
+        noRegexTable[SyntaxKind.RegularExpressionLiteral] = true;
+        noRegexTable[SyntaxKind.ThisKeyword] = true;
+        noRegexTable[SyntaxKind.PlusPlusToken] = true;
+        noRegexTable[SyntaxKind.MinusMinusToken] = true;
+        noRegexTable[SyntaxKind.CloseParenToken] = true;
+        noRegexTable[SyntaxKind.CloseBracketToken] = true;
+        noRegexTable[SyntaxKind.CloseBraceToken] = true;
+        noRegexTable[SyntaxKind.TrueKeyword] = true;
+        noRegexTable[SyntaxKind.FalseKeyword] = true;
+
+        // Just a stack of TemplateHeads and OpenCurlyBraces, used to perform rudimentary (inexact)
+        // classification on template strings. Because of the context free nature of templates,
+        // the only precise way to classify a template portion would be by propagating the stack across
+        // lines, just as we do with the end-of-line state. However, this is a burden for implementers,
+        // and the behavior is entirely subsumed by the syntactic classifier anyway, so we instead
+        // flatten any nesting when the template stack is non-empty and encode it in the end-of-line state.
+        // Situations in which this fails are
+        //  1) When template strings are nested across different lines:
+        //          `hello ${ `world
+        //          ` }`
+        //
+        //     Where on the second line, you will get the closing of a template,
+        //     a closing curly, and a new template.
+        //
+        //  2) When substitution expressions have curly braces and the curly brace falls on the next line:
+        //          `hello ${ () => {
+        //          return "world" } } `
+        //
+        //     Where on the second line, you will get the 'return' keyword,
+        //     a string literal, and a template end consisting of '} } `'.
+        const templateStack: SyntaxKind[] = [];
+
+        /** Returns true if 'keyword2' can legally follow 'keyword1' in any language construct. */
+        function canFollow(keyword1: SyntaxKind, keyword2: SyntaxKind) {
+            if (isAccessibilityModifier(keyword1)) {
+                if (keyword2 === SyntaxKind.GetKeyword ||
+                    keyword2 === SyntaxKind.SetKeyword ||
+                    keyword2 === SyntaxKind.ConstructorKeyword ||
+                    keyword2 === SyntaxKind.StaticKeyword) {
+
+                    // Allow things like "public get", "public constructor" and "public static".
+                    // These are all legal.
+                    return true;
+                }
+
+                // Any other keyword following "public" is actually an identifier an not a real
+                // keyword.
+                return false;
+            }
+
+            // Assume any other keyword combination is legal.  This can be refined in the future
+            // if there are more cases we want the classifier to be better at.
+            return true;
+        }
+
+        function convertClassifications(classifications: Classifications, text: string): ClassificationResult {
+            const entries: ClassificationInfo[] = [];
+            const dense = classifications.spans;
+            let lastEnd = 0;
+
+            for (let i = 0, n = dense.length; i < n; i += 3) {
+                const start = dense[i];
+                const length = dense[i + 1];
+                const type = <ClassificationType>dense[i + 2];
+
+                // Make a whitespace entry between the last item and this one.
+                if (lastEnd >= 0) {
+                    const whitespaceLength = start - lastEnd;
+                    if (whitespaceLength > 0) {
+                        entries.push({ length: whitespaceLength, classification: TokenClass.Whitespace });
+                    }
+                }
+
+                entries.push({ length, classification: convertClassification(type) });
+                lastEnd = start + length;
+            }
+
+            const whitespaceLength = text.length - lastEnd;
+            if (whitespaceLength > 0) {
+                entries.push({ length: whitespaceLength, classification: TokenClass.Whitespace });
+            }
+
+            return { entries, finalLexState: classifications.endOfLineState };
+        }
+
+        function convertClassification(type: ClassificationType): TokenClass {
+            switch (type) {
+                case ClassificationType.comment: return TokenClass.Comment;
+                case ClassificationType.keyword: return TokenClass.Keyword;
+                case ClassificationType.numericLiteral: return TokenClass.NumberLiteral;
+                case ClassificationType.operator: return TokenClass.Operator;
+                case ClassificationType.stringLiteral: return TokenClass.StringLiteral;
+                case ClassificationType.whiteSpace: return TokenClass.Whitespace;
+                case ClassificationType.punctuation: return TokenClass.Punctuation;
+                case ClassificationType.identifier:
+                case ClassificationType.className:
+                case ClassificationType.enumName:
+                case ClassificationType.interfaceName:
+                case ClassificationType.moduleName:
+                case ClassificationType.typeParameterName:
+                case ClassificationType.typeAliasName:
+                case ClassificationType.text:
+                case ClassificationType.parameterName:
+                default:
+                    return TokenClass.Identifier;
+            }
+        }
+
+        function getClassificationsForLine(text: string, lexState: EndOfLineState, syntacticClassifierAbsent: boolean): ClassificationResult {
+            return convertClassifications(getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent), text);
+        }
+
+        // If there is a syntactic classifier ('syntacticClassifierAbsent' is false),
+        // we will be more conservative in order to avoid conflicting with the syntactic classifier.
+        function getEncodedLexicalClassifications(text: string, lexState: EndOfLineState, syntacticClassifierAbsent: boolean): Classifications {
+            let offset = 0;
+            let token = SyntaxKind.Unknown;
+            let lastNonTriviaToken = SyntaxKind.Unknown;
+
+            // Empty out the template stack for reuse.
+            while (templateStack.length > 0) {
+                templateStack.pop();
+            }
+
+            // If we're in a string literal, then prepend: "\
+            // (and a newline).  That way when we lex we'll think we're still in a string literal.
+            //
+            // If we're in a multiline comment, then prepend: /*
+            // (and a newline).  That way when we lex we'll think we're still in a multiline comment.
+            switch (lexState) {
+                case EndOfLineState.InDoubleQuoteStringLiteral:
+                    text = "\"\\\n" + text;
+                    offset = 3;
+                    break;
+                case EndOfLineState.InSingleQuoteStringLiteral:
+                    text = "'\\\n" + text;
+                    offset = 3;
+                    break;
+                case EndOfLineState.InMultiLineCommentTrivia:
+                    text = "/*\n" + text;
+                    offset = 3;
+                    break;
+                case EndOfLineState.InTemplateHeadOrNoSubstitutionTemplate:
+                    text = "`\n" + text;
+                    offset = 2;
+                    break;
+                case EndOfLineState.InTemplateMiddleOrTail:
+                    text = "}\n" + text;
+                    offset = 2;
+                // fallthrough
+                case EndOfLineState.InTemplateSubstitutionPosition:
+                    templateStack.push(SyntaxKind.TemplateHead);
+                    break;
+            }
+
+            scanner.setText(text);
+
+            const result: Classifications = {
+                endOfLineState: EndOfLineState.None,
+                spans: []
+            };
+
+            // We can run into an unfortunate interaction between the lexical and syntactic classifier
+            // when the user is typing something generic.  Consider the case where the user types:
+            //
+            //      Foo<number
+            //
+            // From the lexical classifier's perspective, 'number' is a keyword, and so the word will
+            // be classified as such.  However, from the syntactic classifier's tree-based perspective
+            // this is simply an expression with the identifier 'number' on the RHS of the less than
+            // token.  So the classification will go back to being an identifier.  The moment the user
+            // types again, number will become a keyword, then an identifier, etc. etc.
+            //
+            // To try to avoid this problem, we avoid classifying contextual keywords as keywords
+            // when the user is potentially typing something generic.  We just can't do a good enough
+            // job at the lexical level, and so well leave it up to the syntactic classifier to make
+            // the determination.
+            //
+            // In order to determine if the user is potentially typing something generic, we use a
+            // weak heuristic where we track < and > tokens.  It's a weak heuristic, but should
+            // work well enough in practice.
+            let angleBracketStack = 0;
+
+            do {
+                token = scanner.scan();
+
+                if (!isTrivia(token)) {
+                    if ((token === SyntaxKind.SlashToken || token === SyntaxKind.SlashEqualsToken) && !noRegexTable[lastNonTriviaToken]) {
+                        if (scanner.reScanSlashToken() === SyntaxKind.RegularExpressionLiteral) {
+                            token = SyntaxKind.RegularExpressionLiteral;
+                        }
+                    }
+                    else if (lastNonTriviaToken === SyntaxKind.DotToken && isKeyword(token)) {
+                        token = SyntaxKind.Identifier;
+                    }
+                    else if (isKeyword(lastNonTriviaToken) && isKeyword(token) && !canFollow(lastNonTriviaToken, token)) {
+                        // We have two keywords in a row.  Only treat the second as a keyword if
+                        // it's a sequence that could legally occur in the language.  Otherwise
+                        // treat it as an identifier.  This way, if someone writes "private var"
+                        // we recognize that 'var' is actually an identifier here.
+                        token = SyntaxKind.Identifier;
+                    }
+                    else if (lastNonTriviaToken === SyntaxKind.Identifier &&
+                        token === SyntaxKind.LessThanToken) {
+                        // Could be the start of something generic.  Keep track of that by bumping
+                        // up the current count of generic contexts we may be in.
+                        angleBracketStack++;
+                    }
+                    else if (token === SyntaxKind.GreaterThanToken && angleBracketStack > 0) {
+                        // If we think we're currently in something generic, then mark that that
+                        // generic entity is complete.
+                        angleBracketStack--;
+                    }
+                    else if (token === SyntaxKind.AnyKeyword ||
+                        token === SyntaxKind.StringKeyword ||
+                        token === SyntaxKind.NumberKeyword ||
+                        token === SyntaxKind.BooleanKeyword ||
+                        token === SyntaxKind.SymbolKeyword) {
+                        if (angleBracketStack > 0 && !syntacticClassifierAbsent) {
+                            // If it looks like we're could be in something generic, don't classify this
+                            // as a keyword.  We may just get overwritten by the syntactic classifier,
+                            // causing a noisy experience for the user.
+                            token = SyntaxKind.Identifier;
+                        }
+                    }
+                    else if (token === SyntaxKind.TemplateHead) {
+                        templateStack.push(token);
+                    }
+                    else if (token === SyntaxKind.OpenBraceToken) {
+                        // If we don't have anything on the template stack,
+                        // then we aren't trying to keep track of a previously scanned template head.
+                        if (templateStack.length > 0) {
+                            templateStack.push(token);
+                        }
+                    }
+                    else if (token === SyntaxKind.CloseBraceToken) {
+                        // If we don't have anything on the template stack,
+                        // then we aren't trying to keep track of a previously scanned template head.
+                        if (templateStack.length > 0) {
+                            const lastTemplateStackToken = lastOrUndefined(templateStack);
+
+                            if (lastTemplateStackToken === SyntaxKind.TemplateHead) {
+                                token = scanner.reScanTemplateToken();
+
+                                // Only pop on a TemplateTail; a TemplateMiddle indicates there is more for us.
+                                if (token === SyntaxKind.TemplateTail) {
+                                    templateStack.pop();
+                                }
+                                else {
+                                    Debug.assert(token === SyntaxKind.TemplateMiddle, "Should have been a template middle. Was " + token);
+                                }
+                            }
+                            else {
+                                Debug.assert(lastTemplateStackToken === SyntaxKind.OpenBraceToken, "Should have been an open brace. Was: " + token);
+                                templateStack.pop();
+                            }
+                        }
+                    }
+
+                    lastNonTriviaToken = token;
+                }
+
+                processToken();
+            }
+            while (token !== SyntaxKind.EndOfFileToken);
+
+            return result;
+
+            function processToken(): void {
+                const start = scanner.getTokenPos();
+                const end = scanner.getTextPos();
+
+                addResult(start, end, classFromKind(token));
+
+                if (end >= text.length) {
+                    if (token === SyntaxKind.StringLiteral) {
+                        // Check to see if we finished up on a multiline string literal.
+                        const tokenText = scanner.getTokenText();
+                        if (scanner.isUnterminated()) {
+                            const lastCharIndex = tokenText.length - 1;
+
+                            let numBackslashes = 0;
+                            while (tokenText.charCodeAt(lastCharIndex - numBackslashes) === CharacterCodes.backslash) {
+                                numBackslashes++;
+                            }
+
+                            // If we have an odd number of backslashes, then the multiline string is unclosed
+                            if (numBackslashes & 1) {
+                                const quoteChar = tokenText.charCodeAt(0);
+                                result.endOfLineState = quoteChar === CharacterCodes.doubleQuote
+                                    ? EndOfLineState.InDoubleQuoteStringLiteral
+                                    : EndOfLineState.InSingleQuoteStringLiteral;
+                            }
+                        }
+                    }
+                    else if (token === SyntaxKind.MultiLineCommentTrivia) {
+                        // Check to see if the multiline comment was unclosed.
+                        if (scanner.isUnterminated()) {
+                            result.endOfLineState = EndOfLineState.InMultiLineCommentTrivia;
+                        }
+                    }
+                    else if (isTemplateLiteralKind(token)) {
+                        if (scanner.isUnterminated()) {
+                            if (token === SyntaxKind.TemplateTail) {
+                                result.endOfLineState = EndOfLineState.InTemplateMiddleOrTail;
+                            }
+                            else if (token === SyntaxKind.NoSubstitutionTemplateLiteral) {
+                                result.endOfLineState = EndOfLineState.InTemplateHeadOrNoSubstitutionTemplate;
+                            }
+                            else {
+                                Debug.fail("Only 'NoSubstitutionTemplateLiteral's and 'TemplateTail's can be unterminated; got SyntaxKind #" + token);
+                            }
+                        }
+                    }
+                    else if (templateStack.length > 0 && lastOrUndefined(templateStack) === SyntaxKind.TemplateHead) {
+                        result.endOfLineState = EndOfLineState.InTemplateSubstitutionPosition;
+                    }
+                }
+            }
+
+            function addResult(start: number, end: number, classification: ClassificationType): void {
+                if (classification === ClassificationType.whiteSpace) {
+                    // Don't bother with whitespace classifications.  They're not needed.
+                    return;
+                }
+
+                if (start === 0 && offset > 0) {
+                    // We're classifying the first token, and this was a case where we prepended
+                    // text.  We should consider the start of this token to be at the start of
+                    // the original text.
+                    start += offset;
+                }
+
+                // All our tokens are in relation to the augmented text.  Move them back to be
+                // relative to the original text.
+                start -= offset;
+                end -= offset;
+                const length = end - start;
+
+                if (length > 0) {
+                    result.spans.push(start);
+                    result.spans.push(length);
+                    result.spans.push(classification);
+                }
+            }
+        }
+
+        function isBinaryExpressionOperatorToken(token: SyntaxKind): boolean {
+            switch (token) {
+                case SyntaxKind.AsteriskToken:
+                case SyntaxKind.SlashToken:
+                case SyntaxKind.PercentToken:
+                case SyntaxKind.PlusToken:
+                case SyntaxKind.MinusToken:
+                case SyntaxKind.LessThanLessThanToken:
+                case SyntaxKind.GreaterThanGreaterThanToken:
+                case SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
+                case SyntaxKind.LessThanToken:
+                case SyntaxKind.GreaterThanToken:
+                case SyntaxKind.LessThanEqualsToken:
+                case SyntaxKind.GreaterThanEqualsToken:
+                case SyntaxKind.InstanceOfKeyword:
+                case SyntaxKind.InKeyword:
+                case SyntaxKind.AsKeyword:
+                case SyntaxKind.EqualsEqualsToken:
+                case SyntaxKind.ExclamationEqualsToken:
+                case SyntaxKind.EqualsEqualsEqualsToken:
+                case SyntaxKind.ExclamationEqualsEqualsToken:
+                case SyntaxKind.AmpersandToken:
+                case SyntaxKind.CaretToken:
+                case SyntaxKind.BarToken:
+                case SyntaxKind.AmpersandAmpersandToken:
+                case SyntaxKind.BarBarToken:
+                case SyntaxKind.BarEqualsToken:
+                case SyntaxKind.AmpersandEqualsToken:
+                case SyntaxKind.CaretEqualsToken:
+                case SyntaxKind.LessThanLessThanEqualsToken:
+                case SyntaxKind.GreaterThanGreaterThanEqualsToken:
+                case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
+                case SyntaxKind.PlusEqualsToken:
+                case SyntaxKind.MinusEqualsToken:
+                case SyntaxKind.AsteriskEqualsToken:
+                case SyntaxKind.SlashEqualsToken:
+                case SyntaxKind.PercentEqualsToken:
+                case SyntaxKind.EqualsToken:
+                case SyntaxKind.CommaToken:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        function isPrefixUnaryExpressionOperatorToken(token: SyntaxKind): boolean {
+            switch (token) {
+                case SyntaxKind.PlusToken:
+                case SyntaxKind.MinusToken:
+                case SyntaxKind.TildeToken:
+                case SyntaxKind.ExclamationToken:
+                case SyntaxKind.PlusPlusToken:
+                case SyntaxKind.MinusMinusToken:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        function isKeyword(token: SyntaxKind): boolean {
+            return token >= SyntaxKind.FirstKeyword && token <= SyntaxKind.LastKeyword;
+        }
+
+        function classFromKind(token: SyntaxKind): ClassificationType {
+            if (isKeyword(token)) {
+                return ClassificationType.keyword;
+            }
+            else if (isBinaryExpressionOperatorToken(token) || isPrefixUnaryExpressionOperatorToken(token)) {
+                return ClassificationType.operator;
+            }
+            else if (token >= SyntaxKind.FirstPunctuation && token <= SyntaxKind.LastPunctuation) {
+                return ClassificationType.punctuation;
+            }
+
+            switch (token) {
+                case SyntaxKind.NumericLiteral:
+                    return ClassificationType.numericLiteral;
+                case SyntaxKind.StringLiteral:
+                    return ClassificationType.stringLiteral;
+                case SyntaxKind.RegularExpressionLiteral:
+                    return ClassificationType.regularExpressionLiteral;
+                case SyntaxKind.ConflictMarkerTrivia:
+                case SyntaxKind.MultiLineCommentTrivia:
+                case SyntaxKind.SingleLineCommentTrivia:
+                    return ClassificationType.comment;
+                case SyntaxKind.WhitespaceTrivia:
+                case SyntaxKind.NewLineTrivia:
+                    return ClassificationType.whiteSpace;
+                case SyntaxKind.Identifier:
+                default:
+                    if (isTemplateLiteralKind(token)) {
+                        return ClassificationType.stringLiteral;
+                    }
+                    return ClassificationType.identifier;
+            }
+        }
+
+        return {
+            getClassificationsForLine,
+            getEncodedLexicalClassifications
+        };
+    }
+
+    export function getSemanticClassifications(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFile: SourceFile, classifiableNames: Map<string>, span: TextSpan): ClassifiedSpan[] {
+        return convertClassifications(getEncodedSemanticClassifications(typeChecker, cancellationToken, sourceFile, classifiableNames, span));
+    }
+
+    function checkForClassificationCancellation(cancellationToken: CancellationToken, kind: SyntaxKind) {
+        // We don't want to actually call back into our host on every node to find out if we've
+        // been canceled.  That would be an enormous amount of chattyness, along with the all
+        // the overhead of marshalling the data to/from the host.  So instead we pick a few
+        // reasonable node kinds to bother checking on.  These node kinds represent high level
+        // constructs that we would expect to see commonly, but just at a far less frequent
+        // interval.
+        //
+        // For example, in checker.ts (around 750k) we only have around 600 of these constructs.
+        // That means we're calling back into the host around every 1.2k of the file we process.
+        // Lib.d.ts has similar numbers.
+        switch (kind) {
+            case SyntaxKind.ModuleDeclaration:
+            case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.InterfaceDeclaration:
+            case SyntaxKind.FunctionDeclaration:
+                cancellationToken.throwIfCancellationRequested();
+        }
+    }
+
+    export function getEncodedSemanticClassifications(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFile: SourceFile, classifiableNames: Map<string>, span: TextSpan): Classifications {
+        const result: number[] = [];
+        processNode(sourceFile);
+
+        return { spans: result, endOfLineState: EndOfLineState.None };
+
+        function pushClassification(start: number, length: number, type: ClassificationType) {
+            result.push(start);
+            result.push(length);
+            result.push(type);
+        }
+
+        function classifySymbol(symbol: Symbol, meaningAtPosition: SemanticMeaning): ClassificationType {
+            const flags = symbol.getFlags();
+            if ((flags & SymbolFlags.Classifiable) === SymbolFlags.None) {
+                return;
+            }
+
+            if (flags & SymbolFlags.Class) {
+                return ClassificationType.className;
+            }
+            else if (flags & SymbolFlags.Enum) {
+                return ClassificationType.enumName;
+            }
+            else if (flags & SymbolFlags.TypeAlias) {
+                return ClassificationType.typeAliasName;
+            }
+            else if (meaningAtPosition & SemanticMeaning.Type) {
+                if (flags & SymbolFlags.Interface) {
+                    return ClassificationType.interfaceName;
+                }
+                else if (flags & SymbolFlags.TypeParameter) {
+                    return ClassificationType.typeParameterName;
+                }
+            }
+            else if (flags & SymbolFlags.Module) {
+                // Only classify a module as such if
+                //  - It appears in a namespace context.
+                //  - There exists a module declaration which actually impacts the value side.
+                if (meaningAtPosition & SemanticMeaning.Namespace ||
+                    (meaningAtPosition & SemanticMeaning.Value && hasValueSideModule(symbol))) {
+                    return ClassificationType.moduleName;
+                }
+            }
+
+            return undefined;
+
+            /**
+             * Returns true if there exists a module that introduces entities on the value side.
+             */
+            function hasValueSideModule(symbol: Symbol): boolean {
+                return forEach(symbol.declarations, declaration => {
+                    return declaration.kind === SyntaxKind.ModuleDeclaration &&
+                        getModuleInstanceState(declaration) === ModuleInstanceState.Instantiated;
+                });
+            }
+        }
+
+        function processNode(node: Node) {
+            // Only walk into nodes that intersect the requested span.
+            if (node && textSpanIntersectsWith(span, node.getFullStart(), node.getFullWidth())) {
+                const kind = node.kind;
+                checkForClassificationCancellation(cancellationToken, kind);
+
+                if (kind === SyntaxKind.Identifier && !nodeIsMissing(node)) {
+                    const identifier = <Identifier>node;
+
+                    // Only bother calling into the typechecker if this is an identifier that
+                    // could possibly resolve to a type name.  This makes classification run
+                    // in a third of the time it would normally take.
+                    if (classifiableNames[identifier.text]) {
+                        const symbol = typeChecker.getSymbolAtLocation(node);
+                        if (symbol) {
+                            const type = classifySymbol(symbol, getMeaningFromLocation(node));
+                            if (type) {
+                                pushClassification(node.getStart(), node.getWidth(), type);
+                            }
+                        }
+                    }
+                }
+
+                forEachChild(node, processNode);
+            }
+        }
+    }
+
+    function getClassificationTypeName(type: ClassificationType) {
+        switch (type) {
+            case ClassificationType.comment: return ClassificationTypeNames.comment;
+            case ClassificationType.identifier: return ClassificationTypeNames.identifier;
+            case ClassificationType.keyword: return ClassificationTypeNames.keyword;
+            case ClassificationType.numericLiteral: return ClassificationTypeNames.numericLiteral;
+            case ClassificationType.operator: return ClassificationTypeNames.operator;
+            case ClassificationType.stringLiteral: return ClassificationTypeNames.stringLiteral;
+            case ClassificationType.whiteSpace: return ClassificationTypeNames.whiteSpace;
+            case ClassificationType.text: return ClassificationTypeNames.text;
+            case ClassificationType.punctuation: return ClassificationTypeNames.punctuation;
+            case ClassificationType.className: return ClassificationTypeNames.className;
+            case ClassificationType.enumName: return ClassificationTypeNames.enumName;
+            case ClassificationType.interfaceName: return ClassificationTypeNames.interfaceName;
+            case ClassificationType.moduleName: return ClassificationTypeNames.moduleName;
+            case ClassificationType.typeParameterName: return ClassificationTypeNames.typeParameterName;
+            case ClassificationType.typeAliasName: return ClassificationTypeNames.typeAliasName;
+            case ClassificationType.parameterName: return ClassificationTypeNames.parameterName;
+            case ClassificationType.docCommentTagName: return ClassificationTypeNames.docCommentTagName;
+            case ClassificationType.jsxOpenTagName: return ClassificationTypeNames.jsxOpenTagName;
+            case ClassificationType.jsxCloseTagName: return ClassificationTypeNames.jsxCloseTagName;
+            case ClassificationType.jsxSelfClosingTagName: return ClassificationTypeNames.jsxSelfClosingTagName;
+            case ClassificationType.jsxAttribute: return ClassificationTypeNames.jsxAttribute;
+            case ClassificationType.jsxText: return ClassificationTypeNames.jsxText;
+            case ClassificationType.jsxAttributeStringLiteralValue: return ClassificationTypeNames.jsxAttributeStringLiteralValue;
+        }
+    }
+
+    function convertClassifications(classifications: Classifications): ClassifiedSpan[] {
+        Debug.assert(classifications.spans.length % 3 === 0);
+        const dense = classifications.spans;
+        const result: ClassifiedSpan[] = [];
+        for (let i = 0, n = dense.length; i < n; i += 3) {
+            result.push({
+                textSpan: createTextSpan(dense[i], dense[i + 1]),
+                classificationType: getClassificationTypeName(dense[i + 2])
+            });
+        }
+
+        return result;
+    }
+
+    export function getSyntacticClassifications(cancellationToken: CancellationToken, sourceFile: SourceFile, span: TextSpan): ClassifiedSpan[] {
+        return convertClassifications(getEncodedSyntacticClassifications(cancellationToken, sourceFile, span));
+    }
+
+    export function getEncodedSyntacticClassifications(cancellationToken: CancellationToken, sourceFile: SourceFile, span: TextSpan): Classifications {
+        const spanStart = span.start;
+        const spanLength = span.length;
+
+        // Make a scanner we can get trivia from.
+        const triviaScanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false, sourceFile.languageVariant, sourceFile.text);
+        const mergeConflictScanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false, sourceFile.languageVariant, sourceFile.text);
+
+        const result: number[] = [];
+        processElement(sourceFile);
+
+        return { spans: result, endOfLineState: EndOfLineState.None };
+
+        function pushClassification(start: number, length: number, type: ClassificationType) {
+            result.push(start);
+            result.push(length);
+            result.push(type);
+        }
+
+        function classifyLeadingTriviaAndGetTokenStart(token: Node): number {
+            triviaScanner.setTextPos(token.pos);
+            while (true) {
+                const start = triviaScanner.getTextPos();
+                // only bother scanning if we have something that could be trivia.
+                if (!couldStartTrivia(sourceFile.text, start)) {
+                    return start;
+                }
+
+                const kind = triviaScanner.scan();
+                const end = triviaScanner.getTextPos();
+                const width = end - start;
+
+                // The moment we get something that isn't trivia, then stop processing.
+                if (!isTrivia(kind)) {
+                    return start;
+                }
+
+                // Don't bother with newlines/whitespace.
+                if (kind === SyntaxKind.NewLineTrivia || kind === SyntaxKind.WhitespaceTrivia) {
+                    continue;
+                }
+
+                // Only bother with the trivia if it at least intersects the span of interest.
+                if (isComment(kind)) {
+                    classifyComment(token, kind, start, width);
+
+                    // Classifying a comment might cause us to reuse the trivia scanner
+                    // (because of jsdoc comments).  So after we classify the comment make
+                    // sure we set the scanner position back to where it needs to be.
+                    triviaScanner.setTextPos(end);
+                    continue;
+                }
+
+                if (kind === SyntaxKind.ConflictMarkerTrivia) {
+                    const text = sourceFile.text;
+                    const ch = text.charCodeAt(start);
+
+                    // for the <<<<<<< and >>>>>>> markers, we just add them in as comments
+                    // in the classification stream.
+                    if (ch === CharacterCodes.lessThan || ch === CharacterCodes.greaterThan) {
+                        pushClassification(start, width, ClassificationType.comment);
+                        continue;
+                    }
+
+                    // for the ======== add a comment for the first line, and then lex all
+                    // subsequent lines up until the end of the conflict marker.
+                    Debug.assert(ch === CharacterCodes.equals);
+                    classifyDisabledMergeCode(text, start, end);
+                }
+            }
+        }
+
+        function classifyComment(token: Node, kind: SyntaxKind, start: number, width: number) {
+            if (kind === SyntaxKind.MultiLineCommentTrivia) {
+                // See if this is a doc comment.  If so, we'll classify certain portions of it
+                // specially.
+                const docCommentAndDiagnostics = parseIsolatedJSDocComment(sourceFile.text, start, width);
+                if (docCommentAndDiagnostics && docCommentAndDiagnostics.jsDocComment) {
+                    docCommentAndDiagnostics.jsDocComment.parent = token;
+                    classifyJSDocComment(docCommentAndDiagnostics.jsDocComment);
+                    return;
+                }
+            }
+
+            // Simple comment.  Just add as is.
+            pushCommentRange(start, width);
+        }
+
+        function pushCommentRange(start: number, width: number) {
+            pushClassification(start, width, ClassificationType.comment);
+        }
+
+        function classifyJSDocComment(docComment: JSDocComment) {
+            let pos = docComment.pos;
+
+            for (const tag of docComment.tags) {
+                // As we walk through each tag, classify the portion of text from the end of
+                // the last tag (or the start of the entire doc comment) as 'comment'.
+                if (tag.pos !== pos) {
+                    pushCommentRange(pos, tag.pos - pos);
+                }
+
+                pushClassification(tag.atToken.pos, tag.atToken.end - tag.atToken.pos, ClassificationType.punctuation);
+                pushClassification(tag.tagName.pos, tag.tagName.end - tag.tagName.pos, ClassificationType.docCommentTagName);
+
+                pos = tag.tagName.end;
+
+                switch (tag.kind) {
+                    case SyntaxKind.JSDocParameterTag:
+                        processJSDocParameterTag(<JSDocParameterTag>tag);
+                        break;
+                    case SyntaxKind.JSDocTemplateTag:
+                        processJSDocTemplateTag(<JSDocTemplateTag>tag);
+                        break;
+                    case SyntaxKind.JSDocTypeTag:
+                        processElement((<JSDocTypeTag>tag).typeExpression);
+                        break;
+                    case SyntaxKind.JSDocReturnTag:
+                        processElement((<JSDocReturnTag>tag).typeExpression);
+                        break;
+                }
+
+                pos = tag.end;
+            }
+
+            if (pos !== docComment.end) {
+                pushCommentRange(pos, docComment.end - pos);
+            }
+
+            return;
+
+            function processJSDocParameterTag(tag: JSDocParameterTag) {
+                if (tag.preParameterName) {
+                    pushCommentRange(pos, tag.preParameterName.pos - pos);
+                    pushClassification(tag.preParameterName.pos, tag.preParameterName.end - tag.preParameterName.pos, ClassificationType.parameterName);
+                    pos = tag.preParameterName.end;
+                }
+
+                if (tag.typeExpression) {
+                    pushCommentRange(pos, tag.typeExpression.pos - pos);
+                    processElement(tag.typeExpression);
+                    pos = tag.typeExpression.end;
+                }
+
+                if (tag.postParameterName) {
+                    pushCommentRange(pos, tag.postParameterName.pos - pos);
+                    pushClassification(tag.postParameterName.pos, tag.postParameterName.end - tag.postParameterName.pos, ClassificationType.parameterName);
+                    pos = tag.postParameterName.end;
+                }
+            }
+        }
+
+        function processJSDocTemplateTag(tag: JSDocTemplateTag) {
+            for (const child of tag.getChildren()) {
+                processElement(child);
+            }
+        }
+
+        function classifyDisabledMergeCode(text: string, start: number, end: number) {
+            // Classify the line that the ======= marker is on as a comment.  Then just lex
+            // all further tokens and add them to the result.
+            let i: number;
+            for (i = start; i < end; i++) {
+                if (isLineBreak(text.charCodeAt(i))) {
+                    break;
+                }
+            }
+            pushClassification(start, i - start, ClassificationType.comment);
+            mergeConflictScanner.setTextPos(i);
+
+            while (mergeConflictScanner.getTextPos() < end) {
+                classifyDisabledCodeToken();
+            }
+        }
+
+        function classifyDisabledCodeToken() {
+            const start = mergeConflictScanner.getTextPos();
+            const tokenKind = mergeConflictScanner.scan();
+            const end = mergeConflictScanner.getTextPos();
+
+            const type = classifyTokenType(tokenKind);
+            if (type) {
+                pushClassification(start, end - start, type);
+            }
+        }
+
+        /**
+         * Returns true if node should be treated as classified and no further processing is required.
+         * False will mean that node is not classified and traverse routine should recurse into node contents.
+         */
+        function tryClassifyNode(node: Node): boolean {
+            if (isJSDocTag(node)) {
+                return true;
+            }
+
+            if (nodeIsMissing(node)) {
+                return true;
+            }
+
+            const classifiedElementName = tryClassifyJsxElementName(node);
+            if (!isToken(node) && node.kind !== SyntaxKind.JsxText && classifiedElementName === undefined) {
+                return false;
+            }
+
+            const tokenStart = node.kind === SyntaxKind.JsxText ? node.pos : classifyLeadingTriviaAndGetTokenStart(node);
+
+            const tokenWidth = node.end - tokenStart;
+            Debug.assert(tokenWidth >= 0);
+            if (tokenWidth > 0) {
+                const type = classifiedElementName || classifyTokenType(node.kind, node);
+                if (type) {
+                    pushClassification(tokenStart, tokenWidth, type);
+                }
+            }
+
+            return true;
+        }
+
+        function tryClassifyJsxElementName(token: Node): ClassificationType {
+            switch (token.parent && token.parent.kind) {
+                case SyntaxKind.JsxOpeningElement:
+                    if ((<JsxOpeningElement>token.parent).tagName === token) {
+                        return ClassificationType.jsxOpenTagName;
+                    }
+                    break;
+                case SyntaxKind.JsxClosingElement:
+                    if ((<JsxClosingElement>token.parent).tagName === token) {
+                        return ClassificationType.jsxCloseTagName;
+                    }
+                    break;
+                case SyntaxKind.JsxSelfClosingElement:
+                    if ((<JsxSelfClosingElement>token.parent).tagName === token) {
+                        return ClassificationType.jsxSelfClosingTagName;
+                    }
+                    break;
+                case SyntaxKind.JsxAttribute:
+                    if ((<JsxAttribute>token.parent).name === token) {
+                        return ClassificationType.jsxAttribute;
+                    }
+                    break;
+            }
+            return undefined;
+        }
+
+        // for accurate classification, the actual token should be passed in.  however, for
+        // cases like 'disabled merge code' classification, we just get the token kind and
+        // classify based on that instead.
+        function classifyTokenType(tokenKind: SyntaxKind, token?: Node): ClassificationType {
+            if (isKeyword(tokenKind)) {
+                return ClassificationType.keyword;
+            }
+
+            // Special case < and >  If they appear in a generic context they are punctuation,
+            // not operators.
+            if (tokenKind === SyntaxKind.LessThanToken || tokenKind === SyntaxKind.GreaterThanToken) {
+                // If the node owning the token has a type argument list or type parameter list, then
+                // we can effectively assume that a '<' and '>' belong to those lists.
+                if (token && getTypeArgumentOrTypeParameterList(token.parent)) {
+                    return ClassificationType.punctuation;
+                }
+            }
+
+            if (isPunctuation(tokenKind)) {
+                if (token) {
+                    if (tokenKind === SyntaxKind.EqualsToken) {
+                        // the '=' in a variable declaration is special cased here.
+                        if (token.parent.kind === SyntaxKind.VariableDeclaration ||
+                            token.parent.kind === SyntaxKind.PropertyDeclaration ||
+                            token.parent.kind === SyntaxKind.Parameter ||
+                            token.parent.kind === SyntaxKind.JsxAttribute) {
+                            return ClassificationType.operator;
+                        }
+                    }
+
+                    if (token.parent.kind === SyntaxKind.BinaryExpression ||
+                        token.parent.kind === SyntaxKind.PrefixUnaryExpression ||
+                        token.parent.kind === SyntaxKind.PostfixUnaryExpression ||
+                        token.parent.kind === SyntaxKind.ConditionalExpression) {
+                        return ClassificationType.operator;
+                    }
+                }
+
+                return ClassificationType.punctuation;
+            }
+            else if (tokenKind === SyntaxKind.NumericLiteral) {
+                return ClassificationType.numericLiteral;
+            }
+            else if (tokenKind === SyntaxKind.StringLiteral) {
+                return token.parent.kind === SyntaxKind.JsxAttribute ? ClassificationType.jsxAttributeStringLiteralValue : ClassificationType.stringLiteral;
+            }
+            else if (tokenKind === SyntaxKind.RegularExpressionLiteral) {
+                // TODO: we should get another classification type for these literals.
+                return ClassificationType.stringLiteral;
+            }
+            else if (isTemplateLiteralKind(tokenKind)) {
+                // TODO (drosen): we should *also* get another classification type for these literals.
+                return ClassificationType.stringLiteral;
+            }
+            else if (tokenKind === SyntaxKind.JsxText) {
+                return ClassificationType.jsxText;
+            }
+            else if (tokenKind === SyntaxKind.Identifier) {
+                if (token) {
+                    switch (token.parent.kind) {
+                        case SyntaxKind.ClassDeclaration:
+                            if ((<ClassDeclaration>token.parent).name === token) {
+                                return ClassificationType.className;
+                            }
+                            return;
+                        case SyntaxKind.TypeParameter:
+                            if ((<TypeParameterDeclaration>token.parent).name === token) {
+                                return ClassificationType.typeParameterName;
+                            }
+                            return;
+                        case SyntaxKind.InterfaceDeclaration:
+                            if ((<InterfaceDeclaration>token.parent).name === token) {
+                                return ClassificationType.interfaceName;
+                            }
+                            return;
+                        case SyntaxKind.EnumDeclaration:
+                            if ((<EnumDeclaration>token.parent).name === token) {
+                                return ClassificationType.enumName;
+                            }
+                            return;
+                        case SyntaxKind.ModuleDeclaration:
+                            if ((<ModuleDeclaration>token.parent).name === token) {
+                                return ClassificationType.moduleName;
+                            }
+                            return;
+                        case SyntaxKind.Parameter:
+                            if ((<ParameterDeclaration>token.parent).name === token) {
+                                const isThis = token.kind === SyntaxKind.Identifier && (<Identifier>token).originalKeywordKind === SyntaxKind.ThisKeyword;
+                                return isThis ? ClassificationType.keyword : ClassificationType.parameterName;
+                            }
+                            return;
+                    }
+                }
+                return ClassificationType.identifier;
+            }
+        }
+
+        function processElement(element: Node) {
+            if (!element) {
+                return;
+            }
+
+            // Ignore nodes that don't intersect the original span to classify.
+            if (decodedTextSpanIntersectsWith(spanStart, spanLength, element.pos, element.getFullWidth())) {
+                checkForClassificationCancellation(cancellationToken, element.kind);
+
+                const children = element.getChildren(sourceFile);
+                for (let i = 0, n = children.length; i < n; i++) {
+                    const child = children[i];
+                    if (!tryClassifyNode(child)) {
+                        // Recurse into our child nodes.
+                        processElement(child);
+                    }
+                }
+            }
+        }
+    }
+}

src/services/documentHighlights.ts

@@ -0,0 +1,638 @@
+/* @internal */
+namespace ts.DocumentHighlights {
+    export function getDocumentHighlights(typeChecker: TypeChecker, cancellationToken: CancellationToken, sourceFile: SourceFile, position: number, sourceFilesToSearch: SourceFile[]): DocumentHighlights[] {
+        const node = getTouchingWord(sourceFile, position);
+        if (!node) {
+            return undefined;
+        }
+
+        return getSemanticDocumentHighlights(node) || getSyntacticDocumentHighlights(node);
+
+        function getHighlightSpanForNode(node: Node): HighlightSpan {
+            const start = node.getStart();
+            const end = node.getEnd();
+
+            return {
+                fileName: sourceFile.fileName,
+                textSpan: createTextSpanFromBounds(start, end),
+                kind: HighlightSpanKind.none
+            };
+        }
+
+        function getSemanticDocumentHighlights(node: Node): DocumentHighlights[] {
+            if (node.kind === SyntaxKind.Identifier ||
+                node.kind === SyntaxKind.ThisKeyword ||
+                node.kind === SyntaxKind.ThisType ||
+                node.kind === SyntaxKind.SuperKeyword ||
+                node.kind === SyntaxKind.StringLiteral ||
+                isLiteralNameOfPropertyDeclarationOrIndexAccess(node)) {
+
+                const referencedSymbols = FindAllReferences.getReferencedSymbolsForNode(typeChecker, cancellationToken, node, sourceFilesToSearch, /*findInStrings*/ false, /*findInComments*/ false);
+                return convertReferencedSymbols(referencedSymbols);
+
+            }
+
+            return undefined;
+
+            function convertReferencedSymbols(referencedSymbols: ReferencedSymbol[]): DocumentHighlights[] {
+                if (!referencedSymbols) {
+                    return undefined;
+                }
+
+                const fileNameToDocumentHighlights = createMap<DocumentHighlights>();
+                const result: DocumentHighlights[] = [];
+                for (const referencedSymbol of referencedSymbols) {
+                    for (const referenceEntry of referencedSymbol.references) {
+                        const fileName = referenceEntry.fileName;
+                        let documentHighlights = fileNameToDocumentHighlights[fileName];
+                        if (!documentHighlights) {
+                            documentHighlights = { fileName, highlightSpans: [] };
+
+                            fileNameToDocumentHighlights[fileName] = documentHighlights;
+                            result.push(documentHighlights);
+                        }
+
+                        documentHighlights.highlightSpans.push({
+                            textSpan: referenceEntry.textSpan,
+                            kind: referenceEntry.isWriteAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference
+                        });
+                    }
+                }
+
+                return result;
+            }
+        }
+
+        function getSyntacticDocumentHighlights(node: Node): DocumentHighlights[] {
+            const fileName = sourceFile.fileName;
+
+            const highlightSpans = getHighlightSpans(node);
+            if (!highlightSpans || highlightSpans.length === 0) {
+                return undefined;
+            }
+
+            return [{ fileName, highlightSpans }];
+
+            // returns true if 'node' is defined and has a matching 'kind'.
+            function hasKind(node: Node, kind: SyntaxKind) {
+                return node !== undefined && node.kind === kind;
+            }
+
+            // Null-propagating 'parent' function.
+            function parent(node: Node): Node {
+                return node && node.parent;
+            }
+
+            function getHighlightSpans(node: Node): HighlightSpan[] {
+                if (node) {
+                    switch (node.kind) {
+                        case SyntaxKind.IfKeyword:
+                        case SyntaxKind.ElseKeyword:
+                            if (hasKind(node.parent, SyntaxKind.IfStatement)) {
+                                return getIfElseOccurrences(<IfStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.ReturnKeyword:
+                            if (hasKind(node.parent, SyntaxKind.ReturnStatement)) {
+                                return getReturnOccurrences(<ReturnStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.ThrowKeyword:
+                            if (hasKind(node.parent, SyntaxKind.ThrowStatement)) {
+                                return getThrowOccurrences(<ThrowStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.CatchKeyword:
+                            if (hasKind(parent(parent(node)), SyntaxKind.TryStatement)) {
+                                return getTryCatchFinallyOccurrences(<TryStatement>node.parent.parent);
+                            }
+                            break;
+                        case SyntaxKind.TryKeyword:
+                        case SyntaxKind.FinallyKeyword:
+                            if (hasKind(parent(node), SyntaxKind.TryStatement)) {
+                                return getTryCatchFinallyOccurrences(<TryStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.SwitchKeyword:
+                            if (hasKind(node.parent, SyntaxKind.SwitchStatement)) {
+                                return getSwitchCaseDefaultOccurrences(<SwitchStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.CaseKeyword:
+                        case SyntaxKind.DefaultKeyword:
+                            if (hasKind(parent(parent(parent(node))), SyntaxKind.SwitchStatement)) {
+                                return getSwitchCaseDefaultOccurrences(<SwitchStatement>node.parent.parent.parent);
+                            }
+                            break;
+                        case SyntaxKind.BreakKeyword:
+                        case SyntaxKind.ContinueKeyword:
+                            if (hasKind(node.parent, SyntaxKind.BreakStatement) || hasKind(node.parent, SyntaxKind.ContinueStatement)) {
+                                return getBreakOrContinueStatementOccurrences(<BreakOrContinueStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.ForKeyword:
+                            if (hasKind(node.parent, SyntaxKind.ForStatement) ||
+                                hasKind(node.parent, SyntaxKind.ForInStatement) ||
+                                hasKind(node.parent, SyntaxKind.ForOfStatement)) {
+                                return getLoopBreakContinueOccurrences(<IterationStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.WhileKeyword:
+                        case SyntaxKind.DoKeyword:
+                            if (hasKind(node.parent, SyntaxKind.WhileStatement) || hasKind(node.parent, SyntaxKind.DoStatement)) {
+                                return getLoopBreakContinueOccurrences(<IterationStatement>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.ConstructorKeyword:
+                            if (hasKind(node.parent, SyntaxKind.Constructor)) {
+                                return getConstructorOccurrences(<ConstructorDeclaration>node.parent);
+                            }
+                            break;
+                        case SyntaxKind.GetKeyword:
+                        case SyntaxKind.SetKeyword:
+                            if (hasKind(node.parent, SyntaxKind.GetAccessor) || hasKind(node.parent, SyntaxKind.SetAccessor)) {
+                                return getGetAndSetOccurrences(<AccessorDeclaration>node.parent);
+                            }
+                            break;
+                        default:
+                            if (isModifierKind(node.kind) && node.parent &&
+                                (isDeclaration(node.parent) || node.parent.kind === SyntaxKind.VariableStatement)) {
+                                return getModifierOccurrences(node.kind, node.parent);
+                            }
+                    }
+                }
+
+                return undefined;
+            }
+
+            /**
+             * Aggregates all throw-statements within this node *without* crossing
+             * into function boundaries and try-blocks with catch-clauses.
+             */
+            function aggregateOwnedThrowStatements(node: Node): ThrowStatement[] {
+                const statementAccumulator: ThrowStatement[] = [];
+                aggregate(node);
+                return statementAccumulator;
+
+                function aggregate(node: Node): void {
+                    if (node.kind === SyntaxKind.ThrowStatement) {
+                        statementAccumulator.push(<ThrowStatement>node);
+                    }
+                    else if (node.kind === SyntaxKind.TryStatement) {
+                        const tryStatement = <TryStatement>node;
+
+                        if (tryStatement.catchClause) {
+                            aggregate(tryStatement.catchClause);
+                        }
+                        else {
+                            // Exceptions thrown within a try block lacking a catch clause
+                            // are "owned" in the current context.
+                            aggregate(tryStatement.tryBlock);
+                        }
+
+                        if (tryStatement.finallyBlock) {
+                            aggregate(tryStatement.finallyBlock);
+                        }
+                    }
+                    // Do not cross function boundaries.
+                    else if (!isFunctionLike(node)) {
+                        forEachChild(node, aggregate);
+                    }
+                }
+            }
+
+            /**
+             * For lack of a better name, this function takes a throw statement and returns the
+             * nearest ancestor that is a try-block (whose try statement has a catch clause),
+             * function-block, or source file.
+             */
+            function getThrowStatementOwner(throwStatement: ThrowStatement): Node {
+                let child: Node = throwStatement;
+
+                while (child.parent) {
+                    const parent = child.parent;
+
+                    if (isFunctionBlock(parent) || parent.kind === SyntaxKind.SourceFile) {
+                        return parent;
+                    }
+
+                    // A throw-statement is only owned by a try-statement if the try-statement has
+                    // a catch clause, and if the throw-statement occurs within the try block.
+                    if (parent.kind === SyntaxKind.TryStatement) {
+                        const tryStatement = <TryStatement>parent;
+
+                        if (tryStatement.tryBlock === child && tryStatement.catchClause) {
+                            return child;
+                        }
+                    }
+
+                    child = parent;
+                }
+
+                return undefined;
+            }
+
+            function aggregateAllBreakAndContinueStatements(node: Node): BreakOrContinueStatement[] {
+                const statementAccumulator: BreakOrContinueStatement[] = [];
+                aggregate(node);
+                return statementAccumulator;
+
+                function aggregate(node: Node): void {
+                    if (node.kind === SyntaxKind.BreakStatement || node.kind === SyntaxKind.ContinueStatement) {
+                        statementAccumulator.push(<BreakOrContinueStatement>node);
+                    }
+                    // Do not cross function boundaries.
+                    else if (!isFunctionLike(node)) {
+                        forEachChild(node, aggregate);
+                    }
+                }
+            }
+
+            function ownsBreakOrContinueStatement(owner: Node, statement: BreakOrContinueStatement): boolean {
+                const actualOwner = getBreakOrContinueOwner(statement);
+
+                return actualOwner && actualOwner === owner;
+            }
+
+            function getBreakOrContinueOwner(statement: BreakOrContinueStatement): Node {
+                for (let node = statement.parent; node; node = node.parent) {
+                    switch (node.kind) {
+                        case SyntaxKind.SwitchStatement:
+                            if (statement.kind === SyntaxKind.ContinueStatement) {
+                                continue;
+                            }
+                        // Fall through.
+                        case SyntaxKind.ForStatement:
+                        case SyntaxKind.ForInStatement:
+                        case SyntaxKind.ForOfStatement:
+                        case SyntaxKind.WhileStatement:
+                        case SyntaxKind.DoStatement:
+                            if (!statement.label || isLabeledBy(node, statement.label.text)) {
+                                return node;
+                            }
+                            break;
+                        default:
+                            // Don't cross function boundaries.
+                            if (isFunctionLike(node)) {
+                                return undefined;
+                            }
+                            break;
+                    }
+                }
+
+                return undefined;
+            }
+
+            function getModifierOccurrences(modifier: SyntaxKind, declaration: Node): HighlightSpan[] {
+                const container = declaration.parent;
+
+                // Make sure we only highlight the keyword when it makes sense to do so.
+                if (isAccessibilityModifier(modifier)) {
+                    if (!(container.kind === SyntaxKind.ClassDeclaration ||
+                        container.kind === SyntaxKind.ClassExpression ||
+                        (declaration.kind === SyntaxKind.Parameter && hasKind(container, SyntaxKind.Constructor)))) {
+                        return undefined;
+                    }
+                }
+                else if (modifier === SyntaxKind.StaticKeyword) {
+                    if (!(container.kind === SyntaxKind.ClassDeclaration || container.kind === SyntaxKind.ClassExpression)) {
+                        return undefined;
+                    }
+                }
+                else if (modifier === SyntaxKind.ExportKeyword || modifier === SyntaxKind.DeclareKeyword) {
+                    if (!(container.kind === SyntaxKind.ModuleBlock || container.kind === SyntaxKind.SourceFile)) {
+                        return undefined;
+                    }
+                }
+                else if (modifier === SyntaxKind.AbstractKeyword) {
+                    if (!(container.kind === SyntaxKind.ClassDeclaration || declaration.kind === SyntaxKind.ClassDeclaration)) {
+                        return undefined;
+                    }
+                }
+                else {
+                    // unsupported modifier
+                    return undefined;
+                }
+
+                const keywords: Node[] = [];
+                const modifierFlag: ModifierFlags = getFlagFromModifier(modifier);
+
+                let nodes: Node[];
+                switch (container.kind) {
+                    case SyntaxKind.ModuleBlock:
+                    case SyntaxKind.SourceFile:
+                        // Container is either a class declaration or the declaration is a classDeclaration
+                        if (modifierFlag & ModifierFlags.Abstract) {
+                            nodes = (<Node[]>(<ClassDeclaration>declaration).members).concat(declaration);
+                        }
+                        else {
+                            nodes = (<Block>container).statements;
+                        }
+                        break;
+                    case SyntaxKind.Constructor:
+                        nodes = (<Node[]>(<ConstructorDeclaration>container).parameters).concat(
+                            (<ClassDeclaration>container.parent).members);
+                        break;
+                    case SyntaxKind.ClassDeclaration:
+                    case SyntaxKind.ClassExpression:
+                        nodes = (<ClassLikeDeclaration>container).members;
+
+                        // If we're an accessibility modifier, we're in an instance member and should search
+                        // the constructor's parameter list for instance members as well.
+                        if (modifierFlag & ModifierFlags.AccessibilityModifier) {
+                            const constructor = forEach((<ClassLikeDeclaration>container).members, member => {
+                                return member.kind === SyntaxKind.Constructor && <ConstructorDeclaration>member;
+                            });
+
+                            if (constructor) {
+                                nodes = nodes.concat(constructor.parameters);
+                            }
+                        }
+                        else if (modifierFlag & ModifierFlags.Abstract) {
+                            nodes = nodes.concat(container);
+                        }
+                        break;
+                    default:
+                        Debug.fail("Invalid container kind.");
+                }
+
+                forEach(nodes, node => {
+                    if (getModifierFlags(node) & modifierFlag) {
+                        forEach(node.modifiers, child => pushKeywordIf(keywords, child, modifier));
+                    }
+                });
+
+                return map(keywords, getHighlightSpanForNode);
+
+                function getFlagFromModifier(modifier: SyntaxKind) {
+                    switch (modifier) {
+                        case SyntaxKind.PublicKeyword:
+                            return ModifierFlags.Public;
+                        case SyntaxKind.PrivateKeyword:
+                            return ModifierFlags.Private;
+                        case SyntaxKind.ProtectedKeyword:
+                            return ModifierFlags.Protected;
+                        case SyntaxKind.StaticKeyword:
+                            return ModifierFlags.Static;
+                        case SyntaxKind.ExportKeyword:
+                            return ModifierFlags.Export;
+                        case SyntaxKind.DeclareKeyword:
+                            return ModifierFlags.Ambient;
+                        case SyntaxKind.AbstractKeyword:
+                            return ModifierFlags.Abstract;
+                        default:
+                            Debug.fail();
+                    }
+                }
+            }
+
+            function pushKeywordIf(keywordList: Node[], token: Node, ...expected: SyntaxKind[]): boolean {
+                if (token && contains(expected, token.kind)) {
+                    keywordList.push(token);
+                    return true;
+                }
+
+                return false;
+            }
+
+            function getGetAndSetOccurrences(accessorDeclaration: AccessorDeclaration): HighlightSpan[] {
+                const keywords: Node[] = [];
+
+                tryPushAccessorKeyword(accessorDeclaration.symbol, SyntaxKind.GetAccessor);
+                tryPushAccessorKeyword(accessorDeclaration.symbol, SyntaxKind.SetAccessor);
+
+                return map(keywords, getHighlightSpanForNode);
+
+                function tryPushAccessorKeyword(accessorSymbol: Symbol, accessorKind: SyntaxKind): void {
+                    const accessor = getDeclarationOfKind(accessorSymbol, accessorKind);
+
+                    if (accessor) {
+                        forEach(accessor.getChildren(), child => pushKeywordIf(keywords, child, SyntaxKind.GetKeyword, SyntaxKind.SetKeyword));
+                    }
+                }
+            }
+
+            function getConstructorOccurrences(constructorDeclaration: ConstructorDeclaration): HighlightSpan[] {
+                const declarations = constructorDeclaration.symbol.getDeclarations();
+
+                const keywords: Node[] = [];
+
+                forEach(declarations, declaration => {
+                    forEach(declaration.getChildren(), token => {
+                        return pushKeywordIf(keywords, token, SyntaxKind.ConstructorKeyword);
+                    });
+                });
+
+                return map(keywords, getHighlightSpanForNode);
+            }
+
+            function getLoopBreakContinueOccurrences(loopNode: IterationStatement): HighlightSpan[] {
+                const keywords: Node[] = [];
+
+                if (pushKeywordIf(keywords, loopNode.getFirstToken(), SyntaxKind.ForKeyword, SyntaxKind.WhileKeyword, SyntaxKind.DoKeyword)) {
+                    // If we succeeded and got a do-while loop, then start looking for a 'while' keyword.
+                    if (loopNode.kind === SyntaxKind.DoStatement) {
+                        const loopTokens = loopNode.getChildren();
+
+                        for (let i = loopTokens.length - 1; i >= 0; i--) {
+                            if (pushKeywordIf(keywords, loopTokens[i], SyntaxKind.WhileKeyword)) {
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                const breaksAndContinues = aggregateAllBreakAndContinueStatements(loopNode.statement);
+
+                forEach(breaksAndContinues, statement => {
+                    if (ownsBreakOrContinueStatement(loopNode, statement)) {
+                        pushKeywordIf(keywords, statement.getFirstToken(), SyntaxKind.BreakKeyword, SyntaxKind.ContinueKeyword);
+                    }
+                });
+
+                return map(keywords, getHighlightSpanForNode);
+            }
+
+            function getBreakOrContinueStatementOccurrences(breakOrContinueStatement: BreakOrContinueStatement): HighlightSpan[] {
+                const owner = getBreakOrContinueOwner(breakOrContinueStatement);
+
+                if (owner) {
+                    switch (owner.kind) {
+                        case SyntaxKind.ForStatement:
+                        case SyntaxKind.ForInStatement:
+                        case SyntaxKind.ForOfStatement:
+                        case SyntaxKind.DoStatement:
+                        case SyntaxKind.WhileStatement:
+                            return getLoopBreakContinueOccurrences(<IterationStatement>owner);
+                        case SyntaxKind.SwitchStatement:
+                            return getSwitchCaseDefaultOccurrences(<SwitchStatement>owner);
+
+                    }
+                }
+
+                return undefined;
+            }
+
+            function getSwitchCaseDefaultOccurrences(switchStatement: SwitchStatement): HighlightSpan[] {
+                const keywords: Node[] = [];
+
+                pushKeywordIf(keywords, switchStatement.getFirstToken(), SyntaxKind.SwitchKeyword);
+
+                // Go through each clause in the switch statement, collecting the 'case'/'default' keywords.
+                forEach(switchStatement.caseBlock.clauses, clause => {
+                    pushKeywordIf(keywords, clause.getFirstToken(), SyntaxKind.CaseKeyword, SyntaxKind.DefaultKeyword);
+
+                    const breaksAndContinues = aggregateAllBreakAndContinueStatements(clause);
+
+                    forEach(breaksAndContinues, statement => {
+                        if (ownsBreakOrContinueStatement(switchStatement, statement)) {
+                            pushKeywordIf(keywords, statement.getFirstToken(), SyntaxKind.BreakKeyword);
+                        }
+                    });
+                });
+
+                return map(keywords, getHighlightSpanForNode);
+            }
+
+            function getTryCatchFinallyOccurrences(tryStatement: TryStatement): HighlightSpan[] {
+                const keywords: Node[] = [];
+
+                pushKeywordIf(keywords, tryStatement.getFirstToken(), SyntaxKind.TryKeyword);
+
+                if (tryStatement.catchClause) {
+                    pushKeywordIf(keywords, tryStatement.catchClause.getFirstToken(), SyntaxKind.CatchKeyword);
+                }
+
+                if (tryStatement.finallyBlock) {
+                    const finallyKeyword = findChildOfKind(tryStatement, SyntaxKind.FinallyKeyword, sourceFile);
+                    pushKeywordIf(keywords, finallyKeyword, SyntaxKind.FinallyKeyword);
+                }
+
+                return map(keywords, getHighlightSpanForNode);
+            }
+
+            function getThrowOccurrences(throwStatement: ThrowStatement): HighlightSpan[] {
+                const owner = getThrowStatementOwner(throwStatement);
+
+                if (!owner) {
+                    return undefined;
+                }
+
+                const keywords: Node[] = [];
+
+                forEach(aggregateOwnedThrowStatements(owner), throwStatement => {
+                    pushKeywordIf(keywords, throwStatement.getFirstToken(), SyntaxKind.ThrowKeyword);
+                });
+
+                // If the "owner" is a function, then we equate 'return' and 'throw' statements in their
+                // ability to "jump out" of the function, and include occurrences for both.
+                if (isFunctionBlock(owner)) {
+                    forEachReturnStatement(<Block>owner, returnStatement => {
+                        pushKeywordIf(keywords, returnStatement.getFirstToken(), SyntaxKind.ReturnKeyword);
+                    });
+                }
+
+                return map(keywords, getHighlightSpanForNode);
+            }
+
+            function getReturnOccurrences(returnStatement: ReturnStatement): HighlightSpan[] {
+                const func = <FunctionLikeDeclaration>getContainingFunction(returnStatement);
+
+                // If we didn't find a containing function with a block body, bail out.
+                if (!(func && hasKind(func.body, SyntaxKind.Block))) {
+                    return undefined;
+                }
+
+                const keywords: Node[] = [];
+                forEachReturnStatement(<Block>func.body, returnStatement => {
+                    pushKeywordIf(keywords, returnStatement.getFirstToken(), SyntaxKind.ReturnKeyword);
+                });
+
+                // Include 'throw' statements that do not occur within a try block.
+                forEach(aggregateOwnedThrowStatements(func.body), throwStatement => {
+                    pushKeywordIf(keywords, throwStatement.getFirstToken(), SyntaxKind.ThrowKeyword);
+                });
+
+                return map(keywords, getHighlightSpanForNode);
+            }
+
+            function getIfElseOccurrences(ifStatement: IfStatement): HighlightSpan[] {
+                const keywords: Node[] = [];
+
+                // Traverse upwards through all parent if-statements linked by their else-branches.
+                while (hasKind(ifStatement.parent, SyntaxKind.IfStatement) && (<IfStatement>ifStatement.parent).elseStatement === ifStatement) {
+                    ifStatement = <IfStatement>ifStatement.parent;
+                }
+
+                // Now traverse back down through the else branches, aggregating if/else keywords of if-statements.
+                while (ifStatement) {
+                    const children = ifStatement.getChildren();
+                    pushKeywordIf(keywords, children[0], SyntaxKind.IfKeyword);
+
+                    // Generally the 'else' keyword is second-to-last, so we traverse backwards.
+                    for (let i = children.length - 1; i >= 0; i--) {
+                        if (pushKeywordIf(keywords, children[i], SyntaxKind.ElseKeyword)) {
+                            break;
+                        }
+                    }
+
+                    if (!hasKind(ifStatement.elseStatement, SyntaxKind.IfStatement)) {
+                        break;
+                    }
+
+                    ifStatement = <IfStatement>ifStatement.elseStatement;
+                }
+
+                const result: HighlightSpan[] = [];
+
+                // We'd like to highlight else/ifs together if they are only separated by whitespace
+                // (i.e. the keywords are separated by no comments, no newlines).
+                for (let i = 0; i < keywords.length; i++) {
+                    if (keywords[i].kind === SyntaxKind.ElseKeyword && i < keywords.length - 1) {
+                        const elseKeyword = keywords[i];
+                        const ifKeyword = keywords[i + 1]; // this *should* always be an 'if' keyword.
+
+                        let shouldCombindElseAndIf = true;
+
+                        // Avoid recalculating getStart() by iterating backwards.
+                        for (let j = ifKeyword.getStart() - 1; j >= elseKeyword.end; j--) {
+                            if (!isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(j))) {
+                                shouldCombindElseAndIf = false;
+                                break;
+                            }
+                        }
+
+                        if (shouldCombindElseAndIf) {
+                            result.push({
+                                fileName: fileName,
+                                textSpan: createTextSpanFromBounds(elseKeyword.getStart(), ifKeyword.end),
+                                kind: HighlightSpanKind.reference
+                            });
+                            i++; // skip the next keyword
+                            continue;
+                        }
+                    }
+
+                    // Ordinary case: just highlight the keyword.
+                    result.push(getHighlightSpanForNode(keywords[i]));
+                }
+
+                return result;
+            }
+        }
+    }
+
+    /**
+     * Whether or not a 'node' is preceded by a label of the given string.
+     * Note: 'node' cannot be a SourceFile.
+     */
+    function isLabeledBy(node: Node, labelName: string) {
+        for (let owner = node.parent; owner.kind === SyntaxKind.LabeledStatement; owner = owner.parent) {
+            if ((<LabeledStatement>owner).label.text === labelName) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

src/services/goToDefinition.ts

@@ -0,0 +1,256 @@
+/* @internal */
+namespace ts.GoToDefinition {
+    export function getDefinitionAtPosition(program: Program, sourceFile: SourceFile, position: number): DefinitionInfo[] {
+        /// Triple slash reference comments
+        const comment = findReferenceInPosition(sourceFile.referencedFiles, position);
+        if (comment) {
+            const referenceFile = tryResolveScriptReference(program, sourceFile, comment);
+            if (referenceFile) {
+                return [getDefinitionInfoForFileReference(comment.fileName, referenceFile.fileName)];
+            }
+            return undefined;
+        }
+
+        // Type reference directives
+        const typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position);
+        if (typeReferenceDirective) {
+            const referenceFile = program.getResolvedTypeReferenceDirectives()[typeReferenceDirective.fileName];
+            if (referenceFile && referenceFile.resolvedFileName) {
+                return [getDefinitionInfoForFileReference(typeReferenceDirective.fileName, referenceFile.resolvedFileName)];
+            }
+            return undefined;
+        }
+
+        const node = getTouchingPropertyName(sourceFile, position);
+        if (node === sourceFile) {
+            return undefined;
+        }
+
+        // Labels
+        if (isJumpStatementTarget(node)) {
+            const labelName = (<Identifier>node).text;
+            const label = getTargetLabel((<BreakOrContinueStatement>node.parent), (<Identifier>node).text);
+            return label ? [createDefinitionInfo(label, ScriptElementKind.label, labelName, /*containerName*/ undefined)] : undefined;
+        }
+
+        const typeChecker = program.getTypeChecker();
+
+        const calledDeclaration = tryGetSignatureDeclaration(typeChecker, node);
+        if (calledDeclaration) {
+            return [createDefinitionFromSignatureDeclaration(typeChecker, calledDeclaration)];
+        }
+
+        let symbol = typeChecker.getSymbolAtLocation(node);
+
+        // Could not find a symbol e.g. node is string or number keyword,
+        // or the symbol was an internal symbol and does not have a declaration e.g. undefined symbol
+        if (!symbol) {
+            return undefined;
+        }
+
+        // If this is an alias, and the request came at the declaration location
+        // get the aliased symbol instead. This allows for goto def on an import e.g.
+        //   import {A, B} from "mod";
+        // to jump to the implementation directly.
+        if (symbol.flags & SymbolFlags.Alias) {
+            const declaration = symbol.declarations[0];
+
+            // Go to the original declaration for cases:
+            //
+            //   (1) when the aliased symbol was declared in the location(parent).
+            //   (2) when the aliased symbol is originating from a named import.
+            //
+            if (node.kind === SyntaxKind.Identifier &&
+                (node.parent === declaration ||
+                (declaration.kind === SyntaxKind.ImportSpecifier && declaration.parent && declaration.parent.kind === SyntaxKind.NamedImports))) {
+
+                symbol = typeChecker.getAliasedSymbol(symbol);
+            }
+        }
+
+        // Because name in short-hand property assignment has two different meanings: property name and property value,
+        // using go-to-definition at such position should go to the variable declaration of the property value rather than
+        // go to the declaration of the property name (in this case stay at the same position). However, if go-to-definition
+        // is performed at the location of property access, we would like to go to definition of the property in the short-hand
+        // assignment. This case and others are handled by the following code.
+        if (node.parent.kind === SyntaxKind.ShorthandPropertyAssignment) {
+            const shorthandSymbol = typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration);
+            if (!shorthandSymbol) {
+                return [];
+            }
+
+            const shorthandDeclarations = shorthandSymbol.getDeclarations();
+            const shorthandSymbolKind = SymbolDisplay.getSymbolKind(typeChecker, shorthandSymbol, node);
+            const shorthandSymbolName = typeChecker.symbolToString(shorthandSymbol);
+            const shorthandContainerName = typeChecker.symbolToString(symbol.parent, node);
+            return map(shorthandDeclarations,
+                declaration => createDefinitionInfo(declaration, shorthandSymbolKind, shorthandSymbolName, shorthandContainerName));
+        }
+
+        return getDefinitionFromSymbol(typeChecker, symbol, node);
+    }
+
+    /// Goto type
+    export function getTypeDefinitionAtPosition(typeChecker: TypeChecker, sourceFile: SourceFile, position: number): DefinitionInfo[] {
+        const node = getTouchingPropertyName(sourceFile, position);
+        if (node === sourceFile) {
+            return undefined;
+        }
+
+        const symbol = typeChecker.getSymbolAtLocation(node);
+        if (!symbol) {
+            return undefined;
+        }
+
+        const type = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
+        if (!type) {
+            return undefined;
+        }
+
+        if (type.flags & TypeFlags.Union && !(type.flags & TypeFlags.Enum)) {
+            const result: DefinitionInfo[] = [];
+            forEach((<UnionType>type).types, t => {
+                if (t.symbol) {
+                    addRange(/*to*/ result, /*from*/ getDefinitionFromSymbol(typeChecker, t.symbol, node));
+                }
+            });
+            return result;
+        }
+
+        if (!type.symbol) {
+            return undefined;
+        }
+
+        return getDefinitionFromSymbol(typeChecker, type.symbol, node);
+    }
+
+    function getDefinitionFromSymbol(typeChecker: TypeChecker, symbol: Symbol, node: Node): DefinitionInfo[] {
+        const result: DefinitionInfo[] = [];
+        const declarations = symbol.getDeclarations();
+        const { symbolName, symbolKind, containerName } = getSymbolInfo(typeChecker, symbol, node);
+
+        if (!tryAddConstructSignature(symbol, node, symbolKind, symbolName, containerName, result) &&
+            !tryAddCallSignature(symbol, node, symbolKind, symbolName, containerName, result)) {
+            // Just add all the declarations.
+            forEach(declarations, declaration => {
+                result.push(createDefinitionInfo(declaration, symbolKind, symbolName, containerName));
+            });
+        }
+
+        return result;
+
+        function tryAddConstructSignature(symbol: Symbol, location: Node, symbolKind: string, symbolName: string, containerName: string, result: DefinitionInfo[]) {
+            // Applicable only if we are in a new expression, or we are on a constructor declaration
+            // and in either case the symbol has a construct signature definition, i.e. class
+            if (isNewExpressionTarget(location) || location.kind === SyntaxKind.ConstructorKeyword) {
+                if (symbol.flags & SymbolFlags.Class) {
+                    // Find the first class-like declaration and try to get the construct signature.
+                    for (const declaration of symbol.getDeclarations()) {
+                        if (isClassLike(declaration)) {
+                            return tryAddSignature(declaration.members,
+                                                    /*selectConstructors*/ true,
+                                                    symbolKind,
+                                                    symbolName,
+                                                    containerName,
+                                                    result);
+                        }
+                    }
+
+                    Debug.fail("Expected declaration to have at least one class-like declaration");
+                }
+            }
+            return false;
+        }
+
+        function tryAddCallSignature(symbol: Symbol, location: Node, symbolKind: string, symbolName: string, containerName: string, result: DefinitionInfo[]) {
+            if (isCallExpressionTarget(location) || isNewExpressionTarget(location) || isNameOfFunctionDeclaration(location)) {
+                return tryAddSignature(symbol.declarations, /*selectConstructors*/ false, symbolKind, symbolName, containerName, result);
+            }
+            return false;
+        }
+
+        function tryAddSignature(signatureDeclarations: Declaration[], selectConstructors: boolean, symbolKind: string, symbolName: string, containerName: string, result: DefinitionInfo[]) {
+            const declarations: Declaration[] = [];
+            let definition: Declaration;
+
+            forEach(signatureDeclarations, d => {
+                if ((selectConstructors && d.kind === SyntaxKind.Constructor) ||
+                    (!selectConstructors && (d.kind === SyntaxKind.FunctionDeclaration || d.kind === SyntaxKind.MethodDeclaration || d.kind === SyntaxKind.MethodSignature))) {
+                    declarations.push(d);
+                    if ((<FunctionLikeDeclaration>d).body) definition = d;
+                }
+            });
+
+            if (definition) {
+                result.push(createDefinitionInfo(definition, symbolKind, symbolName, containerName));
+                return true;
+            }
+            else if (declarations.length) {
+                result.push(createDefinitionInfo(lastOrUndefined(declarations), symbolKind, symbolName, containerName));
+                return true;
+            }
+
+            return false;
+        }
+    }
+
+    function createDefinitionInfo(node: Node, symbolKind: string, symbolName: string, containerName: string): DefinitionInfo {
+        return {
+            fileName: node.getSourceFile().fileName,
+            textSpan: createTextSpanFromBounds(node.getStart(), node.getEnd()),
+            kind: symbolKind,
+            name: symbolName,
+            containerKind: undefined,
+            containerName
+        };
+    }
+
+    function getSymbolInfo(typeChecker: TypeChecker, symbol: Symbol, node: Node) {
+        return {
+            symbolName: typeChecker.symbolToString(symbol), // Do not get scoped name, just the name of the symbol
+            symbolKind: SymbolDisplay.getSymbolKind(typeChecker, symbol, node),
+            containerName: symbol.parent ? typeChecker.symbolToString(symbol.parent, node) : ""
+        };
+    }
+
+    function createDefinitionFromSignatureDeclaration(typeChecker: TypeChecker, decl: SignatureDeclaration): DefinitionInfo {
+        const { symbolName, symbolKind, containerName } = getSymbolInfo(typeChecker, decl.symbol, decl);
+        return createDefinitionInfo(decl, symbolKind, symbolName, containerName);
+    }
+
+    function findReferenceInPosition(refs: FileReference[], pos: number): FileReference {
+        for (const ref of refs) {
+            if (ref.pos <= pos && pos < ref.end) {
+                return ref;
+            }
+        }
+        return undefined;
+    }
+
+    function getDefinitionInfoForFileReference(name: string, targetFileName: string): DefinitionInfo {
+        return {
+            fileName: targetFileName,
+            textSpan: createTextSpanFromBounds(0, 0),
+            kind: ScriptElementKind.scriptElement,
+            name: name,
+            containerName: undefined,
+            containerKind: undefined
+        };
+    }
+
+    /** Returns a CallLikeExpression where `node` is the target being invoked. */
+    function getAncestorCallLikeExpression(node: Node): CallLikeExpression | undefined {
+        const target = climbPastManyPropertyAccesses(node);
+        const callLike = target.parent;
+        return callLike && isCallLikeExpression(callLike) && getInvokedExpression(callLike) === target && callLike;
+    }
+
+    function climbPastManyPropertyAccesses(node: Node): Node {
+        return isRightSideOfPropertyAccess(node) ? climbPastManyPropertyAccesses(node.parent) : node;
+    }
+
+    function tryGetSignatureDeclaration(typeChecker: TypeChecker, node: Node): SignatureDeclaration | undefined {
+        const callLike = getAncestorCallLikeExpression(node);
+        return callLike && typeChecker.getResolvedSignature(callLike).declaration;
+    }
+}

src/services/jsDoc.ts

@@ -0,0 +1,545 @@
+/* @internal */
+namespace ts.JsDoc {
+    const jsDocTagNames = [
+        "augments",
+        "author",
+        "argument",
+        "borrows",
+        "class",
+        "constant",
+        "constructor",
+        "constructs",
+        "default",
+        "deprecated",
+        "description",
+        "event",
+        "example",
+        "extends",
+        "field",
+        "fileOverview",
+        "function",
+        "ignore",
+        "inner",
+        "lends",
+        "link",
+        "memberOf",
+        "name",
+        "namespace",
+        "param",
+        "private",
+        "property",
+        "public",
+        "requires",
+        "returns",
+        "see",
+        "since",
+        "static",
+        "throws",
+        "type",
+        "typedef",
+        "property",
+        "prop",
+        "version"
+    ];
+    let jsDocCompletionEntries: CompletionEntry[];
+
+    export function getJsDocCommentsFromDeclarations(declarations: Declaration[], name: string, canUseParsedParamTagComments: boolean) {
+        const documentationComment = <SymbolDisplayPart[]>[];
+        const docComments = getJsDocCommentsSeparatedByNewLines();
+        ts.forEach(docComments, docComment => {
+            if (documentationComment.length) {
+                documentationComment.push(lineBreakPart());
+            }
+            documentationComment.push(docComment);
+        });
+
+        return documentationComment;
+
+        function getJsDocCommentsSeparatedByNewLines() {
+            const paramTag = "@param";
+            const jsDocCommentParts: SymbolDisplayPart[] = [];
+
+            ts.forEach(declarations, (declaration, indexOfDeclaration) => {
+                // Make sure we are collecting doc comment from declaration once,
+                // In case of union property there might be same declaration multiple times
+                // which only varies in type parameter
+                // Eg. const a: Array<string> | Array<number>; a.length
+                // The property length will have two declarations of property length coming
+                // from Array<T> - Array<string> and Array<number>
+                if (indexOf(declarations, declaration) === indexOfDeclaration) {
+                    const sourceFileOfDeclaration = getSourceFileOfNode(declaration);
+                    // If it is parameter - try and get the jsDoc comment with @param tag from function declaration's jsDoc comments
+                    if (canUseParsedParamTagComments && declaration.kind === SyntaxKind.Parameter) {
+                        if ((declaration.parent.kind === SyntaxKind.FunctionExpression || declaration.parent.kind === SyntaxKind.ArrowFunction) &&
+                            declaration.parent.parent.kind === SyntaxKind.VariableDeclaration) {
+                            addCommentParts(declaration.parent.parent.parent, sourceFileOfDeclaration, getCleanedParamJsDocComment);
+                        }
+                        addCommentParts(declaration.parent, sourceFileOfDeclaration, getCleanedParamJsDocComment);
+                    }
+
+                    // If this is left side of dotted module declaration, there is no doc comments associated with this node
+                    if (declaration.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>declaration).body && (<ModuleDeclaration>declaration).body.kind === SyntaxKind.ModuleDeclaration) {
+                        return;
+                    }
+
+                    if ((declaration.kind === SyntaxKind.FunctionExpression || declaration.kind === SyntaxKind.ArrowFunction) &&
+                        declaration.parent.kind === SyntaxKind.VariableDeclaration) {
+                        addCommentParts(declaration.parent.parent, sourceFileOfDeclaration, getCleanedJsDocComment);
+                    }
+
+                    // If this is dotted module name, get the doc comments from the parent
+                    while (declaration.kind === SyntaxKind.ModuleDeclaration && declaration.parent.kind === SyntaxKind.ModuleDeclaration) {
+                        declaration = <ModuleDeclaration>declaration.parent;
+                    }
+                    addCommentParts(declaration.kind === SyntaxKind.VariableDeclaration ? declaration.parent.parent : declaration,
+                                    sourceFileOfDeclaration,
+                                    getCleanedJsDocComment);
+
+                    if (declaration.kind === SyntaxKind.VariableDeclaration) {
+                        const init = (declaration as VariableDeclaration).initializer;
+                        if (init && (init.kind === SyntaxKind.FunctionExpression || init.kind === SyntaxKind.ArrowFunction)) {
+                            // Get the cleaned js doc comment text from the initializer
+                            addCommentParts(init, sourceFileOfDeclaration, getCleanedJsDocComment);
+                        }
+                    }
+                }
+            });
+
+            return jsDocCommentParts;
+
+            function addCommentParts(commented: Node,
+                                     sourceFileOfDeclaration: SourceFile,
+                                     getCommentPart: (pos: number, end: number, file: SourceFile) => SymbolDisplayPart[]): void {
+                const ranges = getJsDocCommentTextRange(commented, sourceFileOfDeclaration);
+                // Get the cleaned js doc comment text from the declaration
+                ts.forEach(ranges, jsDocCommentTextRange => {
+                    const cleanedComment = getCommentPart(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration);
+                    if (cleanedComment) {
+                        addRange(jsDocCommentParts, cleanedComment);
+                    }
+                });
+            }
+
+            function getJsDocCommentTextRange(node: Node, sourceFile: SourceFile): TextRange[] {
+                return ts.map(getJsDocComments(node, sourceFile),
+                    jsDocComment => {
+                        return {
+                            pos: jsDocComment.pos + "/*".length, // Consume /* from the comment
+                            end: jsDocComment.end - "*/".length // Trim off comment end indicator
+                        };
+                    });
+            }
+
+            function consumeWhiteSpacesOnTheLine(pos: number, end: number, sourceFile: SourceFile, maxSpacesToRemove?: number) {
+                if (maxSpacesToRemove !== undefined) {
+                    end = Math.min(end, pos + maxSpacesToRemove);
+                }
+
+                for (; pos < end; pos++) {
+                    const ch = sourceFile.text.charCodeAt(pos);
+                    if (!isWhiteSpaceSingleLine(ch)) {
+                        return pos;
+                    }
+                }
+
+                return end;
+            }
+
+            function consumeLineBreaks(pos: number, end: number, sourceFile: SourceFile) {
+                while (pos < end && isLineBreak(sourceFile.text.charCodeAt(pos))) {
+                    pos++;
+                }
+
+                return pos;
+            }
+
+            function isName(pos: number, end: number, sourceFile: SourceFile, name: string) {
+                return pos + name.length < end &&
+                    sourceFile.text.substr(pos, name.length) === name &&
+                    isWhiteSpace(sourceFile.text.charCodeAt(pos + name.length));
+            }
+
+            function isParamTag(pos: number, end: number, sourceFile: SourceFile) {
+                // If it is @param tag
+                return isName(pos, end, sourceFile, paramTag);
+            }
+
+            function pushDocCommentLineText(docComments: SymbolDisplayPart[], text: string, blankLineCount: number) {
+                // Add the empty lines in between texts
+                while (blankLineCount) {
+                    blankLineCount--;
+                    docComments.push(textPart(""));
+                }
+
+                docComments.push(textPart(text));
+            }
+
+            function getCleanedJsDocComment(pos: number, end: number, sourceFile: SourceFile) {
+                let spacesToRemoveAfterAsterisk: number;
+                const docComments: SymbolDisplayPart[] = [];
+                let blankLineCount = 0;
+                let isInParamTag = false;
+
+                while (pos < end) {
+                    let docCommentTextOfLine = "";
+                    // First consume leading white space
+                    pos = consumeWhiteSpacesOnTheLine(pos, end, sourceFile);
+
+                    // If the comment starts with '*' consume the spaces on this line
+                    if (pos < end && sourceFile.text.charCodeAt(pos) === CharacterCodes.asterisk) {
+                        const lineStartPos = pos + 1;
+                        pos = consumeWhiteSpacesOnTheLine(pos + 1, end, sourceFile, spacesToRemoveAfterAsterisk);
+
+                        // Set the spaces to remove after asterisk as margin if not already set
+                        if (spacesToRemoveAfterAsterisk === undefined && pos < end && !isLineBreak(sourceFile.text.charCodeAt(pos))) {
+                            spacesToRemoveAfterAsterisk = pos - lineStartPos;
+                        }
+                    }
+                    else if (spacesToRemoveAfterAsterisk === undefined) {
+                        spacesToRemoveAfterAsterisk = 0;
+                    }
+
+                    // Analyze text on this line
+                    while (pos < end && !isLineBreak(sourceFile.text.charCodeAt(pos))) {
+                        const ch = sourceFile.text.charAt(pos);
+                        if (ch === "@") {
+                            // If it is @param tag
+                            if (isParamTag(pos, end, sourceFile)) {
+                                isInParamTag = true;
+                                pos += paramTag.length;
+                                continue;
+                            }
+                            else {
+                                isInParamTag = false;
+                            }
+                        }
+
+                        // Add the ch to doc text if we arent in param tag
+                        if (!isInParamTag) {
+                            docCommentTextOfLine += ch;
+                        }
+
+                        // Scan next character
+                        pos++;
+                    }
+
+                    // Continue with next line
+                    pos = consumeLineBreaks(pos, end, sourceFile);
+                    if (docCommentTextOfLine) {
+                        pushDocCommentLineText(docComments, docCommentTextOfLine, blankLineCount);
+                        blankLineCount = 0;
+                    }
+                    else if (!isInParamTag && docComments.length) {
+                        // This is blank line when there is text already parsed
+                        blankLineCount++;
+                    }
+                }
+
+                return docComments;
+            }
+
+            function getCleanedParamJsDocComment(pos: number, end: number, sourceFile: SourceFile) {
+                let paramHelpStringMargin: number;
+                const paramDocComments: SymbolDisplayPart[] = [];
+                while (pos < end) {
+                    if (isParamTag(pos, end, sourceFile)) {
+                        let blankLineCount = 0;
+                        let recordedParamTag = false;
+                        // Consume leading spaces
+                        pos = consumeWhiteSpaces(pos + paramTag.length);
+                        if (pos >= end) {
+                            break;
+                        }
+
+                        // Ignore type expression
+                        if (sourceFile.text.charCodeAt(pos) === CharacterCodes.openBrace) {
+                            pos++;
+                            for (let curlies = 1; pos < end; pos++) {
+                                const charCode = sourceFile.text.charCodeAt(pos);
+
+                                // { character means we need to find another } to match the found one
+                                if (charCode === CharacterCodes.openBrace) {
+                                    curlies++;
+                                    continue;
+                                }
+
+                                // } char
+                                if (charCode === CharacterCodes.closeBrace) {
+                                    curlies--;
+                                    if (curlies === 0) {
+                                        // We do not have any more } to match the type expression is ignored completely
+                                        pos++;
+                                        break;
+                                    }
+                                    else {
+                                        // there are more { to be matched with }
+                                        continue;
+                                    }
+                                }
+
+                                // Found start of another tag
+                                if (charCode === CharacterCodes.at) {
+                                    break;
+                                }
+                            }
+
+                            // Consume white spaces
+                            pos = consumeWhiteSpaces(pos);
+                            if (pos >= end) {
+                                break;
+                            }
+                        }
+
+                        // Parameter name
+                        if (isName(pos, end, sourceFile, name)) {
+                            // Found the parameter we are looking for consume white spaces
+                            pos = consumeWhiteSpaces(pos + name.length);
+                            if (pos >= end) {
+                                break;
+                            }
+
+                            let paramHelpString = "";
+                            const firstLineParamHelpStringPos = pos;
+                            while (pos < end) {
+                                const ch = sourceFile.text.charCodeAt(pos);
+
+                                // at line break, set this comment line text and go to next line
+                                if (isLineBreak(ch)) {
+                                    if (paramHelpString) {
+                                        pushDocCommentLineText(paramDocComments, paramHelpString, blankLineCount);
+                                        paramHelpString = "";
+                                        blankLineCount = 0;
+                                        recordedParamTag = true;
+                                    }
+                                    else if (recordedParamTag) {
+                                        blankLineCount++;
+                                    }
+
+                                    // Get the pos after cleaning start of the line
+                                    setPosForParamHelpStringOnNextLine(firstLineParamHelpStringPos);
+                                    continue;
+                                }
+
+                                // Done scanning param help string - next tag found
+                                if (ch === CharacterCodes.at) {
+                                    break;
+                                }
+
+                                paramHelpString += sourceFile.text.charAt(pos);
+
+                                // Go to next character
+                                pos++;
+                            }
+
+                            // If there is param help text, add it top the doc comments
+                            if (paramHelpString) {
+                                pushDocCommentLineText(paramDocComments, paramHelpString, blankLineCount);
+                            }
+                            paramHelpStringMargin = undefined;
+                        }
+
+                        // If this is the start of another tag, continue with the loop in search of param tag with symbol name
+                        if (sourceFile.text.charCodeAt(pos) === CharacterCodes.at) {
+                            continue;
+                        }
+                    }
+
+                    // Next character
+                    pos++;
+                }
+
+                return paramDocComments;
+
+                function consumeWhiteSpaces(pos: number) {
+                    while (pos < end && isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(pos))) {
+                        pos++;
+                    }
+
+                    return pos;
+                }
+
+                function setPosForParamHelpStringOnNextLine(firstLineParamHelpStringPos: number) {
+                    // Get the pos after consuming line breaks
+                    pos = consumeLineBreaks(pos, end, sourceFile);
+                    if (pos >= end) {
+                        return;
+                    }
+
+                    if (paramHelpStringMargin === undefined) {
+                        paramHelpStringMargin = sourceFile.getLineAndCharacterOfPosition(firstLineParamHelpStringPos).character;
+                    }
+
+                    // Now consume white spaces max
+                    const startOfLinePos = pos;
+                    pos = consumeWhiteSpacesOnTheLine(pos, end, sourceFile, paramHelpStringMargin);
+                    if (pos >= end) {
+                        return;
+                    }
+
+                    const consumedSpaces = pos - startOfLinePos;
+                    if (consumedSpaces < paramHelpStringMargin) {
+                        const ch = sourceFile.text.charCodeAt(pos);
+                        if (ch === CharacterCodes.asterisk) {
+                            // Consume more spaces after asterisk
+                            pos = consumeWhiteSpacesOnTheLine(pos + 1, end, sourceFile, paramHelpStringMargin - consumedSpaces - 1);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    export function getAllJsDocCompletionEntries(): CompletionEntry[] {
+        return jsDocCompletionEntries || (jsDocCompletionEntries = ts.map(jsDocTagNames, tagName => {
+            return {
+                name: tagName,
+                kind: ScriptElementKind.keyword,
+                kindModifiers: "",
+                sortText: "0",
+            };
+        }));
+    }
+
+    /**
+     * Checks if position points to a valid position to add JSDoc comments, and if so,
+     * returns the appropriate template. Otherwise returns an empty string.
+     * Valid positions are
+     *      - outside of comments, statements, and expressions, and
+     *      - preceding a:
+     *          - function/constructor/method declaration
+     *          - class declarations
+     *          - variable statements
+     *          - namespace declarations
+     *
+     * Hosts should ideally check that:
+     * - The line is all whitespace up to 'position' before performing the insertion.
+     * - If the keystroke sequence "/\*\*" induced the call, we also check that the next
+     * non-whitespace character is '*', which (approximately) indicates whether we added
+     * the second '*' to complete an existing (JSDoc) comment.
+     * @param fileName The file in which to perform the check.
+     * @param position The (character-indexed) position in the file where the check should
+     * be performed.
+     */
+    export function getDocCommentTemplateAtPosition(newLine: string, sourceFile: SourceFile, position: number): TextInsertion {
+        // Check if in a context where we don't want to perform any insertion
+        if (isInString(sourceFile, position) || isInComment(sourceFile, position) || hasDocComment(sourceFile, position)) {
+            return undefined;
+        }
+
+        const tokenAtPos = getTokenAtPosition(sourceFile, position);
+        const tokenStart = tokenAtPos.getStart();
+        if (!tokenAtPos || tokenStart < position) {
+            return undefined;
+        }
+
+        // TODO: add support for:
+        // - enums/enum members
+        // - interfaces
+        // - property declarations
+        // - potentially property assignments
+        let commentOwner: Node;
+        findOwner: for (commentOwner = tokenAtPos; commentOwner; commentOwner = commentOwner.parent) {
+            switch (commentOwner.kind) {
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.Constructor:
+                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.VariableStatement:
+                    break findOwner;
+                case SyntaxKind.SourceFile:
+                    return undefined;
+                case SyntaxKind.ModuleDeclaration:
+                    // If in walking up the tree, we hit a a nested namespace declaration,
+                    // then we must be somewhere within a dotted namespace name; however we don't
+                    // want to give back a JSDoc template for the 'b' or 'c' in 'namespace a.b.c { }'.
+                    if (commentOwner.parent.kind === SyntaxKind.ModuleDeclaration) {
+                        return undefined;
+                    }
+                    break findOwner;
+            }
+        }
+
+        if (!commentOwner || commentOwner.getStart() < position) {
+            return undefined;
+        }
+
+        const parameters = getParametersForJsDocOwningNode(commentOwner);
+        const posLineAndChar = sourceFile.getLineAndCharacterOfPosition(position);
+        const lineStart = sourceFile.getLineStarts()[posLineAndChar.line];
+
+        const indentationStr = sourceFile.text.substr(lineStart, posLineAndChar.character);
+
+        let docParams = "";
+        for (let i = 0, numParams = parameters.length; i < numParams; i++) {
+            const currentName = parameters[i].name;
+            const paramName = currentName.kind === SyntaxKind.Identifier ?
+                (<Identifier>currentName).text :
+                "param" + i;
+
+            docParams += `${indentationStr} * @param ${paramName}${newLine}`;
+        }
+
+        // A doc comment consists of the following
+        // * The opening comment line
+        // * the first line (without a param) for the object's untagged info (this is also where the caret ends up)
+        // * the '@param'-tagged lines
+        // * TODO: other tags.
+        // * the closing comment line
+        // * if the caret was directly in front of the object, then we add an extra line and indentation.
+        const preamble = "/**" + newLine +
+            indentationStr + " * ";
+        const result =
+            preamble + newLine +
+            docParams +
+            indentationStr + " */" +
+            (tokenStart === position ? newLine + indentationStr : "");
+
+        return { newText: result, caretOffset: preamble.length };
+    }
+
+    function getParametersForJsDocOwningNode(commentOwner: Node): ParameterDeclaration[] {
+        if (isFunctionLike(commentOwner)) {
+            return commentOwner.parameters;
+        }
+
+        if (commentOwner.kind === SyntaxKind.VariableStatement) {
+            const varStatement = <VariableStatement>commentOwner;
+            const varDeclarations = varStatement.declarationList.declarations;
+
+            if (varDeclarations.length === 1 && varDeclarations[0].initializer) {
+                return getParametersFromRightHandSideOfAssignment(varDeclarations[0].initializer);
+            }
+        }
+
+        return emptyArray;
+    }
+
+    /**
+     * Digs into an an initializer or RHS operand of an assignment operation
+     * to get the parameters of an apt signature corresponding to a
+     * function expression or a class expression.
+     *
+     * @param rightHandSide the expression which may contain an appropriate set of parameters
+     * @returns the parameters of a signature found on the RHS if one exists; otherwise 'emptyArray'.
+     */
+    function getParametersFromRightHandSideOfAssignment(rightHandSide: Expression): ParameterDeclaration[] {
+        while (rightHandSide.kind === SyntaxKind.ParenthesizedExpression) {
+            rightHandSide = (<ParenthesizedExpression>rightHandSide).expression;
+        }
+
+        switch (rightHandSide.kind) {
+            case SyntaxKind.FunctionExpression:
+            case SyntaxKind.ArrowFunction:
+                return (<FunctionExpression>rightHandSide).parameters;
+            case SyntaxKind.ClassExpression:
+                for (const member of (<ClassExpression>rightHandSide).members) {
+                    if (member.kind === SyntaxKind.Constructor) {
+                        return (<ConstructorDeclaration>member).parameters;
+                    }
+                }
+                break;
+        }
+
+        return emptyArray;
+    }
+}

src/services/preProcess.ts

@@ -0,0 +1,360 @@
+/* @internal */
+namespace ts.PreProcess {
+    export function preProcessFile(sourceText: string, readImportFiles = true, detectJavaScriptImports = false): PreProcessedFileInfo {
+        const referencedFiles: FileReference[] = [];
+        const typeReferenceDirectives: FileReference[] = [];
+        const importedFiles: FileReference[] = [];
+        let ambientExternalModules: { ref: FileReference, depth: number }[];
+        let isNoDefaultLib = false;
+        let braceNesting = 0;
+        // assume that text represent an external module if it contains at least one top level import/export
+        // ambient modules that are found inside external modules are interpreted as module augmentations
+        let externalModule = false;
+
+        function nextToken() {
+            const token = scanner.scan();
+            if (token === SyntaxKind.OpenBraceToken) {
+                braceNesting++;
+            }
+            else if (token === SyntaxKind.CloseBraceToken) {
+                braceNesting--;
+            }
+            return token;
+        }
+
+        function processTripleSlashDirectives(): void {
+            const commentRanges = getLeadingCommentRanges(sourceText, 0);
+            forEach(commentRanges, commentRange => {
+                const comment = sourceText.substring(commentRange.pos, commentRange.end);
+                const referencePathMatchResult = getFileReferenceFromReferencePath(comment, commentRange);
+                if (referencePathMatchResult) {
+                    isNoDefaultLib = referencePathMatchResult.isNoDefaultLib;
+                    const fileReference = referencePathMatchResult.fileReference;
+                    if (fileReference) {
+                        const collection = referencePathMatchResult.isTypeReferenceDirective
+                            ? typeReferenceDirectives
+                            : referencedFiles;
+
+                        collection.push(fileReference);
+                    }
+                }
+            });
+        }
+
+        function getFileReference() {
+            const file = scanner.getTokenValue();
+            const pos = scanner.getTokenPos();
+            return {
+                fileName: file,
+                pos: pos,
+                end: pos + file.length
+            };
+        }
+
+        function recordAmbientExternalModule(): void {
+            if (!ambientExternalModules) {
+                ambientExternalModules = [];
+            }
+            ambientExternalModules.push({ ref: getFileReference(), depth: braceNesting });
+        }
+
+        function recordModuleName() {
+            importedFiles.push(getFileReference());
+
+            markAsExternalModuleIfTopLevel();
+        }
+
+        function markAsExternalModuleIfTopLevel() {
+            if (braceNesting === 0) {
+                externalModule = true;
+            }
+        }
+
+        /**
+         * Returns true if at least one token was consumed from the stream
+         */
+        function tryConsumeDeclare(): boolean {
+            let token = scanner.getToken();
+            if (token === SyntaxKind.DeclareKeyword) {
+                // declare module "mod"
+                token = nextToken();
+                if (token === SyntaxKind.ModuleKeyword) {
+                    token = nextToken();
+                    if (token === SyntaxKind.StringLiteral) {
+                        recordAmbientExternalModule();
+                    }
+                }
+                return true;
+            }
+
+            return false;
+        }
+
+        /**
+         * Returns true if at least one token was consumed from the stream
+         */
+        function tryConsumeImport(): boolean {
+            let token = scanner.getToken();
+            if (token === SyntaxKind.ImportKeyword) {
+
+                token = nextToken();
+                if (token === SyntaxKind.StringLiteral) {
+                    // import "mod";
+                    recordModuleName();
+                    return true;
+                }
+                else {
+                    if (token === SyntaxKind.Identifier || isKeyword(token)) {
+                        token = nextToken();
+                        if (token === SyntaxKind.FromKeyword) {
+                            token = nextToken();
+                            if (token === SyntaxKind.StringLiteral) {
+                                // import d from "mod";
+                                recordModuleName();
+                                return true;
+                            }
+                        }
+                        else if (token === SyntaxKind.EqualsToken) {
+                            if (tryConsumeRequireCall(/*skipCurrentToken*/ true)) {
+                                return true;
+                            }
+                        }
+                        else if (token === SyntaxKind.CommaToken) {
+                            // consume comma and keep going
+                            token = nextToken();
+                        }
+                        else {
+                            // unknown syntax
+                            return true;
+                        }
+                    }
+
+                    if (token === SyntaxKind.OpenBraceToken) {
+                        token = nextToken();
+                        // consume "{ a as B, c, d as D}" clauses
+                        // make sure that it stops on EOF
+                        while (token !== SyntaxKind.CloseBraceToken && token !== SyntaxKind.EndOfFileToken) {
+                            token = nextToken();
+                        }
+
+                        if (token === SyntaxKind.CloseBraceToken) {
+                            token = nextToken();
+                            if (token === SyntaxKind.FromKeyword) {
+                                token = nextToken();
+                                if (token === SyntaxKind.StringLiteral) {
+                                    // import {a as A} from "mod";
+                                    // import d, {a, b as B} from "mod"
+                                    recordModuleName();
+                                }
+                            }
+                        }
+                    }
+                    else if (token === SyntaxKind.AsteriskToken) {
+                        token = nextToken();
+                        if (token === SyntaxKind.AsKeyword) {
+                            token = nextToken();
+                            if (token === SyntaxKind.Identifier || isKeyword(token)) {
+                                token = nextToken();
+                                if (token === SyntaxKind.FromKeyword) {
+                                    token = nextToken();
+                                    if (token === SyntaxKind.StringLiteral) {
+                                        // import * as NS from "mod"
+                                        // import d, * as NS from "mod"
+                                        recordModuleName();
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        function tryConsumeExport(): boolean {
+            let token = scanner.getToken();
+            if (token === SyntaxKind.ExportKeyword) {
+                markAsExternalModuleIfTopLevel();
+                token = nextToken();
+                if (token === SyntaxKind.OpenBraceToken) {
+                    token = nextToken();
+                    // consume "{ a as B, c, d as D}" clauses
+                    // make sure it stops on EOF
+                    while (token !== SyntaxKind.CloseBraceToken && token !== SyntaxKind.EndOfFileToken) {
+                        token = nextToken();
+                    }
+
+                    if (token === SyntaxKind.CloseBraceToken) {
+                        token = nextToken();
+                        if (token === SyntaxKind.FromKeyword) {
+                            token = nextToken();
+                            if (token === SyntaxKind.StringLiteral) {
+                                // export {a as A} from "mod";
+                                // export {a, b as B} from "mod"
+                                recordModuleName();
+                            }
+                        }
+                    }
+                }
+                else if (token === SyntaxKind.AsteriskToken) {
+                    token = nextToken();
+                    if (token === SyntaxKind.FromKeyword) {
+                        token = nextToken();
+                        if (token === SyntaxKind.StringLiteral) {
+                            // export * from "mod"
+                            recordModuleName();
+                        }
+                    }
+                }
+                else if (token === SyntaxKind.ImportKeyword) {
+                    token = nextToken();
+                    if (token === SyntaxKind.Identifier || isKeyword(token)) {
+                        token = nextToken();
+                        if (token === SyntaxKind.EqualsToken) {
+                            if (tryConsumeRequireCall(/*skipCurrentToken*/ true)) {
+                                return true;
+                            }
+                        }
+                    }
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        function tryConsumeRequireCall(skipCurrentToken: boolean): boolean {
+            let token = skipCurrentToken ? nextToken() : scanner.getToken();
+            if (token === SyntaxKind.RequireKeyword) {
+                token = nextToken();
+                if (token === SyntaxKind.OpenParenToken) {
+                    token = nextToken();
+                    if (token === SyntaxKind.StringLiteral) {
+                        //  require("mod");
+                        recordModuleName();
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+
+        function tryConsumeDefine(): boolean {
+            let token = scanner.getToken();
+            if (token === SyntaxKind.Identifier && scanner.getTokenValue() === "define") {
+                token = nextToken();
+                if (token !== SyntaxKind.OpenParenToken) {
+                    return true;
+                }
+
+                token = nextToken();
+                if (token === SyntaxKind.StringLiteral) {
+                    // looks like define ("modname", ... - skip string literal and comma
+                    token = nextToken();
+                    if (token === SyntaxKind.CommaToken) {
+                        token = nextToken();
+                    }
+                    else {
+                        // unexpected token
+                        return true;
+                    }
+                }
+
+                // should be start of dependency list
+                if (token !== SyntaxKind.OpenBracketToken) {
+                    return true;
+                }
+
+                // skip open bracket
+                token = nextToken();
+                let i = 0;
+                // scan until ']' or EOF
+                while (token !== SyntaxKind.CloseBracketToken && token !== SyntaxKind.EndOfFileToken) {
+                    // record string literals as module names
+                    if (token === SyntaxKind.StringLiteral) {
+                        recordModuleName();
+                        i++;
+                    }
+
+                    token = nextToken();
+                }
+                return true;
+
+            }
+            return false;
+        }
+
+        function processImports(): void {
+            scanner.setText(sourceText);
+            nextToken();
+            // Look for:
+            //    import "mod";
+            //    import d from "mod"
+            //    import {a as A } from "mod";
+            //    import * as NS  from "mod"
+            //    import d, {a, b as B} from "mod"
+            //    import i = require("mod");
+            //
+            //    export * from "mod"
+            //    export {a as b} from "mod"
+            //    export import i = require("mod")
+            //    (for JavaScript files) require("mod")
+
+            while (true) {
+                if (scanner.getToken() === SyntaxKind.EndOfFileToken) {
+                    break;
+                }
+
+                // check if at least one of alternative have moved scanner forward
+                if (tryConsumeDeclare() ||
+                    tryConsumeImport() ||
+                    tryConsumeExport() ||
+                    (detectJavaScriptImports && (tryConsumeRequireCall(/*skipCurrentToken*/ false) || tryConsumeDefine()))) {
+                    continue;
+                }
+                else {
+                    nextToken();
+                }
+            }
+
+            scanner.setText(undefined);
+        }
+
+        if (readImportFiles) {
+            processImports();
+        }
+        processTripleSlashDirectives();
+        if (externalModule) {
+            // for external modules module all nested ambient modules are augmentations
+            if (ambientExternalModules) {
+                // move all detected ambient modules to imported files since they need to be resolved
+                for (const decl of ambientExternalModules) {
+                    importedFiles.push(decl.ref);
+                }
+            }
+            return { referencedFiles, typeReferenceDirectives, importedFiles, isLibFile: isNoDefaultLib, ambientExternalModules: undefined };
+        }
+        else {
+            // for global scripts ambient modules still can have augmentations - look for ambient modules with depth > 0
+            let ambientModuleNames: string[];
+            if (ambientExternalModules) {
+                for (const decl of ambientExternalModules) {
+                    if (decl.depth === 0) {
+                        if (!ambientModuleNames) {
+                            ambientModuleNames = [];
+                        }
+                        ambientModuleNames.push(decl.ref.fileName);
+                    }
+                    else {
+                        importedFiles.push(decl.ref);
+                    }
+                }
+            }
+            return { referencedFiles, typeReferenceDirectives, importedFiles, isLibFile: isNoDefaultLib, ambientExternalModules: ambientModuleNames };
+        }
+    }
+}

src/services/rename.ts

@@ -0,0 +1,98 @@
+/* @internal */
+namespace ts.Rename {
+    export function getRenameInfo(typeChecker: TypeChecker, defaultLibFileName: string, getCanonicalFileName: (fileName: string) => string, sourceFile: SourceFile, position: number): RenameInfo {
+        const canonicalDefaultLibName = getCanonicalFileName(ts.normalizePath(defaultLibFileName));
+
+        const node = getTouchingWord(sourceFile, position, /*includeJsDocComment*/ true);
+
+        if (node) {
+            if (node.kind === SyntaxKind.Identifier ||
+                node.kind === SyntaxKind.StringLiteral ||
+                isLiteralNameOfPropertyDeclarationOrIndexAccess(node) ||
+                isThis(node)) {
+                const symbol = typeChecker.getSymbolAtLocation(node);
+
+                // Only allow a symbol to be renamed if it actually has at least one declaration.
+                if (symbol) {
+                    const declarations = symbol.getDeclarations();
+                    if (declarations && declarations.length > 0) {
+                        // Disallow rename for elements that are defined in the standard TypeScript library.
+                        if (forEach(declarations, isDefinedInLibraryFile)) {
+                            return getRenameInfoError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library));
+                        }
+
+                        const displayName = stripQuotes(getDeclaredName(typeChecker, symbol, node));
+                        const kind = SymbolDisplay.getSymbolKind(typeChecker, symbol, node);
+                        if (kind) {
+                            return {
+                                canRename: true,
+                                kind,
+                                displayName,
+                                localizedErrorMessage: undefined,
+                                fullDisplayName: typeChecker.getFullyQualifiedName(symbol),
+                                kindModifiers: SymbolDisplay.getSymbolModifiers(symbol),
+                                triggerSpan: createTriggerSpanForNode(node, sourceFile)
+                            };
+                        }
+                    }
+                }
+                else if (node.kind === SyntaxKind.StringLiteral) {
+                    const type = getStringLiteralTypeForNode(<StringLiteral>node, typeChecker);
+                    if (type) {
+                        if (isDefinedInLibraryFile(node)) {
+                            return getRenameInfoError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library));
+                        }
+                        else {
+                            const displayName = stripQuotes(type.text);
+                            return {
+                                canRename: true,
+                                kind: ScriptElementKind.variableElement,
+                                displayName,
+                                localizedErrorMessage: undefined,
+                                fullDisplayName: displayName,
+                                kindModifiers: ScriptElementKindModifier.none,
+                                triggerSpan: createTriggerSpanForNode(node, sourceFile)
+                            };
+                        }
+                    }
+                }
+            }
+        }
+
+        return getRenameInfoError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_this_element));
+
+        function getRenameInfoError(localizedErrorMessage: string): RenameInfo {
+            return {
+                canRename: false,
+                localizedErrorMessage: localizedErrorMessage,
+                displayName: undefined,
+                fullDisplayName: undefined,
+                kind: undefined,
+                kindModifiers: undefined,
+                triggerSpan: undefined
+            };
+        }
+
+        function isDefinedInLibraryFile(declaration: Node) {
+            if (defaultLibFileName) {
+                const sourceFile = declaration.getSourceFile();
+                const canonicalName = getCanonicalFileName(ts.normalizePath(sourceFile.fileName));
+                if (canonicalName === canonicalDefaultLibName) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        function createTriggerSpanForNode(node: Node, sourceFile: SourceFile) {
+            let start = node.getStart(sourceFile);
+            let width = node.getWidth(sourceFile);
+            if (node.kind === SyntaxKind.StringLiteral) {
+                // Exclude the quotes
+                start += 1;
+                width -= 2;
+            }
+            return createTextSpan(start, width);
+        }
+    }
+}

src/services/shims.ts

@@ -986,7 +986,7 @@ namespace ts {
 
         constructor(factory: ShimFactory, private logger: Logger) {
             super(factory);
-            this.classifier = createClassifier();
+            this.classifier = Classifier.createClassifier();
         }
 
         public getEncodedLexicalClassifications(text: string, lexState: EndOfLineState, syntacticClassifierAbsent?: boolean): string {
@@ -1047,7 +1047,7 @@ namespace ts {
                 `getPreProcessedFileInfo('${fileName}')`,
                 () => {
                     // for now treat files as JavaScript
-                    const result = preProcessFile(sourceTextSnapshot.getText(0, sourceTextSnapshot.getLength()), /* readImportFiles */ true, /* detectJavaScriptImports */ true);
+                    const result = PreProcess.preProcessFile(sourceTextSnapshot.getText(0, sourceTextSnapshot.getLength()), /* readImportFiles */ true, /* detectJavaScriptImports */ true);
                     return {
                         referencedFiles: this.convertFileReferences(result.referencedFiles),
                         importedFiles: this.convertFileReferences(result.importedFiles),

src/services/symbolDisplay.ts

@@ -0,0 +1,523 @@
+/* @internal */
+namespace ts.SymbolDisplay {
+    // TODO(drosen): use contextual SemanticMeaning.
+    export function getSymbolKind(typeChecker: TypeChecker, symbol: Symbol, location: Node): string {
+        const flags = symbol.getFlags();
+
+        if (flags & SymbolFlags.Class) return getDeclarationOfKind(symbol, SyntaxKind.ClassExpression) ?
+            ScriptElementKind.localClassElement : ScriptElementKind.classElement;
+        if (flags & SymbolFlags.Enum) return ScriptElementKind.enumElement;
+        if (flags & SymbolFlags.TypeAlias) return ScriptElementKind.typeElement;
+        if (flags & SymbolFlags.Interface) return ScriptElementKind.interfaceElement;
+        if (flags & SymbolFlags.TypeParameter) return ScriptElementKind.typeParameterElement;
+
+        const result = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, flags, location);
+        if (result === ScriptElementKind.unknown) {
+            if (flags & SymbolFlags.TypeParameter) return ScriptElementKind.typeParameterElement;
+            if (flags & SymbolFlags.EnumMember) return ScriptElementKind.variableElement;
+            if (flags & SymbolFlags.Alias) return ScriptElementKind.alias;
+            if (flags & SymbolFlags.Module) return ScriptElementKind.moduleElement;
+        }
+
+        return result;
+    }
+
+    function getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker: TypeChecker, symbol: Symbol, flags: SymbolFlags, location: Node) {
+        if (typeChecker.isUndefinedSymbol(symbol)) {
+            return ScriptElementKind.variableElement;
+        }
+        if (typeChecker.isArgumentsSymbol(symbol)) {
+            return ScriptElementKind.localVariableElement;
+        }
+        if (location.kind === SyntaxKind.ThisKeyword && isExpression(location)) {
+            return ScriptElementKind.parameterElement;
+        }
+        if (flags & SymbolFlags.Variable) {
+            if (isFirstDeclarationOfSymbolParameter(symbol)) {
+                return ScriptElementKind.parameterElement;
+            }
+            else if (symbol.valueDeclaration && isConst(symbol.valueDeclaration)) {
+                return ScriptElementKind.constElement;
+            }
+            else if (forEach(symbol.declarations, isLet)) {
+                return ScriptElementKind.letElement;
+            }
+            return isLocalVariableOrFunction(symbol) ? ScriptElementKind.localVariableElement : ScriptElementKind.variableElement;
+        }
+        if (flags & SymbolFlags.Function) return isLocalVariableOrFunction(symbol) ? ScriptElementKind.localFunctionElement : ScriptElementKind.functionElement;
+        if (flags & SymbolFlags.GetAccessor) return ScriptElementKind.memberGetAccessorElement;
+        if (flags & SymbolFlags.SetAccessor) return ScriptElementKind.memberSetAccessorElement;
+        if (flags & SymbolFlags.Method) return ScriptElementKind.memberFunctionElement;
+        if (flags & SymbolFlags.Constructor) return ScriptElementKind.constructorImplementationElement;
+
+        if (flags & SymbolFlags.Property) {
+            if (flags & SymbolFlags.SyntheticProperty) {
+                // If union property is result of union of non method (property/accessors/variables), it is labeled as property
+                const unionPropertyKind = forEach(typeChecker.getRootSymbols(symbol), rootSymbol => {
+                    const rootSymbolFlags = rootSymbol.getFlags();
+                    if (rootSymbolFlags & (SymbolFlags.PropertyOrAccessor | SymbolFlags.Variable)) {
+                        return ScriptElementKind.memberVariableElement;
+                    }
+                    Debug.assert(!!(rootSymbolFlags & SymbolFlags.Method));
+                });
+                if (!unionPropertyKind) {
+                    // If this was union of all methods,
+                    // make sure it has call signatures before we can label it as method
+                    const typeOfUnionProperty = typeChecker.getTypeOfSymbolAtLocation(symbol, location);
+                    if (typeOfUnionProperty.getCallSignatures().length) {
+                        return ScriptElementKind.memberFunctionElement;
+                    }
+                    return ScriptElementKind.memberVariableElement;
+                }
+                return unionPropertyKind;
+            }
+            return ScriptElementKind.memberVariableElement;
+        }
+
+        return ScriptElementKind.unknown;
+    }
+
+    export function getSymbolModifiers(symbol: Symbol): string {
+        return symbol && symbol.declarations && symbol.declarations.length > 0
+            ? getNodeModifiers(symbol.declarations[0])
+            : ScriptElementKindModifier.none;
+    }
+
+    // TODO(drosen): Currently completion entry details passes the SemanticMeaning.All instead of using semanticMeaning of location
+    export function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker: TypeChecker, symbol: Symbol, sourceFile: SourceFile, enclosingDeclaration: Node,
+        location: Node, semanticMeaning = getMeaningFromLocation(location)) {
+
+        const displayParts: SymbolDisplayPart[] = [];
+        let documentation: SymbolDisplayPart[];
+        const symbolFlags = symbol.flags;
+        let symbolKind = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, symbolFlags, location);
+        let hasAddedSymbolInfo: boolean;
+        const isThisExpression = location.kind === SyntaxKind.ThisKeyword && isExpression(location);
+        let type: Type;
+
+        // Class at constructor site need to be shown as constructor apart from property,method, vars
+        if (symbolKind !== ScriptElementKind.unknown || symbolFlags & SymbolFlags.Class || symbolFlags & SymbolFlags.Alias) {
+            // If it is accessor they are allowed only if location is at name of the accessor
+            if (symbolKind === ScriptElementKind.memberGetAccessorElement || symbolKind === ScriptElementKind.memberSetAccessorElement) {
+                symbolKind = ScriptElementKind.memberVariableElement;
+            }
+
+            let signature: Signature;
+            type = isThisExpression ? typeChecker.getTypeAtLocation(location) : typeChecker.getTypeOfSymbolAtLocation(symbol, location);
+            if (type) {
+                if (location.parent && location.parent.kind === SyntaxKind.PropertyAccessExpression) {
+                    const right = (<PropertyAccessExpression>location.parent).name;
+                    // Either the location is on the right of a property access, or on the left and the right is missing
+                    if (right === location || (right && right.getFullWidth() === 0)) {
+                        location = location.parent;
+                    }
+                }
+
+                // try get the call/construct signature from the type if it matches
+                let callExpression: CallExpression;
+                if (location.kind === SyntaxKind.CallExpression || location.kind === SyntaxKind.NewExpression) {
+                    callExpression = <CallExpression>location;
+                }
+                else if (isCallExpressionTarget(location) || isNewExpressionTarget(location)) {
+                    callExpression = <CallExpression>location.parent;
+                }
+
+                if (callExpression) {
+                    const candidateSignatures: Signature[] = [];
+                    signature = typeChecker.getResolvedSignature(callExpression, candidateSignatures);
+                    if (!signature && candidateSignatures.length) {
+                        // Use the first candidate:
+                        signature = candidateSignatures[0];
+                    }
+
+                    const useConstructSignatures = callExpression.kind === SyntaxKind.NewExpression || callExpression.expression.kind === SyntaxKind.SuperKeyword;
+                    const allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures();
+
+                    if (!contains(allSignatures, signature.target) && !contains(allSignatures, signature)) {
+                        // Get the first signature if there is one -- allSignatures may contain
+                        // either the original signature or its target, so check for either
+                        signature = allSignatures.length ? allSignatures[0] : undefined;
+                    }
+
+                    if (signature) {
+                        if (useConstructSignatures && (symbolFlags & SymbolFlags.Class)) {
+                            // Constructor
+                            symbolKind = ScriptElementKind.constructorImplementationElement;
+                            addPrefixForAnyFunctionOrVar(type.symbol, symbolKind);
+                        }
+                        else if (symbolFlags & SymbolFlags.Alias) {
+                            symbolKind = ScriptElementKind.alias;
+                            pushTypePart(symbolKind);
+                            displayParts.push(spacePart());
+                            if (useConstructSignatures) {
+                                displayParts.push(keywordPart(SyntaxKind.NewKeyword));
+                                displayParts.push(spacePart());
+                            }
+                            addFullSymbolName(symbol);
+                        }
+                        else {
+                            addPrefixForAnyFunctionOrVar(symbol, symbolKind);
+                        }
+
+                        switch (symbolKind) {
+                            case ScriptElementKind.memberVariableElement:
+                            case ScriptElementKind.variableElement:
+                            case ScriptElementKind.constElement:
+                            case ScriptElementKind.letElement:
+                            case ScriptElementKind.parameterElement:
+                            case ScriptElementKind.localVariableElement:
+                                // If it is call or construct signature of lambda's write type name
+                                displayParts.push(punctuationPart(SyntaxKind.ColonToken));
+                                displayParts.push(spacePart());
+                                if (useConstructSignatures) {
+                                    displayParts.push(keywordPart(SyntaxKind.NewKeyword));
+                                    displayParts.push(spacePart());
+                                }
+                                if (!(type.flags & TypeFlags.Anonymous) && type.symbol) {
+                                    addRange(displayParts, symbolToDisplayParts(typeChecker, type.symbol, enclosingDeclaration, /*meaning*/ undefined, SymbolFormatFlags.WriteTypeParametersOrArguments));
+                                }
+                                addSignatureDisplayParts(signature, allSignatures, TypeFormatFlags.WriteArrowStyleSignature);
+                                break;
+
+                            default:
+                                // Just signature
+                                addSignatureDisplayParts(signature, allSignatures);
+                        }
+                        hasAddedSymbolInfo = true;
+                    }
+                }
+                else if ((isNameOfFunctionDeclaration(location) && !(symbol.flags & SymbolFlags.Accessor)) || // name of function declaration
+                    (location.kind === SyntaxKind.ConstructorKeyword && location.parent.kind === SyntaxKind.Constructor)) { // At constructor keyword of constructor declaration
+                    // get the signature from the declaration and write it
+                    const functionDeclaration = <FunctionLikeDeclaration>location.parent;
+                    const allSignatures = functionDeclaration.kind === SyntaxKind.Constructor ? type.getNonNullableType().getConstructSignatures() : type.getNonNullableType().getCallSignatures();
+                    if (!typeChecker.isImplementationOfOverload(functionDeclaration)) {
+                        signature = typeChecker.getSignatureFromDeclaration(functionDeclaration);
+                    }
+                    else {
+                        signature = allSignatures[0];
+                    }
+
+                    if (functionDeclaration.kind === SyntaxKind.Constructor) {
+                        // show (constructor) Type(...) signature
+                        symbolKind = ScriptElementKind.constructorImplementationElement;
+                        addPrefixForAnyFunctionOrVar(type.symbol, symbolKind);
+                    }
+                    else {
+                        // (function/method) symbol(..signature)
+                        addPrefixForAnyFunctionOrVar(functionDeclaration.kind === SyntaxKind.CallSignature &&
+                            !(type.symbol.flags & SymbolFlags.TypeLiteral || type.symbol.flags & SymbolFlags.ObjectLiteral) ? type.symbol : symbol, symbolKind);
+                    }
+
+                    addSignatureDisplayParts(signature, allSignatures);
+                    hasAddedSymbolInfo = true;
+                }
+            }
+        }
+        if (symbolFlags & SymbolFlags.Class && !hasAddedSymbolInfo && !isThisExpression) {
+            if (getDeclarationOfKind(symbol, SyntaxKind.ClassExpression)) {
+                // Special case for class expressions because we would like to indicate that
+                // the class name is local to the class body (similar to function expression)
+                //      (local class) class <className>
+                pushTypePart(ScriptElementKind.localClassElement);
+            }
+            else {
+                // Class declaration has name which is not local.
+                displayParts.push(keywordPart(SyntaxKind.ClassKeyword));
+            }
+            displayParts.push(spacePart());
+            addFullSymbolName(symbol);
+            writeTypeParametersOfSymbol(symbol, sourceFile);
+        }
+        if ((symbolFlags & SymbolFlags.Interface) && (semanticMeaning & SemanticMeaning.Type)) {
+            addNewLineIfDisplayPartsExist();
+            displayParts.push(keywordPart(SyntaxKind.InterfaceKeyword));
+            displayParts.push(spacePart());
+            addFullSymbolName(symbol);
+            writeTypeParametersOfSymbol(symbol, sourceFile);
+        }
+        if (symbolFlags & SymbolFlags.TypeAlias) {
+            addNewLineIfDisplayPartsExist();
+            displayParts.push(keywordPart(SyntaxKind.TypeKeyword));
+            displayParts.push(spacePart());
+            addFullSymbolName(symbol);
+            writeTypeParametersOfSymbol(symbol, sourceFile);
+            displayParts.push(spacePart());
+            displayParts.push(operatorPart(SyntaxKind.EqualsToken));
+            displayParts.push(spacePart());
+            addRange(displayParts, typeToDisplayParts(typeChecker, typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration, TypeFormatFlags.InTypeAlias));
+        }
+        if (symbolFlags & SymbolFlags.Enum) {
+            addNewLineIfDisplayPartsExist();
+            if (forEach(symbol.declarations, isConstEnumDeclaration)) {
+                displayParts.push(keywordPart(SyntaxKind.ConstKeyword));
+                displayParts.push(spacePart());
+            }
+            displayParts.push(keywordPart(SyntaxKind.EnumKeyword));
+            displayParts.push(spacePart());
+            addFullSymbolName(symbol);
+        }
+        if (symbolFlags & SymbolFlags.Module) {
+            addNewLineIfDisplayPartsExist();
+            const declaration = <ModuleDeclaration>getDeclarationOfKind(symbol, SyntaxKind.ModuleDeclaration);
+            const isNamespace = declaration && declaration.name && declaration.name.kind === SyntaxKind.Identifier;
+            displayParts.push(keywordPart(isNamespace ? SyntaxKind.NamespaceKeyword : SyntaxKind.ModuleKeyword));
+            displayParts.push(spacePart());
+            addFullSymbolName(symbol);
+        }
+        if ((symbolFlags & SymbolFlags.TypeParameter) && (semanticMeaning & SemanticMeaning.Type)) {
+            addNewLineIfDisplayPartsExist();
+            displayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
+            displayParts.push(textPart("type parameter"));
+            displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
+            displayParts.push(spacePart());
+            addFullSymbolName(symbol);
+            displayParts.push(spacePart());
+            displayParts.push(keywordPart(SyntaxKind.InKeyword));
+            displayParts.push(spacePart());
+            if (symbol.parent) {
+                // Class/Interface type parameter
+                addFullSymbolName(symbol.parent, enclosingDeclaration);
+                writeTypeParametersOfSymbol(symbol.parent, enclosingDeclaration);
+            }
+            else {
+                // Method/function type parameter
+                let declaration = <Node>getDeclarationOfKind(symbol, SyntaxKind.TypeParameter);
+                Debug.assert(declaration !== undefined);
+                declaration = declaration.parent;
+
+                if (declaration) {
+                    if (isFunctionLikeKind(declaration.kind)) {
+                        const signature = typeChecker.getSignatureFromDeclaration(<SignatureDeclaration>declaration);
+                        if (declaration.kind === SyntaxKind.ConstructSignature) {
+                            displayParts.push(keywordPart(SyntaxKind.NewKeyword));
+                            displayParts.push(spacePart());
+                        }
+                        else if (declaration.kind !== SyntaxKind.CallSignature && (<SignatureDeclaration>declaration).name) {
+                            addFullSymbolName(declaration.symbol);
+                        }
+                        addRange(displayParts, signatureToDisplayParts(typeChecker, signature, sourceFile, TypeFormatFlags.WriteTypeArgumentsOfSignature));
+                    }
+                    else {
+                        // Type alias type parameter
+                        // For example
+                        //      type list<T> = T[];  // Both T will go through same code path
+                        displayParts.push(keywordPart(SyntaxKind.TypeKeyword));
+                        displayParts.push(spacePart());
+                        addFullSymbolName(declaration.symbol);
+                        writeTypeParametersOfSymbol(declaration.symbol, sourceFile);
+                    }
+                }
+            }
+        }
+        if (symbolFlags & SymbolFlags.EnumMember) {
+            addPrefixForAnyFunctionOrVar(symbol, "enum member");
+            const declaration = symbol.declarations[0];
+            if (declaration.kind === SyntaxKind.EnumMember) {
+                const constantValue = typeChecker.getConstantValue(<EnumMember>declaration);
+                if (constantValue !== undefined) {
+                    displayParts.push(spacePart());
+                    displayParts.push(operatorPart(SyntaxKind.EqualsToken));
+                    displayParts.push(spacePart());
+                    displayParts.push(displayPart(constantValue.toString(), SymbolDisplayPartKind.numericLiteral));
+                }
+            }
+        }
+        if (symbolFlags & SymbolFlags.Alias) {
+            addNewLineIfDisplayPartsExist();
+            if (symbol.declarations[0].kind === SyntaxKind.NamespaceExportDeclaration) {
+                displayParts.push(keywordPart(SyntaxKind.ExportKeyword));
+                displayParts.push(spacePart());
+                displayParts.push(keywordPart(SyntaxKind.NamespaceKeyword));
+            }
+            else {
+                displayParts.push(keywordPart(SyntaxKind.ImportKeyword));
+            }
+            displayParts.push(spacePart());
+            addFullSymbolName(symbol);
+            ts.forEach(symbol.declarations, declaration => {
+                if (declaration.kind === SyntaxKind.ImportEqualsDeclaration) {
+                    const importEqualsDeclaration = <ImportEqualsDeclaration>declaration;
+                    if (isExternalModuleImportEqualsDeclaration(importEqualsDeclaration)) {
+                        displayParts.push(spacePart());
+                        displayParts.push(operatorPart(SyntaxKind.EqualsToken));
+                        displayParts.push(spacePart());
+                        displayParts.push(keywordPart(SyntaxKind.RequireKeyword));
+                        displayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
+                        displayParts.push(displayPart(getTextOfNode(getExternalModuleImportEqualsDeclarationExpression(importEqualsDeclaration)), SymbolDisplayPartKind.stringLiteral));
+                        displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
+                    }
+                    else {
+                        const internalAliasSymbol = typeChecker.getSymbolAtLocation(importEqualsDeclaration.moduleReference);
+                        if (internalAliasSymbol) {
+                            displayParts.push(spacePart());
+                            displayParts.push(operatorPart(SyntaxKind.EqualsToken));
+                            displayParts.push(spacePart());
+                            addFullSymbolName(internalAliasSymbol, enclosingDeclaration);
+                        }
+                    }
+                    return true;
+                }
+            });
+        }
+        if (!hasAddedSymbolInfo) {
+            if (symbolKind !== ScriptElementKind.unknown) {
+                if (type) {
+                    if (isThisExpression) {
+                        addNewLineIfDisplayPartsExist();
+                        displayParts.push(keywordPart(SyntaxKind.ThisKeyword));
+                    }
+                    else {
+                        addPrefixForAnyFunctionOrVar(symbol, symbolKind);
+                    }
+
+                    // For properties, variables and local vars: show the type
+                    if (symbolKind === ScriptElementKind.memberVariableElement ||
+                        symbolFlags & SymbolFlags.Variable ||
+                        symbolKind === ScriptElementKind.localVariableElement ||
+                        isThisExpression) {
+                        displayParts.push(punctuationPart(SyntaxKind.ColonToken));
+                        displayParts.push(spacePart());
+                        // If the type is type parameter, format it specially
+                        if (type.symbol && type.symbol.flags & SymbolFlags.TypeParameter) {
+                            const typeParameterParts = mapToDisplayParts(writer => {
+                                typeChecker.getSymbolDisplayBuilder().buildTypeParameterDisplay(<TypeParameter>type, writer, enclosingDeclaration);
+                            });
+                            addRange(displayParts, typeParameterParts);
+                        }
+                        else {
+                            addRange(displayParts, typeToDisplayParts(typeChecker, type, enclosingDeclaration));
+                        }
+                    }
+                    else if (symbolFlags & SymbolFlags.Function ||
+                        symbolFlags & SymbolFlags.Method ||
+                        symbolFlags & SymbolFlags.Constructor ||
+                        symbolFlags & SymbolFlags.Signature ||
+                        symbolFlags & SymbolFlags.Accessor ||
+                        symbolKind === ScriptElementKind.memberFunctionElement) {
+                        const allSignatures = type.getNonNullableType().getCallSignatures();
+                        addSignatureDisplayParts(allSignatures[0], allSignatures);
+                    }
+                }
+            }
+            else {
+                symbolKind = getSymbolKind(typeChecker, symbol, location);
+            }
+        }
+
+        if (!documentation) {
+            documentation = symbol.getDocumentationComment();
+            if (documentation.length === 0 && symbol.flags & SymbolFlags.Property) {
+                // For some special property access expressions like `experts.foo = foo` or `module.exports.foo = foo`
+                // there documentation comments might be attached to the right hand side symbol of their declarations.
+                // The pattern of such special property access is that the parent symbol is the symbol of the file.
+                if (symbol.parent && forEach(symbol.parent.declarations, declaration => declaration.kind === SyntaxKind.SourceFile)) {
+                    for (const declaration of symbol.declarations) {
+                        if (!declaration.parent || declaration.parent.kind !== SyntaxKind.BinaryExpression) {
+                            continue;
+                        }
+
+                        const rhsSymbol = typeChecker.getSymbolAtLocation((<BinaryExpression>declaration.parent).right);
+                        if (!rhsSymbol) {
+                            continue;
+                        }
+
+                        documentation = rhsSymbol.getDocumentationComment();
+                        if (documentation.length > 0) {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        return { displayParts, documentation, symbolKind };
+
+        function addNewLineIfDisplayPartsExist() {
+            if (displayParts.length) {
+                displayParts.push(lineBreakPart());
+            }
+        }
+
+        function addFullSymbolName(symbol: Symbol, enclosingDeclaration?: Node) {
+            const fullSymbolDisplayParts = symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration || sourceFile, /*meaning*/ undefined,
+                SymbolFormatFlags.WriteTypeParametersOrArguments | SymbolFormatFlags.UseOnlyExternalAliasing);
+            addRange(displayParts, fullSymbolDisplayParts);
+        }
+
+        function addPrefixForAnyFunctionOrVar(symbol: Symbol, symbolKind: string) {
+            addNewLineIfDisplayPartsExist();
+            if (symbolKind) {
+                pushTypePart(symbolKind);
+                displayParts.push(spacePart());
+                addFullSymbolName(symbol);
+            }
+        }
+
+        function pushTypePart(symbolKind: string) {
+            switch (symbolKind) {
+                case ScriptElementKind.variableElement:
+                case ScriptElementKind.functionElement:
+                case ScriptElementKind.letElement:
+                case ScriptElementKind.constElement:
+                case ScriptElementKind.constructorImplementationElement:
+                    displayParts.push(textOrKeywordPart(symbolKind));
+                    return;
+                default:
+                    displayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
+                    displayParts.push(textOrKeywordPart(symbolKind));
+                    displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
+                    return;
+            }
+        }
+
+        function addSignatureDisplayParts(signature: Signature, allSignatures: Signature[], flags?: TypeFormatFlags) {
+            addRange(displayParts, signatureToDisplayParts(typeChecker, signature, enclosingDeclaration, flags | TypeFormatFlags.WriteTypeArgumentsOfSignature));
+            if (allSignatures.length > 1) {
+                displayParts.push(spacePart());
+                displayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
+                displayParts.push(operatorPart(SyntaxKind.PlusToken));
+                displayParts.push(displayPart((allSignatures.length - 1).toString(), SymbolDisplayPartKind.numericLiteral));
+                displayParts.push(spacePart());
+                displayParts.push(textPart(allSignatures.length === 2 ? "overload" : "overloads"));
+                displayParts.push(punctuationPart(SyntaxKind.CloseParenToken));
+            }
+            documentation = signature.getDocumentationComment();
+        }
+
+        function writeTypeParametersOfSymbol(symbol: Symbol, enclosingDeclaration: Node) {
+            const typeParameterParts = mapToDisplayParts(writer => {
+                typeChecker.getSymbolDisplayBuilder().buildTypeParameterDisplayFromSymbol(symbol, writer, enclosingDeclaration);
+            });
+            addRange(displayParts, typeParameterParts);
+        }
+    }
+
+    function isLocalVariableOrFunction(symbol: Symbol) {
+        if (symbol.parent) {
+            return false; // This is exported symbol
+        }
+
+        return ts.forEach(symbol.declarations, declaration => {
+            // Function expressions are local
+            if (declaration.kind === SyntaxKind.FunctionExpression) {
+                return true;
+            }
+
+            if (declaration.kind !== SyntaxKind.VariableDeclaration && declaration.kind !== SyntaxKind.FunctionDeclaration) {
+                return false;
+            }
+
+            // If the parent is not sourceFile or module block it is local variable
+            for (let parent = declaration.parent; !isFunctionBlock(parent); parent = parent.parent) {
+                // Reached source file or module block
+                if (parent.kind === SyntaxKind.SourceFile || parent.kind === SyntaxKind.ModuleBlock) {
+                    return false;
+                }
+            }
+
+            // parent is in function block
+            return true;
+        });
+    }
+}

src/services/transpile.ts

@@ -0,0 +1,154 @@
+namespace ts {
+    export interface TranspileOptions {
+        compilerOptions?: CompilerOptions;
+        fileName?: string;
+        reportDiagnostics?: boolean;
+        moduleName?: string;
+        renamedDependencies?: MapLike<string>;
+    }
+
+    export interface TranspileOutput {
+        outputText: string;
+        diagnostics?: Diagnostic[];
+        sourceMapText?: string;
+    }
+
+    /*
+     * This function will compile source text from 'input' argument using specified compiler options.
+     * If not options are provided - it will use a set of default compiler options.
+     * Extra compiler options that will unconditionally be used by this function are:
+     * - isolatedModules = true
+     * - allowNonTsExtensions = true
+     * - noLib = true
+     * - noResolve = true
+     */
+    export function transpileModule(input: string, transpileOptions: TranspileOptions): TranspileOutput {
+        const diagnostics: Diagnostic[] = [];
+
+        const options: CompilerOptions = transpileOptions.compilerOptions ? fixupCompilerOptions(transpileOptions.compilerOptions, diagnostics) : getDefaultCompilerOptions();
+
+        options.isolatedModules = true;
+
+        // transpileModule does not write anything to disk so there is no need to verify that there are no conflicts between input and output paths.
+        options.suppressOutputPathCheck = true;
+
+        // Filename can be non-ts file.
+        options.allowNonTsExtensions = true;
+
+        // We are not returning a sourceFile for lib file when asked by the program,
+        // so pass --noLib to avoid reporting a file not found error.
+        options.noLib = true;
+
+        // Clear out other settings that would not be used in transpiling this module
+        options.lib = undefined;
+        options.types = undefined;
+        options.noEmit = undefined;
+        options.noEmitOnError = undefined;
+        options.paths = undefined;
+        options.rootDirs = undefined;
+        options.declaration = undefined;
+        options.declarationDir = undefined;
+        options.out = undefined;
+        options.outFile = undefined;
+
+        // We are not doing a full typecheck, we are not resolving the whole context,
+        // so pass --noResolve to avoid reporting missing file errors.
+        options.noResolve = true;
+
+        // if jsx is specified then treat file as .tsx
+        const inputFileName = transpileOptions.fileName || (options.jsx ? "module.tsx" : "module.ts");
+        const sourceFile = createSourceFile(inputFileName, input, options.target);
+        if (transpileOptions.moduleName) {
+            sourceFile.moduleName = transpileOptions.moduleName;
+        }
+
+        if (transpileOptions.renamedDependencies) {
+            sourceFile.renamedDependencies = createMap(transpileOptions.renamedDependencies);
+        }
+
+        const newLine = getNewLineCharacter(options);
+
+        // Output
+        let outputText: string;
+        let sourceMapText: string;
+
+        // Create a compilerHost object to allow the compiler to read and write files
+        const compilerHost: CompilerHost = {
+            getSourceFile: (fileName, target) => fileName === normalizePath(inputFileName) ? sourceFile : undefined,
+            writeFile: (name, text, writeByteOrderMark) => {
+                if (fileExtensionIs(name, ".map")) {
+                    Debug.assert(sourceMapText === undefined, `Unexpected multiple source map outputs for the file '${name}'`);
+                    sourceMapText = text;
+                }
+                else {
+                    Debug.assert(outputText === undefined, `Unexpected multiple outputs for the file: '${name}'`);
+                    outputText = text;
+                }
+            },
+            getDefaultLibFileName: () => "lib.d.ts",
+            useCaseSensitiveFileNames: () => false,
+            getCanonicalFileName: fileName => fileName,
+            getCurrentDirectory: () => "",
+            getNewLine: () => newLine,
+            fileExists: (fileName): boolean => fileName === inputFileName,
+            readFile: (fileName): string => "",
+            directoryExists: directoryExists => true,
+            getDirectories: (path: string) => []
+        };
+
+        const program = createProgram([inputFileName], options, compilerHost);
+
+        if (transpileOptions.reportDiagnostics) {
+            addRange(/*to*/ diagnostics, /*from*/ program.getSyntacticDiagnostics(sourceFile));
+            addRange(/*to*/ diagnostics, /*from*/ program.getOptionsDiagnostics());
+        }
+        // Emit
+        program.emit();
+
+        Debug.assert(outputText !== undefined, "Output generation failed");
+
+        return { outputText, diagnostics, sourceMapText };
+    }
+
+    /*
+     * This is a shortcut function for transpileModule - it accepts transpileOptions as parameters and returns only outputText part of the result.
+     */
+    export function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[], moduleName?: string): string {
+        const output = transpileModule(input, { compilerOptions, fileName, reportDiagnostics: !!diagnostics, moduleName });
+        // addRange correctly handles cases when wither 'from' or 'to' argument is missing
+        addRange(diagnostics, output.diagnostics);
+        return output.outputText;
+    }
+
+    let commandLineOptionsStringToEnum: CommandLineOptionOfCustomType[];
+
+    /** JS users may pass in string values for enum compiler options (such as ModuleKind), so convert. */
+    function fixupCompilerOptions(options: CompilerOptions, diagnostics: Diagnostic[]): CompilerOptions {
+        // Lazily create this value to fix module loading errors.
+        commandLineOptionsStringToEnum = commandLineOptionsStringToEnum || <CommandLineOptionOfCustomType[]>filter(optionDeclarations, o =>
+            typeof o.type === "object" && !forEachProperty(o.type, v => typeof v !== "number"));
+
+        options = clone(options);
+
+        for (const opt of commandLineOptionsStringToEnum) {
+            if (!hasProperty(options, opt.name)) {
+                continue;
+            }
+
+            const value = options[opt.name];
+            // Value should be a key of opt.type
+            if (typeof value === "string") {
+                // If value is not a string, this will fail
+                options[opt.name] = parseCustomTypeOption(opt, value, diagnostics);
+            }
+            else {
+                if (!forEachProperty(opt.type, v => v === value)) {
+                    // Supplied value isn't a valid enum value.
+                    diagnostics.push(createCompilerDiagnosticForInvalidCustomType(opt));
+                }
+            }
+        }
+
+        return options;
+    }
+}

src/services/tsconfig.json

@@ -40,17 +40,27 @@
         "../compiler/program.ts",
         "../compiler/commandLineParser.ts",
         "../compiler/diagnosticInformationMap.generated.ts",
+        "types.ts",
+        "utilities.ts",
         "breakpoints.ts",
+        "classifier.ts",
+        "completions.ts",
+        "documentHighlights.ts",
+        "findAllReferences.ts",
+        "goToDefinition.ts",
+        "jsDoc.ts",
+        "jsTyping.ts",
         "navigateTo.ts",
         "navigationBar.ts",
         "outliningElementsCollector.ts",
         "patternMatcher.ts",
+        "preProcess.ts",
+        "rename.ts",
         "services.ts",
+        "transpile.ts",
         "shims.ts",
         "signatureHelp.ts",
-        "types.ts",
-        "utilities.ts",
-        "jsTyping.ts",
+        "symbolDisplay.ts",
         "formatting/formatting.ts",
         "formatting/formattingContext.ts",
         "formatting/formattingRequestKind.ts",

src/services/utilities.ts

@@ -1,6 +1,387 @@
 // These utilities are common to multiple language service features.
 /* @internal */
 namespace ts {
+    export const scanner: Scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ true);
+    export const emptyArray: any[] = [];
+
+    export const enum SemanticMeaning {
+        None = 0x0,
+        Value = 0x1,
+        Type = 0x2,
+        Namespace = 0x4,
+        All = Value | Type | Namespace
+    }
+
+    export function getMeaningFromDeclaration(node: Node): SemanticMeaning {
+        switch (node.kind) {
+            case SyntaxKind.Parameter:
+            case SyntaxKind.VariableDeclaration:
+            case SyntaxKind.BindingElement:
+            case SyntaxKind.PropertyDeclaration:
+            case SyntaxKind.PropertySignature:
+            case SyntaxKind.PropertyAssignment:
+            case SyntaxKind.ShorthandPropertyAssignment:
+            case SyntaxKind.EnumMember:
+            case SyntaxKind.MethodDeclaration:
+            case SyntaxKind.MethodSignature:
+            case SyntaxKind.Constructor:
+            case SyntaxKind.GetAccessor:
+            case SyntaxKind.SetAccessor:
+            case SyntaxKind.FunctionDeclaration:
+            case SyntaxKind.FunctionExpression:
+            case SyntaxKind.ArrowFunction:
+            case SyntaxKind.CatchClause:
+                return SemanticMeaning.Value;
+
+            case SyntaxKind.TypeParameter:
+            case SyntaxKind.InterfaceDeclaration:
+            case SyntaxKind.TypeAliasDeclaration:
+            case SyntaxKind.TypeLiteral:
+                return SemanticMeaning.Type;
+
+            case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.EnumDeclaration:
+                return SemanticMeaning.Value | SemanticMeaning.Type;
+
+            case SyntaxKind.ModuleDeclaration:
+                if (isAmbientModule(<ModuleDeclaration>node)) {
+                    return SemanticMeaning.Namespace | SemanticMeaning.Value;
+                }
+                else if (getModuleInstanceState(node) === ModuleInstanceState.Instantiated) {
+                    return SemanticMeaning.Namespace | SemanticMeaning.Value;
+                }
+                else {
+                    return SemanticMeaning.Namespace;
+                }
+
+            case SyntaxKind.NamedImports:
+            case SyntaxKind.ImportSpecifier:
+            case SyntaxKind.ImportEqualsDeclaration:
+            case SyntaxKind.ImportDeclaration:
+            case SyntaxKind.ExportAssignment:
+            case SyntaxKind.ExportDeclaration:
+                return SemanticMeaning.Value | SemanticMeaning.Type | SemanticMeaning.Namespace;
+
+            // An external module can be a Value
+            case SyntaxKind.SourceFile:
+                return SemanticMeaning.Namespace | SemanticMeaning.Value;
+        }
+
+        return SemanticMeaning.Value | SemanticMeaning.Type | SemanticMeaning.Namespace;
+    }
+
+    export function getMeaningFromLocation(node: Node): SemanticMeaning {
+        if (node.parent.kind === SyntaxKind.ExportAssignment) {
+            return SemanticMeaning.Value | SemanticMeaning.Type | SemanticMeaning.Namespace;
+        }
+        else if (isInRightSideOfImport(node)) {
+            return getMeaningFromRightHandSideOfImportEquals(node);
+        }
+        else if (isDeclarationName(node)) {
+            return getMeaningFromDeclaration(node.parent);
+        }
+        else if (isTypeReference(node)) {
+            return SemanticMeaning.Type;
+        }
+        else if (isNamespaceReference(node)) {
+            return SemanticMeaning.Namespace;
+        }
+        else {
+            return SemanticMeaning.Value;
+        }
+    }
+
+    function getMeaningFromRightHandSideOfImportEquals(node: Node) {
+        Debug.assert(node.kind === SyntaxKind.Identifier);
+
+        //     import a = |b|; // Namespace
+        //     import a = |b.c|; // Value, type, namespace
+        //     import a = |b.c|.d; // Namespace
+
+        if (node.parent.kind === SyntaxKind.QualifiedName &&
+            (<QualifiedName>node.parent).right === node &&
+            node.parent.parent.kind === SyntaxKind.ImportEqualsDeclaration) {
+            return SemanticMeaning.Value | SemanticMeaning.Type | SemanticMeaning.Namespace;
+        }
+        return SemanticMeaning.Namespace;
+    }
+
+    function isInRightSideOfImport(node: Node) {
+        while (node.parent.kind === SyntaxKind.QualifiedName) {
+            node = node.parent;
+        }
+        return isInternalModuleImportEqualsDeclaration(node.parent) && (<ImportEqualsDeclaration>node.parent).moduleReference === node;
+    }
+
+    function isNamespaceReference(node: Node): boolean {
+        return isQualifiedNameNamespaceReference(node) || isPropertyAccessNamespaceReference(node);
+    }
+
+    function isQualifiedNameNamespaceReference(node: Node): boolean {
+        let root = node;
+        let isLastClause = true;
+        if (root.parent.kind === SyntaxKind.QualifiedName) {
+            while (root.parent && root.parent.kind === SyntaxKind.QualifiedName) {
+                root = root.parent;
+            }
+
+            isLastClause = (<QualifiedName>root).right === node;
+        }
+
+        return root.parent.kind === SyntaxKind.TypeReference && !isLastClause;
+    }
+
+    function isPropertyAccessNamespaceReference(node: Node): boolean {
+        let root = node;
+        let isLastClause = true;
+        if (root.parent.kind === SyntaxKind.PropertyAccessExpression) {
+            while (root.parent && root.parent.kind === SyntaxKind.PropertyAccessExpression) {
+                root = root.parent;
+            }
+
+            isLastClause = (<PropertyAccessExpression>root).name === node;
+        }
+
+        if (!isLastClause && root.parent.kind === SyntaxKind.ExpressionWithTypeArguments && root.parent.parent.kind === SyntaxKind.HeritageClause) {
+            const decl = root.parent.parent.parent;
+            return (decl.kind === SyntaxKind.ClassDeclaration && (<HeritageClause>root.parent.parent).token === SyntaxKind.ImplementsKeyword) ||
+                (decl.kind === SyntaxKind.InterfaceDeclaration && (<HeritageClause>root.parent.parent).token === SyntaxKind.ExtendsKeyword);
+        }
+
+        return false;
+    }
+
+    function isTypeReference(node: Node): boolean {
+        if (isRightSideOfQualifiedNameOrPropertyAccess(node)) {
+            node = node.parent;
+        }
+
+        return node.parent.kind === SyntaxKind.TypeReference ||
+            (node.parent.kind === SyntaxKind.ExpressionWithTypeArguments && !isExpressionWithTypeArgumentsInClassExtendsClause(<ExpressionWithTypeArguments>node.parent)) ||
+            (node.kind === SyntaxKind.ThisKeyword && !isPartOfExpression(node)) ||
+            node.kind === SyntaxKind.ThisType;
+    }
+
+    export function isCallExpressionTarget(node: Node): boolean {
+        return isCallOrNewExpressionTarget(node, SyntaxKind.CallExpression);
+    }
+
+    export function isNewExpressionTarget(node: Node): boolean {
+        return isCallOrNewExpressionTarget(node, SyntaxKind.NewExpression);
+    }
+
+    function isCallOrNewExpressionTarget(node: Node, kind: SyntaxKind) {
+        const target = climbPastPropertyAccess(node);
+        return target && target.parent && target.parent.kind === kind && (<CallExpression>target.parent).expression === target;
+    }
+
+    export function climbPastPropertyAccess(node: Node) {
+        return isRightSideOfPropertyAccess(node) ? node.parent : node;
+    }
+
+    export function getTargetLabel(referenceNode: Node, labelName: string): Identifier {
+        while (referenceNode) {
+            if (referenceNode.kind === SyntaxKind.LabeledStatement && (<LabeledStatement>referenceNode).label.text === labelName) {
+                return (<LabeledStatement>referenceNode).label;
+            }
+            referenceNode = referenceNode.parent;
+        }
+        return undefined;
+    }
+
+    export function isJumpStatementTarget(node: Node): boolean {
+        return node.kind === SyntaxKind.Identifier &&
+            (node.parent.kind === SyntaxKind.BreakStatement || node.parent.kind === SyntaxKind.ContinueStatement) &&
+            (<BreakOrContinueStatement>node.parent).label === node;
+    }
+
+    function isLabelOfLabeledStatement(node: Node): boolean {
+        return node.kind === SyntaxKind.Identifier &&
+            node.parent.kind === SyntaxKind.LabeledStatement &&
+            (<LabeledStatement>node.parent).label === node;
+    }
+
+    export function isLabelName(node: Node): boolean {
+        return isLabelOfLabeledStatement(node) || isJumpStatementTarget(node);
+    }
+
+    export function isRightSideOfQualifiedName(node: Node) {
+        return node.parent.kind === SyntaxKind.QualifiedName && (<QualifiedName>node.parent).right === node;
+    }
+
+    export function isRightSideOfPropertyAccess(node: Node) {
+        return node && node.parent && node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node;
+    }
+
+    export function isNameOfModuleDeclaration(node: Node) {
+        return node.parent.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>node.parent).name === node;
+    }
+
+    export function isNameOfFunctionDeclaration(node: Node): boolean {
+        return node.kind === SyntaxKind.Identifier &&
+            isFunctionLike(node.parent) && (<FunctionLikeDeclaration>node.parent).name === node;
+    }
+
+    export function isLiteralNameOfPropertyDeclarationOrIndexAccess(node: Node): boolean {
+        if (node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NumericLiteral) {
+            switch (node.parent.kind) {
+                case SyntaxKind.PropertyDeclaration:
+                case SyntaxKind.PropertySignature:
+                case SyntaxKind.PropertyAssignment:
+                case SyntaxKind.EnumMember:
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.MethodSignature:
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                case SyntaxKind.ModuleDeclaration:
+                    return (<Declaration>node.parent).name === node;
+                case SyntaxKind.ElementAccessExpression:
+                    return (<ElementAccessExpression>node.parent).argumentExpression === node;
+                case SyntaxKind.ComputedPropertyName:
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+    export function isExpressionOfExternalModuleImportEqualsDeclaration(node: Node) {
+        return isExternalModuleImportEqualsDeclaration(node.parent.parent) &&
+            getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node;
+    }
+
+    /** Returns true if the position is within a comment */
+    export function isInsideComment(sourceFile: SourceFile, token: Node, position: number): boolean {
+        // The position has to be: 1. in the leading trivia (before token.getStart()), and 2. within a comment
+        return position <= token.getStart(sourceFile) &&
+            (isInsideCommentRange(getTrailingCommentRanges(sourceFile.text, token.getFullStart())) ||
+                isInsideCommentRange(getLeadingCommentRanges(sourceFile.text, token.getFullStart())));
+
+        function isInsideCommentRange(comments: CommentRange[]): boolean {
+            return forEach(comments, comment => {
+                // either we are 1. completely inside the comment, or 2. at the end of the comment
+                if (comment.pos < position && position < comment.end) {
+                    return true;
+                }
+                else if (position === comment.end) {
+                    const text = sourceFile.text;
+                    const width = comment.end - comment.pos;
+                    // is single line comment or just /*
+                    if (width <= 2 || text.charCodeAt(comment.pos + 1) === CharacterCodes.slash) {
+                        return true;
+                    }
+                    else {
+                        // is unterminated multi-line comment
+                        return !(text.charCodeAt(comment.end - 1) === CharacterCodes.slash &&
+                            text.charCodeAt(comment.end - 2) === CharacterCodes.asterisk);
+                    }
+                }
+                return false;
+            });
+        }
+    }
+
+    export function getContainerNode(node: Node): Declaration {
+        while (true) {
+            node = node.parent;
+            if (!node) {
+                return undefined;
+            }
+            switch (node.kind) {
+                case SyntaxKind.SourceFile:
+                case SyntaxKind.MethodDeclaration:
+                case SyntaxKind.MethodSignature:
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.FunctionExpression:
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                case SyntaxKind.ClassDeclaration:
+                case SyntaxKind.InterfaceDeclaration:
+                case SyntaxKind.EnumDeclaration:
+                case SyntaxKind.ModuleDeclaration:
+                    return <Declaration>node;
+            }
+        }
+    }
+
+    export function getNodeKind(node: Node): string {
+        switch (node.kind) {
+            case SyntaxKind.SourceFile:
+                return isExternalModule(<SourceFile>node) ? ScriptElementKind.moduleElement : ScriptElementKind.scriptElement;
+            case SyntaxKind.ModuleDeclaration:
+                return ScriptElementKind.moduleElement;
+            case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.ClassExpression:
+                return ScriptElementKind.classElement;
+            case SyntaxKind.InterfaceDeclaration: return ScriptElementKind.interfaceElement;
+            case SyntaxKind.TypeAliasDeclaration: return ScriptElementKind.typeElement;
+            case SyntaxKind.EnumDeclaration: return ScriptElementKind.enumElement;
+            case SyntaxKind.VariableDeclaration:
+                return getKindOfVariableDeclaration(<VariableDeclaration>node);
+            case SyntaxKind.BindingElement:
+                return getKindOfVariableDeclaration(<VariableDeclaration>getRootDeclaration(node));
+            case SyntaxKind.ArrowFunction:
+            case SyntaxKind.FunctionDeclaration:
+            case SyntaxKind.FunctionExpression:
+                return ScriptElementKind.functionElement;
+            case SyntaxKind.GetAccessor: return ScriptElementKind.memberGetAccessorElement;
+            case SyntaxKind.SetAccessor: return ScriptElementKind.memberSetAccessorElement;
+            case SyntaxKind.MethodDeclaration:
+            case SyntaxKind.MethodSignature:
+                return ScriptElementKind.memberFunctionElement;
+            case SyntaxKind.PropertyDeclaration:
+            case SyntaxKind.PropertySignature:
+                return ScriptElementKind.memberVariableElement;
+            case SyntaxKind.IndexSignature: return ScriptElementKind.indexSignatureElement;
+            case SyntaxKind.ConstructSignature: return ScriptElementKind.constructSignatureElement;
+            case SyntaxKind.CallSignature: return ScriptElementKind.callSignatureElement;
+            case SyntaxKind.Constructor: return ScriptElementKind.constructorImplementationElement;
+            case SyntaxKind.TypeParameter: return ScriptElementKind.typeParameterElement;
+            case SyntaxKind.EnumMember: return ScriptElementKind.enumMemberElement;
+            case SyntaxKind.Parameter: return hasModifier(node, ModifierFlags.ParameterPropertyModifier) ? ScriptElementKind.memberVariableElement : ScriptElementKind.parameterElement;
+            case SyntaxKind.ImportEqualsDeclaration:
+            case SyntaxKind.ImportSpecifier:
+            case SyntaxKind.ImportClause:
+            case SyntaxKind.ExportSpecifier:
+            case SyntaxKind.NamespaceImport:
+                return ScriptElementKind.alias;
+            case SyntaxKind.JSDocTypedefTag:
+                return ScriptElementKind.typeElement;
+            default:
+                return ScriptElementKind.unknown;
+        }
+
+        function getKindOfVariableDeclaration(v: VariableDeclaration): string {
+            return isConst(v)
+                ? ScriptElementKind.constElement
+                : isLet(v)
+                    ? ScriptElementKind.letElement
+                    : ScriptElementKind.variableElement;
+        }
+    }
+
+    export function getStringLiteralTypeForNode(node: StringLiteral | LiteralTypeNode, typeChecker: TypeChecker): LiteralType {
+        const searchNode = node.parent.kind === SyntaxKind.LiteralType ? <LiteralTypeNode>node.parent : node;
+        const type = typeChecker.getTypeAtLocation(searchNode);
+        if (type && type.flags & TypeFlags.StringLiteral) {
+            return <LiteralType>type;
+        }
+        return undefined;
+    }
+
+    export function isThis(node: Node): boolean {
+        switch (node.kind) {
+            case SyntaxKind.ThisKeyword:
+            // case SyntaxKind.ThisType: TODO: GH#9267
+                return true;
+            case SyntaxKind.Identifier:
+                // 'this' as a parameter
+                return (node as Identifier).originalKeywordKind === SyntaxKind.ThisKeyword && node.parent.kind === SyntaxKind.Parameter;
+            default:
+                return false;
+        }
+    }
+
     // Matches the beginning of a triple slash directive
     const tripleSlashDirectivePrefixRegex = /^\/\/\/\s*</;
 

tests/baselines/reference/enumWithInfinityProperty.js

@@ -0,0 +1,11 @@
+//// [enumWithInfinityProperty.ts]
+enum A {
+    Infinity = 1
+}
+
+
+//// [enumWithInfinityProperty.js]
+var A;
+(function (A) {
+    A[A["Infinity"] = 1] = "Infinity";
+})(A || (A = {}));

tests/baselines/reference/enumWithInfinityProperty.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/compiler/enumWithInfinityProperty.ts ===
+enum A {
+>A : Symbol(A, Decl(enumWithInfinityProperty.ts, 0, 0))
+
+    Infinity = 1
+>Infinity : Symbol(A.Infinity, Decl(enumWithInfinityProperty.ts, 0, 8))
+}
+

tests/baselines/reference/enumWithInfinityProperty.types

@@ -0,0 +1,9 @@
+=== tests/cases/compiler/enumWithInfinityProperty.ts ===
+enum A {
+>A : A
+
+    Infinity = 1
+>Infinity : A
+>1 : number
+}
+

tests/baselines/reference/enumWithNaNProperty.js

@@ -0,0 +1,11 @@
+//// [enumWithNaNProperty.ts]
+enum A {
+    NaN = 1
+}
+
+
+//// [enumWithNaNProperty.js]
+var A;
+(function (A) {
+    A[A["NaN"] = 1] = "NaN";
+})(A || (A = {}));

tests/baselines/reference/enumWithNaNProperty.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/compiler/enumWithNaNProperty.ts ===
+enum A {
+>A : Symbol(A, Decl(enumWithNaNProperty.ts, 0, 0))
+
+    NaN = 1
+>NaN : Symbol(A.NaN, Decl(enumWithNaNProperty.ts, 0, 8))
+}
+

tests/baselines/reference/enumWithNaNProperty.types

@@ -0,0 +1,9 @@
+=== tests/cases/compiler/enumWithNaNProperty.ts ===
+enum A {
+>A : A
+
+    NaN = 1
+>NaN : A
+>1 : number
+}
+

tests/baselines/reference/enumWithNegativeInfinityProperty.js

@@ -0,0 +1,11 @@
+//// [enumWithNegativeInfinityProperty.ts]
+enum A {
+    "-Infinity" = 1
+}
+
+
+//// [enumWithNegativeInfinityProperty.js]
+var A;
+(function (A) {
+    A[A["-Infinity"] = 1] = "-Infinity";
+})(A || (A = {}));

tests/baselines/reference/enumWithNegativeInfinityProperty.symbols

@@ -0,0 +1,7 @@
+=== tests/cases/compiler/enumWithNegativeInfinityProperty.ts ===
+enum A {
+>A : Symbol(A, Decl(enumWithNegativeInfinityProperty.ts, 0, 0))
+
+    "-Infinity" = 1
+}
+

tests/baselines/reference/enumWithNegativeInfinityProperty.types

@@ -0,0 +1,8 @@
+=== tests/cases/compiler/enumWithNegativeInfinityProperty.ts ===
+enum A {
+>A : A
+
+    "-Infinity" = 1
+>1 : number
+}
+

tests/baselines/reference/quickInfoDisplayPartsArrowFunctionExpression.baseline

@@ -0,0 +1,514 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsArrowFunctionExpression.ts",
+      "position": 4
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 4,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "x",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "any",
+          "kind": "keyword"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=>",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "number",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsArrowFunctionExpression.ts",
+      "position": 8
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 8,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "any",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsArrowFunctionExpression.ts",
+      "position": 21
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 21,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "y",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "any",
+          "kind": "keyword"
+        },
+        {
+          "text": ",",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "b",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "any",
+          "kind": "keyword"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=>",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "number",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsArrowFunctionExpression.ts",
+      "position": 26
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 26,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "any",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsArrowFunctionExpression.ts",
+      "position": 29
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 29,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "b",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "any",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsArrowFunctionExpression.ts",
+      "position": 43
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 43,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "z",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "number",
+          "kind": "keyword"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=>",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "number",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsArrowFunctionExpression.ts",
+      "position": 48
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 48,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "number",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsArrowFunctionExpression.ts",
+      "position": 70
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 70,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "z2",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=>",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "number",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsClass.baseline

@@ -0,0 +1,199 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClass.ts",
+      "position": 6
+    },
+    "quickInfo": {
+      "kind": "class",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 6,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "class",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClass.ts",
+      "position": 16
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 16,
+        "length": 9
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "cInstance",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClass.ts",
+      "position": 32
+    },
+    "quickInfo": {
+      "kind": "constructor",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 32,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "constructor",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClass.ts",
+      "position": 41
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 41,
+        "length": 4
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "cVal",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "typeof",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClass.ts",
+      "position": 48
+    },
+    "quickInfo": {
+      "kind": "class",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 48,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "class",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsClassMethod.baseline

@@ -0,0 +1,982 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 21
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "public",
+      "textSpan": {
+        "start": 21,
+        "length": 12
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "publicMethod",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 52
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "private",
+      "textSpan": {
+        "start": 52,
+        "length": 13
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "privateMethod",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 86
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "protected",
+      "textSpan": {
+        "start": 86,
+        "length": 15
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "protectedMethod",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 119
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "static",
+      "textSpan": {
+        "start": 119,
+        "length": 12
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "staticMethod",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 157
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "private,static",
+      "textSpan": {
+        "start": 157,
+        "length": 19
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "privateStaticMethod",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 204
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "protected,static",
+      "textSpan": {
+        "start": 204,
+        "length": 21
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "protectedStaticMethod",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 260
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "public",
+      "textSpan": {
+        "start": 260,
+        "length": 12
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "publicMethod",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 289
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "private",
+      "textSpan": {
+        "start": 289,
+        "length": 13
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "privateMethod",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 319
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "protected",
+      "textSpan": {
+        "start": 319,
+        "length": 15
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "protectedMethod",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 348
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "static",
+      "textSpan": {
+        "start": 348,
+        "length": 12
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "staticMethod",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 374
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "private,static",
+      "textSpan": {
+        "start": 374,
+        "length": 19
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "privateStaticMethod",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 407
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "protected,static",
+      "textSpan": {
+        "start": 407,
+        "length": 21
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "protectedStaticMethod",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 465
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 465,
+        "length": 9
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "cInstance",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 475
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "public",
+      "textSpan": {
+        "start": 475,
+        "length": 12
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "publicMethod",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 491
+    },
+    "quickInfo": {
+      "kind": "class",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 491,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "class",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts",
+      "position": 493
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "static",
+      "textSpan": {
+        "start": 493,
+        "length": 12
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "staticMethod",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsClassProperty.baseline

@@ -0,0 +1,870 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 21
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "public",
+      "textSpan": {
+        "start": 21,
+        "length": 14
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "publicProperty",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 57
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "private",
+      "textSpan": {
+        "start": 57,
+        "length": 15
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "privateProperty",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 96
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "protected",
+      "textSpan": {
+        "start": 96,
+        "length": 17
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "protectedProperty",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 134
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "static",
+      "textSpan": {
+        "start": 134,
+        "length": 14
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "staticProperty",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 177
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "private,static",
+      "textSpan": {
+        "start": 177,
+        "length": 21
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "privateStaticProperty",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 229
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "protected,static",
+      "textSpan": {
+        "start": 229,
+        "length": 23
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "protectedStaticProperty",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 290
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "public",
+      "textSpan": {
+        "start": 290,
+        "length": 14
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "publicProperty",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 319
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "private",
+      "textSpan": {
+        "start": 319,
+        "length": 15
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "privateProperty",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 349
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "protected",
+      "textSpan": {
+        "start": 349,
+        "length": 17
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "protectedProperty",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 378
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "static",
+      "textSpan": {
+        "start": 378,
+        "length": 14
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "staticProperty",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 404
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "private,static",
+      "textSpan": {
+        "start": 404,
+        "length": 21
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "privateStaticProperty",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 437
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "protected,static",
+      "textSpan": {
+        "start": 437,
+        "length": 23
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "protectedStaticProperty",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 495
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 495,
+        "length": 9
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "cInstance",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 505
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "public",
+      "textSpan": {
+        "start": 505,
+        "length": 14
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "publicProperty",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 521
+    },
+    "quickInfo": {
+      "kind": "class",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 521,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "class",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts",
+      "position": 523
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "static",
+      "textSpan": {
+        "start": 523,
+        "length": 14
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "staticProperty",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsExternalModuleAlias_file0.baseline

@@ -0,0 +1,288 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModuleAlias_file1.ts",
+      "position": 7
+    },
+    "quickInfo": {
+      "kind": "alias",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 7,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "import",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a1",
+          "kind": "aliasName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=",
+          "kind": "operator"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "require",
+          "kind": "keyword"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "\"./quickInfoDisplayPartsExternalModuleAlias_file0\"",
+          "kind": "stringLiteral"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModuleAlias_file1.ts",
+      "position": 20
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 20,
+        "length": 50
+      },
+      "displayParts": [
+        {
+          "text": "module",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a1",
+          "kind": "aliasName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModuleAlias_file1.ts",
+      "position": 77
+    },
+    "quickInfo": {
+      "kind": "alias",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 77,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "import",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a1",
+          "kind": "aliasName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=",
+          "kind": "operator"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "require",
+          "kind": "keyword"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "\"./quickInfoDisplayPartsExternalModuleAlias_file0\"",
+          "kind": "stringLiteral"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModuleAlias_file1.ts",
+      "position": 102
+    },
+    "quickInfo": {
+      "kind": "alias",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 102,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "import",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a2",
+          "kind": "aliasName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=",
+          "kind": "operator"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "require",
+          "kind": "keyword"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "\"./quickInfoDisplayPartsExternalModuleAlias_file0\"",
+          "kind": "stringLiteral"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModuleAlias_file1.ts",
+      "position": 115
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 115,
+        "length": 50
+      },
+      "displayParts": [
+        {
+          "text": "module",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a1",
+          "kind": "aliasName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModuleAlias_file1.ts",
+      "position": 172
+    },
+    "quickInfo": {
+      "kind": "alias",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 172,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "import",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a2",
+          "kind": "aliasName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=",
+          "kind": "operator"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "require",
+          "kind": "keyword"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "\"./quickInfoDisplayPartsExternalModuleAlias_file0\"",
+          "kind": "stringLiteral"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsExternalModules.baseline

@@ -0,0 +1,687 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 17
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 17,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 29
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 29,
+        "length": 26
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "namespaceElemWithoutExport",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "number",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 77
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 77,
+        "length": 23
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "namespaceElemWithExport",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "number",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 120
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 120,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "typeof",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 124
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 124,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 138
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 138,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "b",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "typeof",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 148
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 148,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 168
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 168,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 171
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 171,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "m2",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 184
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 184,
+        "length": 26
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "namespaceElemWithoutExport",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "number",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 232
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 232,
+        "length": 23
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "m2",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "namespaceElemWithExport",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "number",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 275
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 275,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "x",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "typeof",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "m2",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 279
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 279,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 282
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 282,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "m2",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 297
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 297,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "y",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "typeof",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "m2",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 307
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 307,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts",
+      "position": 310
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 310,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "m2",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsFunctionExpression.baseline

@@ -0,0 +1,352 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsFunctionExpression.ts",
+      "position": 4
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 4,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "x",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=>",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsFunctionExpression.ts",
+      "position": 17
+    },
+    "quickInfo": {
+      "kind": "local function",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 17,
+        "length": 3
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "local function",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "foo",
+          "kind": "functionName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsFunctionExpression.ts",
+      "position": 29
+    },
+    "quickInfo": {
+      "kind": "local function",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 29,
+        "length": 3
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "local function",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "foo",
+          "kind": "functionName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsFunctionExpression.ts",
+      "position": 43
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 43,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "y",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=>",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsFunctionExpression.ts",
+      "position": 74
+    },
+    "quickInfo": {
+      "kind": "local function",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 74,
+        "length": 4
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "local function",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "foo1",
+          "kind": "functionName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsFunctionExpression.ts",
+      "position": 87
+    },
+    "quickInfo": {
+      "kind": "local function",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 87,
+        "length": 4
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "local function",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "foo1",
+          "kind": "functionName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsInterface.baseline

@@ -0,0 +1,101 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInterface.ts",
+      "position": 10
+    },
+    "quickInfo": {
+      "kind": "interface",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 10,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "interface",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "i",
+          "kind": "interfaceName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInterface.ts",
+      "position": 20
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 20,
+        "length": 9
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "iInstance",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "i",
+          "kind": "interfaceName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInterface.ts",
+      "position": 31
+    },
+    "quickInfo": {
+      "kind": "interface",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 31,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "interface",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "i",
+          "kind": "interfaceName"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsInterfaceMembers.baseline

@@ -0,0 +1,507 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInterfaceMembers.ts",
+      "position": 18
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 18,
+        "length": 8
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "I",
+          "kind": "interfaceName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInterfaceMembers.ts",
+      "position": 40
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 40,
+        "length": 6
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "I",
+          "kind": "interfaceName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInterfaceMembers.ts",
+      "position": 109
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 109,
+        "length": 9
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "iInstance",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "I",
+          "kind": "interfaceName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInterfaceMembers.ts",
+      "position": 119
+    },
+    "quickInfo": {
+      "kind": "property",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 119,
+        "length": 8
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "I",
+          "kind": "interfaceName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "property",
+          "kind": "propertyName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInterfaceMembers.ts",
+      "position": 130
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 130,
+        "length": 9
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "iInstance",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "I",
+          "kind": "interfaceName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInterfaceMembers.ts",
+      "position": 140
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 140,
+        "length": 6
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "I",
+          "kind": "interfaceName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInterfaceMembers.ts",
+      "position": 150
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 150,
+        "length": 9
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "iInstance",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "I",
+          "kind": "interfaceName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=>",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInterfaceMembers.ts",
+      "position": 167
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 167,
+        "length": 15
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "anotherInstance",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "I",
+          "kind": "interfaceName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsInterfaceMembers.ts",
+      "position": 189
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 189,
+        "length": 9
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "iInstance",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "new",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "I",
+          "kind": "interfaceName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=>",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "I",
+          "kind": "interfaceName"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsLiteralLikeNames01.baseline

@@ -0,0 +1,672 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsLiteralLikeNames01.ts",
+      "position": 21
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "public",
+      "textSpan": {
+        "start": 21,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "C",
+          "kind": "className"
+        },
+        {
+          "text": "[",
+          "kind": "punctuation"
+        },
+        {
+          "text": "1",
+          "kind": "methodName"
+        },
+        {
+          "text": "]",
+          "kind": "punctuation"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsLiteralLikeNames01.ts",
+      "position": 41
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "private",
+      "textSpan": {
+        "start": 41,
+        "length": 8
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "C",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "Infinity",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsLiteralLikeNames01.ts",
+      "position": 70
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "protected",
+      "textSpan": {
+        "start": 70,
+        "length": 3
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "C",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "NaN",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsLiteralLikeNames01.ts",
+      "position": 91
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "static",
+      "textSpan": {
+        "start": 91,
+        "length": 19
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "C",
+          "kind": "className"
+        },
+        {
+          "text": "[",
+          "kind": "punctuation"
+        },
+        {
+          "text": "\"stringLiteralName\"",
+          "kind": "stringLiteral"
+        },
+        {
+          "text": "]",
+          "kind": "punctuation"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsLiteralLikeNames01.ts",
+      "position": 145
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "public",
+      "textSpan": {
+        "start": 145,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "C",
+          "kind": "className"
+        },
+        {
+          "text": "[",
+          "kind": "punctuation"
+        },
+        {
+          "text": "1",
+          "kind": "methodName"
+        },
+        {
+          "text": "]",
+          "kind": "punctuation"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsLiteralLikeNames01.ts",
+      "position": 164
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "public",
+      "textSpan": {
+        "start": 164,
+        "length": 3
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "C",
+          "kind": "className"
+        },
+        {
+          "text": "[",
+          "kind": "punctuation"
+        },
+        {
+          "text": "1",
+          "kind": "methodName"
+        },
+        {
+          "text": "]",
+          "kind": "punctuation"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsLiteralLikeNames01.ts",
+      "position": 185
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "private",
+      "textSpan": {
+        "start": 185,
+        "length": 8
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "C",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "Infinity",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsLiteralLikeNames01.ts",
+      "position": 210
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "private",
+      "textSpan": {
+        "start": 210,
+        "length": 10
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "C",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "Infinity",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsLiteralLikeNames01.ts",
+      "position": 238
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "protected",
+      "textSpan": {
+        "start": 238,
+        "length": 3
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "C",
+          "kind": "className"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "NaN",
+          "kind": "methodName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsLiteralLikeNames01.ts",
+      "position": 255
+    },
+    "quickInfo": {
+      "kind": "method",
+      "kindModifiers": "static",
+      "textSpan": {
+        "start": 255,
+        "length": 17
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "method",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "C",
+          "kind": "className"
+        },
+        {
+          "text": "[",
+          "kind": "punctuation"
+        },
+        {
+          "text": "\"stringLiteralName\"",
+          "kind": "stringLiteral"
+        },
+        {
+          "text": "]",
+          "kind": "punctuation"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsModules.baseline

@@ -0,0 +1,687 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 10
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 10,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 22
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 22,
+        "length": 26
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "namespaceElemWithoutExport",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "number",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 70
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 70,
+        "length": 23
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "namespaceElemWithExport",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "number",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 106
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 106,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "typeof",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 110
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 110,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 117
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 117,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "b",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "typeof",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 127
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 127,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 140
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 140,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 143
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 143,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "m2",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 156
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 156,
+        "length": 26
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "namespaceElemWithoutExport",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "number",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 204
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 204,
+        "length": 23
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "m2",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "namespaceElemWithExport",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "number",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 240
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 240,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "x",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "typeof",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "m2",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 244
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 244,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 247
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 247,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "m2",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 255
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 255,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "y",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "typeof",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "m2",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 265
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 265,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsModules.ts",
+      "position": 268
+    },
+    "quickInfo": {
+      "kind": "module",
+      "kindModifiers": "export",
+      "textSpan": {
+        "start": 268,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "namespace",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "m1",
+          "kind": "moduleName"
+        },
+        {
+          "text": ".",
+          "kind": "punctuation"
+        },
+        {
+          "text": "m2",
+          "kind": "moduleName"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsParameters.baseline

@@ -0,0 +1,567 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsParameters.ts",
+      "position": 9
+    },
+    "quickInfo": {
+      "kind": "function",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 9,
+        "length": 3
+      },
+      "displayParts": [
+        {
+          "text": "function",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "foo",
+          "kind": "functionName"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "param",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        },
+        {
+          "text": ",",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "optionalParam",
+          "kind": "parameterName"
+        },
+        {
+          "text": "?",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        },
+        {
+          "text": ",",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "paramWithInitializer",
+          "kind": "parameterName"
+        },
+        {
+          "text": "?",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        },
+        {
+          "text": ",",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "...",
+          "kind": "punctuation"
+        },
+        {
+          "text": "restParam",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        },
+        {
+          "text": "[",
+          "kind": "punctuation"
+        },
+        {
+          "text": "]",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "void",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsParameters.ts",
+      "position": 13
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 13,
+        "length": 5
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "param",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsParameters.ts",
+      "position": 28
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 28,
+        "length": 13
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "optionalParam",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsParameters.ts",
+      "position": 52
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 52,
+        "length": 20
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "paramWithInitializer",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsParameters.ts",
+      "position": 87
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 87,
+        "length": 9
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "restParam",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        },
+        {
+          "text": "[",
+          "kind": "punctuation"
+        },
+        {
+          "text": "]",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsParameters.ts",
+      "position": 114
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 114,
+        "length": 5
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "param",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsParameters.ts",
+      "position": 135
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 135,
+        "length": 13
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "optionalParam",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsParameters.ts",
+      "position": 164
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 164,
+        "length": 20
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "paramWithInitializer",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsParameters.ts",
+      "position": 200
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 200,
+        "length": 9
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "restParam",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        },
+        {
+          "text": "[",
+          "kind": "punctuation"
+        },
+        {
+          "text": "]",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsTypeAlias.baseline

@@ -0,0 +1,240 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeAlias.ts",
+      "position": 6
+    },
+    "quickInfo": {
+      "kind": "class",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 6,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "class",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeAlias.ts",
+      "position": 17
+    },
+    "quickInfo": {
+      "kind": "type",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 17,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "type",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "t1",
+          "kind": "aliasName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=",
+          "kind": "operator"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeAlias.ts",
+      "position": 22
+    },
+    "quickInfo": {
+      "kind": "class",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 22,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "class",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeAlias.ts",
+      "position": 29
+    },
+    "quickInfo": {
+      "kind": "var",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 29,
+        "length": 9
+      },
+      "displayParts": [
+        {
+          "text": "var",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "cInstance",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeAlias.ts",
+      "position": 40
+    },
+    "quickInfo": {
+      "kind": "type",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 40,
+        "length": 2
+      },
+      "displayParts": [
+        {
+          "text": "type",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "t1",
+          "kind": "aliasName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=",
+          "kind": "operator"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeAlias.ts",
+      "position": 49
+    },
+    "quickInfo": {
+      "kind": "constructor",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 49,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "constructor",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "c",
+          "kind": "className"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsTypeParameterInFunction.baseline

@@ -0,0 +1,990 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunction.ts",
+      "position": 9
+    },
+    "quickInfo": {
+      "kind": "function",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 9,
+        "length": 3
+      },
+      "displayParts": [
+        {
+          "text": "function",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "foo",
+          "kind": "functionName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunction.ts",
+      "position": 13
+    },
+    "quickInfo": {
+      "kind": "type parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 13,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "type parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "in",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "foo",
+          "kind": "functionName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunction.ts",
+      "position": 16
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 16,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunction.ts",
+      "position": 19
+    },
+    "quickInfo": {
+      "kind": "type parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 19,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "type parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "in",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "foo",
+          "kind": "functionName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunction.ts",
+      "position": 35
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 35,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunction.ts",
+      "position": 40
+    },
+    "quickInfo": {
+      "kind": "function",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 40,
+        "length": 3
+      },
+      "displayParts": [
+        {
+          "text": "function",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "foo",
+          "kind": "functionName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunction.ts",
+      "position": 63
+    },
+    "quickInfo": {
+      "kind": "function",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 63,
+        "length": 4
+      },
+      "displayParts": [
+        {
+          "text": "function",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "foo2",
+          "kind": "functionName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "extends",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunction.ts",
+      "position": 68
+    },
+    "quickInfo": {
+      "kind": "type parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 68,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "type parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "in",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "foo2",
+          "kind": "functionName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "extends",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunction.ts",
+      "position": 86
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 86,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "extends",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunction.ts",
+      "position": 89
+    },
+    "quickInfo": {
+      "kind": "type parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 89,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "type parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "in",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "foo2",
+          "kind": "functionName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "extends",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunction.ts",
+      "position": 105
+    },
+    "quickInfo": {
+      "kind": "parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 105,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "U",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "extends",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunction.ts",
+      "position": 110
+    },
+    "quickInfo": {
+      "kind": "function",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 110,
+        "length": 4
+      },
+      "displayParts": [
+        {
+          "text": "function",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "foo2",
+          "kind": "functionName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "\"hello\"",
+          "kind": "stringLiteral"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        },
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "a",
+          "kind": "parameterName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "\"hello\"",
+          "kind": "stringLiteral"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "\"hello\"",
+          "kind": "stringLiteral"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsTypeParameterInFunctionLikeInTypeAlias.baseline

@@ -0,0 +1,221 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunctionLikeInTypeAlias.ts",
+      "position": 30
+    },
+    "quickInfo": {
+      "kind": "type parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 30,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "type parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "A",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "in",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "type",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "MixinCtor",
+          "kind": "aliasName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "A",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunctionLikeInTypeAlias.ts",
+      "position": 59
+    },
+    "quickInfo": {
+      "kind": "type parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 59,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "type parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "A",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "in",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "type",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "MixinCtor",
+          "kind": "aliasName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "A",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunctionLikeInTypeAlias.ts",
+      "position": 139
+    },
+    "quickInfo": {
+      "kind": "type parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 139,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "type parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "A",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "in",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "type",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "MixinCtor",
+          "kind": "aliasName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "A",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsTypeParameterInTypeAlias.baseline

@@ -0,0 +1,472 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInTypeAlias.ts",
+      "position": 5
+    },
+    "quickInfo": {
+      "kind": "type",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 5,
+        "length": 4
+      },
+      "displayParts": [
+        {
+          "text": "type",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "List",
+          "kind": "aliasName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "T",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=",
+          "kind": "operator"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "T",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": "[",
+          "kind": "punctuation"
+        },
+        {
+          "text": "]",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInTypeAlias.ts",
+      "position": 10
+    },
+    "quickInfo": {
+      "kind": "type parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 10,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "type parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "T",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "in",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "type",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "List",
+          "kind": "aliasName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "T",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInTypeAlias.ts",
+      "position": 15
+    },
+    "quickInfo": {
+      "kind": "type parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 15,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "type parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "T",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "in",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "type",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "List",
+          "kind": "aliasName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "T",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInTypeAlias.ts",
+      "position": 24
+    },
+    "quickInfo": {
+      "kind": "type",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 24,
+        "length": 5
+      },
+      "displayParts": [
+        {
+          "text": "type",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "List2",
+          "kind": "aliasName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "T",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "extends",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "=",
+          "kind": "operator"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "T",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": "[",
+          "kind": "punctuation"
+        },
+        {
+          "text": "]",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInTypeAlias.ts",
+      "position": 30
+    },
+    "quickInfo": {
+      "kind": "type parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 30,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "type parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "T",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "in",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "type",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "List2",
+          "kind": "aliasName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "T",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "extends",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInTypeAlias.ts",
+      "position": 50
+    },
+    "quickInfo": {
+      "kind": "type parameter",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 50,
+        "length": 1
+      },
+      "displayParts": [
+        {
+          "text": "(",
+          "kind": "punctuation"
+        },
+        {
+          "text": "type parameter",
+          "kind": "text"
+        },
+        {
+          "text": ")",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "T",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "in",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "type",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "List2",
+          "kind": "aliasName"
+        },
+        {
+          "text": "<",
+          "kind": "punctuation"
+        },
+        {
+          "text": "T",
+          "kind": "typeParameterName"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "extends",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "string",
+          "kind": "keyword"
+        },
+        {
+          "text": ">",
+          "kind": "punctuation"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/quickInfoDisplayPartsVarWithStringTypes01.baseline

@@ -0,0 +1,141 @@
+[
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsVarWithStringTypes01.ts",
+      "position": 4
+    },
+    "quickInfo": {
+      "kind": "let",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 4,
+        "length": 5
+      },
+      "displayParts": [
+        {
+          "text": "let",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "hello",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "\"hello\"",
+          "kind": "stringLiteral"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsVarWithStringTypes01.ts",
+      "position": 44
+    },
+    "quickInfo": {
+      "kind": "let",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 44,
+        "length": 5
+      },
+      "displayParts": [
+        {
+          "text": "let",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "world",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "\"world\"",
+          "kind": "stringLiteral"
+        }
+      ],
+      "documentation": []
+    }
+  },
+  {
+    "marker": {
+      "fileName": "/tests/cases/fourslash/quickInfoDisplayPartsVarWithStringTypes01.ts",
+      "position": 74
+    },
+    "quickInfo": {
+      "kind": "let",
+      "kindModifiers": "",
+      "textSpan": {
+        "start": 74,
+        "length": 12
+      },
+      "displayParts": [
+        {
+          "text": "let",
+          "kind": "keyword"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "helloOrWorld",
+          "kind": "localName"
+        },
+        {
+          "text": ":",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "\"hello\"",
+          "kind": "stringLiteral"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "|",
+          "kind": "punctuation"
+        },
+        {
+          "text": " ",
+          "kind": "space"
+        },
+        {
+          "text": "\"world\"",
+          "kind": "stringLiteral"
+        }
+      ],
+      "documentation": []
+    }
+  }
+]

tests/baselines/reference/tsxReactEmitEntities.js

@@ -9,8 +9,27 @@ declare var React: any;
 
 <div>Dot goes here: &middot; &notAnEntity; </div>;
 <div>Be careful of &quot;-ed strings!</div>;
+<div>&#0123;&#123;braces&#x7d;&#x7D;</div>;
+// Escapes do nothing
+<div>\n</div>;
+
+// Also works in string literal attributes
+<div attr="&#0123;&hellip;&#x7D;\"></div>;
+// Does not happen for a string literal that happens to be inside an attribute (and escapes then work)
+<div attr={"&#0123;&hellip;&#x7D;\""}></div>;
+// Preserves single quotes
+<div attr='"'></div>
 
 
 //// [file.js]
 React.createElement("div", null, "Dot goes here: \u00B7 &notAnEntity; ");
 React.createElement("div", null, "Be careful of \"-ed strings!");
+React.createElement("div", null, "{{braces}}");
+// Escapes do nothing
+React.createElement("div", null, "\\n");
+// Also works in string literal attributes
+React.createElement("div", { attr: "{\u2026}\\" });
+// Does not happen for a string literal that happens to be inside an attribute (and escapes then work)
+React.createElement("div", { attr: "&#0123;&hellip;&#x7D;\"" });
+// Preserves single quotes
+React.createElement("div", { attr: '"' });

tests/baselines/reference/tsxReactEmitEntities.symbols

@@ -23,3 +23,30 @@ declare var React: any;
 >div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22))
 >div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22))
 
+<div>&#0123;&#123;braces&#x7d;&#x7D;</div>;
+>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22))
+>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22))
+
+// Escapes do nothing
+<div>\n</div>;
+>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22))
+>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22))
+
+// Also works in string literal attributes
+<div attr="&#0123;&hellip;&#x7D;\"></div>;
+>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22))
+>attr : Symbol(unknown)
+>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22))
+
+// Does not happen for a string literal that happens to be inside an attribute (and escapes then work)
+<div attr={"&#0123;&hellip;&#x7D;\""}></div>;
+>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22))
+>attr : Symbol(unknown)
+>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22))
+
+// Preserves single quotes
+<div attr='"'></div>
+>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22))
+>attr : Symbol(unknown)
+>div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 1, 22))
+

tests/baselines/reference/tsxReactEmitEntities.types

@@ -25,3 +25,36 @@ declare var React: any;
 >div : any
 >div : any
 
+<div>&#0123;&#123;braces&#x7d;&#x7D;</div>;
+><div>&#0123;&#123;braces&#x7d;&#x7D;</div> : JSX.Element
+>div : any
+>div : any
+
+// Escapes do nothing
+<div>\n</div>;
+><div>\n</div> : JSX.Element
+>div : any
+>div : any
+
+// Also works in string literal attributes
+<div attr="&#0123;&hellip;&#x7D;\"></div>;
+><div attr="&#0123;&hellip;&#x7D;\"></div> : JSX.Element
+>div : any
+>attr : any
+>div : any
+
+// Does not happen for a string literal that happens to be inside an attribute (and escapes then work)
+<div attr={"&#0123;&hellip;&#x7D;\""}></div>;
+><div attr={"&#0123;&hellip;&#x7D;\""}></div> : JSX.Element
+>div : any
+>attr : any
+>"&#0123;&hellip;&#x7D;\"" : string
+>div : any
+
+// Preserves single quotes
+<div attr='"'></div>
+><div attr='"'></div> : JSX.Element
+>div : any
+>attr : any
+>div : any
+

tests/cases/compiler/enumWithInfinityProperty.ts

@@ -0,0 +1,3 @@
+enum A {
+    Infinity = 1
+}

tests/cases/compiler/enumWithNaNProperty.ts

@@ -0,0 +1,3 @@
+enum A {
+    NaN = 1
+}

tests/cases/compiler/enumWithNegativeInfinityProperty.ts

@@ -0,0 +1,3 @@
+enum A {
+    "-Infinity" = 1
+}

tests/cases/conformance/jsx/tsxReactEmitEntities.tsx

@@ -10,3 +10,13 @@ declare var React: any;
 
 <div>Dot goes here: &middot; &notAnEntity; </div>;
 <div>Be careful of &quot;-ed strings!</div>;
+<div>&#0123;&#123;braces&#x7d;&#x7D;</div>;
+// Escapes do nothing
+<div>\n</div>;
+
+// Also works in string literal attributes
+<div attr="&#0123;&hellip;&#x7D;\"></div>;
+// Does not happen for a string literal that happens to be inside an attribute (and escapes then work)
+<div attr={"&#0123;&hellip;&#x7D;\""}></div>;
+// Preserves single quotes
+<div attr='"'></div>

tests/cases/fourslash/fourslash.ts

@@ -199,6 +199,7 @@ declare namespace FourSlashInterface {
         baselineCurrentFileBreakpointLocations(): void;
         baselineCurrentFileNameOrDottedNameSpans(): void;
         baselineGetEmitOutput(): void;
+        baselineQuickInfo(): void;
         nameOrDottedNameSpanTextIs(text: string): void;
         outliningSpansInCurrentFile(spans: TextSpan[]): void;
         todoCommentsInCurrentFile(descriptors: string[]): void;

tests/cases/fourslash/quickInfoDisplayPartsArrowFunctionExpression.ts

@@ -5,46 +5,4 @@
 ////var /*3*/z = (/*8*/a: number) => 10;
 ////var /*4*/z2 = () => 10;
 
-var marker = 0;
-function verifyInstance(instanceName: string, paramCount: number, type: string) {
-    marker++;
-    goTo.marker(marker.toString());
-    var displayParts = [{ text: "var", kind: "keyword" },
-        { text: " ", kind: "space" }, { text: instanceName, kind: "localName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "(", kind: "punctuation" }];
-    
-    for (var i = 0; i < paramCount; i++) {
-        if (i) {
-            displayParts.push({ text: ",", kind: "punctuation" }, { text: " ", kind: "space" });
-        }
-        displayParts.push({ text: !i ? "a" : "b", kind: "parameterName" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: type, kind: "keyword" });
-    }
-    displayParts.push({ text: ")", kind: "punctuation" }, { text: " ", kind: "space" },
-        { text: "=>", kind: "punctuation" }, { text: " ", kind: "space" },
-        { text: "number", kind: "keyword" });
-
-
-    verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName(marker.toString()).position, length: instanceName.length },
-        displayParts, []);
-}
-
-function verifyParameter(parameterName: string, type: string) {
-    marker++;
-    goTo.marker(marker.toString());
-    verify.verifyQuickInfoDisplayParts("parameter", "", { start: test.markerByName(marker.toString()).position, length: parameterName.length },
-        [{ text: "(", kind: "punctuation" }, { text: "parameter", kind: "text" }, { text: ")", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: parameterName, kind: "parameterName" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: type, kind: "keyword" }],
-        []);
-}
-
-verifyInstance("x", 1, "any");
-verifyInstance("y", 2, "any");
-verifyInstance("z", 1, "number");
-verifyInstance("z2", 0, "any");
-
-verifyParameter("a", "any");
-verifyParameter("a", "any");
-verifyParameter("b", "any");
-verifyParameter("a", "number");
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsClass.ts

@@ -5,35 +5,4 @@
 ////var /*2*/cInstance = new /*3*/c();
 ////var /*4*/cVal = /*5*/c;
 
-goTo.marker('1');
-verify.verifyQuickInfoDisplayParts("class", "", { start: test.markerByName("1").position, length: "c".length },
-    [{ text: "class", kind: "keyword" }, { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
-
-goTo.marker('2');
-verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName("2").position, length: "cInstance".length },
-    [{ text: "var", kind: "keyword" },
-        { text: " ", kind: "space" }, { text: "cInstance", kind: "localName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
-
-goTo.marker('3');
-verify.verifyQuickInfoDisplayParts("constructor", "", { start: test.markerByName("3").position, length: "c".length },
-    [{ text: "constructor", kind: "keyword" },
-        { text: " ", kind: "space" }, { text: "c", kind: "className" },
-        { text: "(", kind: "punctuation" }, { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
-
-goTo.marker('4');
-verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName("4").position, length: "cVal".length },
-    [{ text: "var", kind: "keyword" },
-        { text: " ", kind: "space" }, { text: "cVal", kind: "localName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" },
-        { text: "typeof", kind: "keyword" }, { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
-
-goTo.marker('5');
-verify.verifyQuickInfoDisplayParts("class", "", { start: test.markerByName("5").position, length: "c".length },
-    [{ text: "class", kind: "keyword" }, { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsClassAccessors.ts

@@ -36,94 +36,4 @@
 /////*9s*/cInstance./*10s*/publicProperty = y;
 /////*11s*/c./*12s*/staticProperty = y;
 
-function verifyClassProperty(markerName: string, kindModifiers: string, propertyName: string) {
-    goTo.marker(markerName);
-    verify.verifyQuickInfoDisplayParts("property", kindModifiers, { start: test.markerByName(markerName).position, length: propertyName.length },
-        [{ text: "(", kind: "punctuation" }, { text: "property", kind: "text" }, { text: ")", kind: "punctuation" },
-            { text: " ", kind: "space" },
-            { text: "c", kind: "className" }, { text: ".", kind: "punctuation" }, { text: propertyName, kind: "propertyName" },
-            { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "string", kind: "keyword" }],
-        []);
-}
-
-function verifyPublicProperty(markerName: string) {
-    verifyClassProperty(markerName, "public", "publicProperty");
-}
-
-function verifyPrivateProperty(markerName: string) {
-    verifyClassProperty(markerName, "private", "privateProperty");
-}
-
-function verifyProtectedProperty(markerName: string) {
-    verifyClassProperty(markerName, "protected", "protectedProperty");
-}
-
-function verifyStaticProperty(markerName: string) {
-    verifyClassProperty(markerName, "static", "staticProperty");
-}
-
-function verifyPrivateStaticProperty(markerName: string) {
-    verifyClassProperty(markerName, "private,static", "privateStaticProperty");
-}
-
-function verifyProtectedStaticProperty(markerName: string) {
-    verifyClassProperty(markerName, "protected,static", "protectedStaticProperty");
-}
-
-verifyPublicProperty('1');
-verifyPublicProperty('1s');
-verifyPrivateProperty('2');
-verifyPrivateProperty('2s');
-verifyProtectedProperty('21');
-verifyProtectedProperty('21s');
-verifyStaticProperty('3');
-verifyStaticProperty('3s');
-verifyPrivateStaticProperty('4');
-verifyPrivateStaticProperty('4s');
-verifyProtectedStaticProperty('41');
-verifyProtectedStaticProperty('41s');
-
-verifyPublicProperty('5');
-verifyPublicProperty('5s');
-verifyPrivateProperty('6');
-verifyPrivateProperty('6s');
-verifyProtectedProperty('61');
-verifyProtectedProperty('61s');
-verifyStaticProperty('7');
-verifyStaticProperty('7s');
-verifyPrivateStaticProperty('8');
-verifyPrivateStaticProperty('8s');
-verifyProtectedStaticProperty('81');
-verifyProtectedStaticProperty('81s');
-
-goTo.marker('9');
-verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName("9").position, length: "cInstance".length },
-    [{ text: "var", kind: "keyword" },
-        { text: " ", kind: "space" }, { text: "cInstance", kind: "localName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
-
-verifyPublicProperty('10');
-
-goTo.marker('11');
-verify.verifyQuickInfoDisplayParts("class", "", { start: test.markerByName("11").position, length: "c".length },
-    [{ text: "class", kind: "keyword" }, { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
-
-verifyStaticProperty('12');
-
-goTo.marker('9s');
-verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName("9s").position, length: "cInstance".length },
-    [{ text: "var", kind: "keyword" },
-        { text: " ", kind: "space" }, { text: "cInstance", kind: "localName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
-
-verifyPublicProperty('10s');
-
-goTo.marker('11s');
-verify.verifyQuickInfoDisplayParts("class", "", { start: test.markerByName("11s").position, length: "c".length },
-    [{ text: "class", kind: "keyword" }, { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
-
-verifyStaticProperty('12s');
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsClassConstructor.ts

@@ -27,100 +27,4 @@
 ////var /*23*/cWithMultipleOverloadsInstance3 = new /*24*/cWithMultipleOverloads(true);
 ////var /*25*/cWithMultipleOverloadsVal = /*26*/cWithMultipleOverloads;
 
-function verifyNonOverloadSignature(marker: string, textSpanLength: number) {
-    goTo.marker(marker);
-    verify.verifyQuickInfoDisplayParts("constructor", "", { start: test.markerByName(marker).position, length: textSpanLength },
-        [{ text: "constructor", kind: "keyword" },
-            { text: " ", kind: "space" }, { text: "c", kind: "className" },
-            { text: "(", kind: "punctuation" }, { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-        []);
-}
-
-function verifyClassInstance(markerName: string, instanceName: string, className: string) {
-    goTo.marker(markerName);
-    verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName(markerName).position, length: instanceName.length },
-        [{ text: "var", kind: "keyword" },
-            { text: " ", kind: "space" }, { text: instanceName, kind: "localName" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: className, kind: "className" }],
-        []);
-}
-
-function verifyClass(markerName: string, className: string) {
-    goTo.marker(markerName);
-    verify.verifyQuickInfoDisplayParts("class", "", { start: test.markerByName(markerName).position, length: className.length },
-        [{ text: "class", kind: "keyword" }, { text: " ", kind: "space" }, { text: className, kind: "className" }],
-        []);
-}
-
-function verifyTypeOfClass(markerName: string, typeOfVarName: string, className: string) {
-    goTo.marker(markerName);
-    verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName(markerName).position, length: typeOfVarName.length },
-        [{ text: "var", kind: "keyword" },
-            { text: " ", kind: "space" }, { text: typeOfVarName, kind: "localName" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" },
-            { text: "typeof", kind: "keyword" }, { text: " ", kind: "space" }, { text: className, kind: "className" }],
-        []);
-}
-
-function verifySingleOverloadSignature(marker: string, textSpanLength: number, parameterType: string) {
-    goTo.marker(marker);
-    verify.verifyQuickInfoDisplayParts("constructor", "", { start: test.markerByName(marker).position, length: textSpanLength },
-        [{ text: "constructor", kind: "keyword" },
-            { text: " ", kind: "space" }, { text: "cWithOverloads", kind: "className" }, { text: "(", kind: "punctuation" },
-            { text: "x", kind: "parameterName" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: parameterType, kind: "keyword" },
-            { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: "cWithOverloads", kind: "className" },
-            { text: " ", kind: "space" }, { text: "(", kind: "punctuation" },
-            { text: "+", kind: "operator" }, { text: "1", kind: "numericLiteral" },
-            { text: " ", kind: "space" }, { text: "overload", kind: "text" },
-            { text: ")", kind: "punctuation" }],
-        []);
-}
-
-function verifyMultipleOverloadSignature(marker: string, textSpanLength: number, parameterType: string) {
-    goTo.marker(marker);
-    verify.verifyQuickInfoDisplayParts("constructor", "", { start: test.markerByName(marker).position, length: textSpanLength },
-        [{ text: "constructor", kind: "keyword" },
-            { text: " ", kind: "space" }, { text: "cWithMultipleOverloads", kind: "className" }, { text: "(", kind: "punctuation" },
-            { text: "x", kind: "parameterName" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: parameterType, kind: "keyword" },
-            { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: "cWithMultipleOverloads", kind: "className" },
-            { text: " ", kind: "space" }, { text: "(", kind: "punctuation" },
-            { text: "+", kind: "operator" }, { text: "2", kind: "numericLiteral" },
-            { text: " ", kind: "space" }, { text: "overloads", kind: "text" },
-            { text: ")", kind: "punctuation" }],
-        []);
-}
-
-
-verifyNonOverloadSignature("1", "constructor".length);
-verifyClassInstance("2", "cInstance", "c");
-verifyNonOverloadSignature("3", "c".length);
-verifyTypeOfClass("4", "cVal", "c");
-verifyClass("5", "c");
-
-verifySingleOverloadSignature("6", "constructor".length, "string");
-verifySingleOverloadSignature("7", "constructor".length, "number");
-verifySingleOverloadSignature("8", "constructor".length, "string");
-verifyClassInstance("9", "cWithOverloadsInstance", "cWithOverloads");
-verifySingleOverloadSignature("10", "cWithOverloads".length, "string");
-verifyClassInstance("11", "cWithOverloadsInstance2", "cWithOverloads");
-verifySingleOverloadSignature("12", "cWithOverloads".length, "number");
-verifyTypeOfClass("13", "cWithOverloadsVal", "cWithOverloads");
-verifyClass("14", "cWithOverloads");
-
-verifyMultipleOverloadSignature("15", "constructor".length, "string");
-verifyMultipleOverloadSignature("16", "constructor".length, "number");
-verifyMultipleOverloadSignature("17", "constructor".length, "boolean");
-verifyMultipleOverloadSignature("18", "constructor".length, "string");
-verifyClassInstance("19", "cWithMultipleOverloadsInstance", "cWithMultipleOverloads");
-verifyMultipleOverloadSignature("20", "cWithMultipleOverloads".length, "string");
-verifyClassInstance("21", "cWithMultipleOverloadsInstance2", "cWithMultipleOverloads");
-verifyMultipleOverloadSignature("22", "cWithMultipleOverloads".length, "number");
-verifyClassInstance("23", "cWithMultipleOverloadsInstance3", "cWithMultipleOverloads");
-verifyMultipleOverloadSignature("24", "cWithMultipleOverloads".length, "boolean");
-verifyTypeOfClass("25", "cWithMultipleOverloadsVal", "cWithMultipleOverloads");
-verifyClass("26", "cWithMultipleOverloads");
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsClassMethod.ts

@@ -20,67 +20,4 @@
 /////*9*/cInstance./*10*/publicMethod();
 /////*11*/c./*12*/staticMethod();
 
-function verifyClassMethod(markerName: string, kindModifiers: string, methodName: string) {
-    goTo.marker(markerName);
-    verify.verifyQuickInfoDisplayParts("method", kindModifiers, { start: test.markerByName(markerName).position, length: methodName.length },
-        [{ text: "(", kind: "punctuation" }, { text: "method", kind: "text" }, { text: ")", kind: "punctuation" },
-            { text: " ", kind: "space" },
-            { text: "c", kind: "className" }, { text: ".", kind: "punctuation" }, { text: methodName, kind: "methodName" },
-            { text: "(", kind: "punctuation" }, { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: "void", kind: "keyword" }],
-        []);
-}
-
-function verifyPublicMethod(markerName: string) {
-    verifyClassMethod(markerName, "public", "publicMethod");
-}
-
-function verifyPrivateMethod(markerName: string) {
-    verifyClassMethod(markerName, "private", "privateMethod");
-}
-
-function verifyProtectedMethod(markerName: string) {
-    verifyClassMethod(markerName, "protected", "protectedMethod");
-}
-
-function verifyStaticMethod(markerName: string) {
-    verifyClassMethod(markerName, "static", "staticMethod");
-}
-
-function verifyPrivateStaticMethod(markerName: string) {
-    verifyClassMethod(markerName, "private,static", "privateStaticMethod");
-}
-
-function verifyProtectedStaticMethod(markerName: string) {
-    verifyClassMethod(markerName, "protected,static", "protectedStaticMethod");
-}
-
-verifyPublicMethod('1');
-verifyPrivateMethod('2');
-verifyProtectedMethod('21');
-verifyStaticMethod('3');
-verifyPrivateStaticMethod('4');
-verifyProtectedStaticMethod('41');
-
-verifyPublicMethod('5');
-verifyPrivateMethod('6');
-verifyProtectedMethod('61');
-verifyStaticMethod('7');
-verifyPrivateStaticMethod('8');
-verifyProtectedStaticMethod('81');
-
-goTo.marker('9');
-verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName("9").position, length: "cInstance".length },
-    [{ text: "var", kind: "keyword" },
-        { text: " ", kind: "space" }, { text: "cInstance", kind: "localName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
-
-verifyPublicMethod('10');
-
-goTo.marker('11');
-verify.verifyQuickInfoDisplayParts("class", "", { start: test.markerByName("11").position, length: "c".length },
-    [{ text: "class", kind: "keyword" }, { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
-
-verifyStaticMethod('12');
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsClassProperty.ts

@@ -20,66 +20,4 @@
 /////*9*/cInstance./*10*/publicProperty;
 /////*11*/c./*12*/staticProperty;
 
-function verifyClassProperty(markerName: string, kindModifiers: string, propertyName: string) {
-    goTo.marker(markerName);
-    verify.verifyQuickInfoDisplayParts("property", kindModifiers, { start: test.markerByName(markerName).position, length: propertyName.length },
-        [{ text: "(", kind: "punctuation" }, { text: "property", kind: "text" }, { text: ")", kind: "punctuation" },
-            { text: " ", kind: "space" },
-            { text: "c", kind: "className" }, { text: ".", kind: "punctuation" }, { text: propertyName, kind: "propertyName" },
-            { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "string", kind: "keyword" }],
-        []);
-}
-
-function verifyPublicProperty(markerName: string) {
-    verifyClassProperty(markerName, "public", "publicProperty");
-}
-
-function verifyPrivateProperty(markerName: string) {
-    verifyClassProperty(markerName, "private", "privateProperty");
-}
-
-function verifyProtectedProperty(markerName: string) {
-    verifyClassProperty(markerName, "protected", "protectedProperty");
-}
-
-function verifyStaticProperty(markerName: string) {
-    verifyClassProperty(markerName, "static", "staticProperty");
-}
-
-function verifyPrivateStaticProperty(markerName: string) {
-    verifyClassProperty(markerName, "private,static", "privateStaticProperty");
-}
-
-function verifyProtectedStaticProperty(markerName: string) {
-    verifyClassProperty(markerName, "protected,static", "protectedStaticProperty");
-}
-
-verifyPublicProperty('1');
-verifyPrivateProperty('2');
-verifyProtectedProperty('21');
-verifyStaticProperty('3');
-verifyPrivateStaticProperty('4');
-verifyProtectedStaticProperty('41');
-
-verifyPublicProperty('5');
-verifyPrivateProperty('6');
-verifyProtectedProperty('61');
-verifyStaticProperty('7');
-verifyPrivateStaticProperty('8');
-verifyProtectedStaticProperty('81');
-
-goTo.marker('9');
-verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName("9").position, length: "cInstance".length },
-    [{ text: "var", kind: "keyword" },
-        { text: " ", kind: "space" }, { text: "cInstance", kind: "localName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
-
-verifyPublicProperty('10');
-
-goTo.marker('11');
-verify.verifyQuickInfoDisplayParts("class", "", { start: test.markerByName("11").position, length: "c".length },
-    [{ text: "class", kind: "keyword" }, { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
-
-verifyStaticProperty('12');
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsConst.ts

@@ -22,62 +22,4 @@
 /////*15*/h(10);
 /////*16*/h("hello");
 
-var marker = 0;
-function verifyConst(name: string, typeDisplay: ts.SymbolDisplayPart[], optionalNameDisplay?: ts.SymbolDisplayPart[], optionalKindModifiers?: string) {
-    marker++;
-    goTo.marker(marker.toString());
-    verify.verifyQuickInfoDisplayParts("const", optionalKindModifiers || "", { start: test.markerByName(marker.toString()).position, length: name.length },
-        [{ text: "const", kind: "keyword" },
-            { text: " ", kind: "space" }].concat(optionalNameDisplay || [{ text: name, kind: "localName" }]).concat(
-            { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }).concat(typeDisplay),
-        []);
-}
-
-var numberTypeDisplay: ts.SymbolDisplayPart[] = [{ text: "number", kind: "keyword" }];
-
-verifyConst("a", numberTypeDisplay);
-verifyConst("b", numberTypeDisplay);
-verifyConst("a", numberTypeDisplay);
-verifyConst("b1", numberTypeDisplay);
-verifyConst("c", numberTypeDisplay);
-verifyConst("d", numberTypeDisplay, [{ text: "m", kind: "moduleName" }, { text: ".", kind: "punctuation" }, { text: "d", kind: "localName" }], "export");
-verifyConst("e", numberTypeDisplay);
-
-var functionTypeReturningNumber: ts.SymbolDisplayPart[] = [{ text: "(", kind: "punctuation" }, { text: ")", kind: "punctuation" },
-    { text: " ", kind: "space" }, { text: "=>", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "number", kind: "keyword" }];
-verifyConst("f", functionTypeReturningNumber);
-verifyConst("g", functionTypeReturningNumber);
-verifyConst("f", functionTypeReturningNumber);
-verifyConst("f", functionTypeReturningNumber);
-
-
-function getFunctionType(parametertype: string, returnType: string, isArrow?: boolean): ts.SymbolDisplayPart[] {
-    var functionTypeDisplay = [{ text: "(", kind: "punctuation" }, { text: "a", kind: "parameterName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: parametertype, kind: "keyword" }, { text: ")", kind: "punctuation" }];
-
-    if (isArrow) {
-        functionTypeDisplay = functionTypeDisplay.concat({ text: " ", kind: "space" }, { text: "=>", kind: "punctuation" });
-    }
-    else {
-        functionTypeDisplay = functionTypeDisplay.concat({ text: ":", kind: "punctuation" });
-    }
-
-    return functionTypeDisplay.concat({ text: " ", kind: "space" }, { text: returnType, kind: "keyword" });
-}
-
-var typeLiteralWithOverloadCall: ts.SymbolDisplayPart[] = [{ text: "{", kind: "punctuation" }, { text: "\n", kind: "lineBreak" },
-    { text: "    ", kind: "space" }].concat(getFunctionType("string", "number")).concat(
-    { text: ";", kind: "punctuation" }, { text: "\n", kind: "lineBreak" },
-    { text: "    ", kind: "space" }).concat(getFunctionType("number", "string")).concat(
-    { text: ";", kind: "punctuation" }, { text: "\n", kind: "lineBreak" }, { text: "}", kind: "punctuation" });
-
-verifyConst("h", typeLiteralWithOverloadCall);
-verifyConst("i", typeLiteralWithOverloadCall);
-verifyConst("h", typeLiteralWithOverloadCall);
-
-var overloadDisplay: ts.SymbolDisplayPart[] = [{ text: " ", kind: "space" }, { text: "(", kind: "punctuation" },
-    { text: "+", kind: "operator" }, { text: "1", kind: "numericLiteral" },
-    { text: " ", kind: "space" }, { text: "overload", kind: "text" }, { text: ")", kind: "punctuation" }];
-
-verifyConst("h", getFunctionType("number", "string", /*isArrow*/true).concat(overloadDisplay));
-verifyConst("h", getFunctionType("string", "number", /*isArrow*/true).concat(overloadDisplay));
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsEnum1.ts

@@ -19,58 +19,4 @@
 /////*25*/eInstance1 = /*26*/constE./*27*/e2;
 /////*28*/eInstance1 = /*29*/constE./*30*/e3;
 
-var marker = 0;
-function verifyEnumDeclaration(enumName: string, instanceName: string, isConst?: boolean) {
-    verifyEnumDisplay();
-
-    verifyEnumMemberDisplay("e1", 0);
-    verifyEnumMemberDisplay("e2", 10);
-    verifyEnumMemberDisplay("e3", 11);
-
-    verifyInstance();
-    verifyEnumDisplay();
-
-    verifyInstance();
-    verifyEnumDisplay();
-    verifyEnumMemberDisplay("e1", 0);
-
-    verifyInstance();
-    verifyEnumDisplay();
-    verifyEnumMemberDisplay("e2", 10);
-
-    verifyInstance();
-    verifyEnumDisplay();
-    verifyEnumMemberDisplay("e3", 11);
-
-    function verifyEnumDisplay() {
-        marker++;
-        goTo.marker(marker.toString());
-        verify.verifyQuickInfoDisplayParts("enum", "", { start: test.markerByName(marker.toString()).position, length: enumName.length },
-            (isConst ? [{ text: "const", kind: "keyword" }, { text: " ", kind: "space" }] : []).concat(
-                [{ text: "enum", kind: "keyword" }, { text: " ", kind: "space" }, { text: enumName, kind: "enumName" }]),
-            []);;
-    }
-
-    function verifyEnumMemberDisplay(enumMemberName: string, initializer: number) {
-        marker++;
-        goTo.marker(marker.toString());
-        verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName(marker.toString()).position, length: enumMemberName.length },
-            [{ text: "(", kind: "punctuation" }, { text: "enum member", kind: "text" }, { text: ")", kind: "punctuation" },
-                { text: " ", kind: "space" }, { text: enumName, kind: "enumName" }, { text: ".", kind: "punctuation" }, { text: enumMemberName, kind: "enumMemberName" }, 
-                { text: " ", kind: "space" }, { text: "=", kind: "operator" }, { text: " ", kind: "space" },  { text: initializer.toString(), kind: "numericLiteral" }],
-            []);
-    }
-
-    function verifyInstance() {
-        marker++;
-        goTo.marker(marker.toString());
-        verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName(marker.toString()).position, length: instanceName.length },
-            [{ text: "var", kind: "keyword" },
-                { text: " ", kind: "space" }, { text: instanceName, kind: "localName" }, { text: ":", kind: "punctuation" },
-                { text: " ", kind: "space" }, { text: enumName, kind: "enumName" }],
-            []);
-    }
-}
-
-verifyEnumDeclaration("E", "eInstance");
-verifyEnumDeclaration("constE", "eInstance1", /*isConst*/ true);
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsEnum2.ts

@@ -19,61 +19,4 @@
 /////*25*/eInstance1 = /*26*/constE./*27*/e2;
 /////*28*/eInstance1 = /*29*/constE./*30*/e3;
 
-var marker = 0;
-function verifyEnumDeclaration(enumName: string, instanceName: string, isConst?: boolean) {
-    verifyEnumDisplay();
-
-    verifyEnumMemberDisplay('"e1"', /*spanLength*/ 4, 0);
-    verifyEnumMemberDisplay("'e2'", /*spanLength*/ 4, 10);
-    verifyEnumMemberDisplay('"e3"', /*spanLength*/ 4, 11);
-
-    verifyInstance();
-    verifyEnumDisplay();
-
-    verifyInstance();
-    verifyEnumDisplay();
-    verifyEnumMemberDisplay('"e1"', /*spanLength*/ 2, 0);
-
-    verifyInstance();
-    verifyEnumDisplay();
-    verifyEnumMemberDisplay("'e2'", /*spanLength*/ 2, 10);
-
-    verifyInstance();
-    verifyEnumDisplay();
-    verifyEnumMemberDisplay('"e3"', /*spanLength*/ 2, 11);
-
-    function verifyEnumDisplay() {
-        marker++;
-        goTo.marker(marker.toString());
-        verify.verifyQuickInfoDisplayParts("enum", "", { start: test.markerByName(marker.toString()).position, length: enumName.length },
-            (isConst ? [{ text: "const", kind: "keyword" }, { text: " ", kind: "space" }] : []).concat(
-                [{ text: "enum", kind: "keyword" }, { text: " ", kind: "space" }, { text: enumName, kind: "enumName" }]),
-            []);;
-    }
-
-    function verifyEnumMemberDisplay(enumMemberName: string, spanLength: number, initializer: number) {
-        marker++;
-        goTo.marker(marker.toString());
-        // Each of these names is a string literal,
-        // but since they're accessed by property accesses,
-        // we need to account for the quotes at the beginning and end.
-        verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName(marker.toString()).position, length: spanLength },
-            [{ text: "(", kind: "punctuation" }, { text: "enum member", kind: "text" }, { text: ")", kind: "punctuation" },
-                { text: " ", kind: "space" }, { text: enumName, kind: "enumName" }, { text: "[", kind: "punctuation" }, { text: enumMemberName, kind: "stringLiteral" }, { text: "]", kind: "punctuation" },
-                { text: " ", kind: "space" }, { text: "=", kind: "operator" }, { text: " ", kind: "space" },  { text: initializer.toString(), kind: "numericLiteral" }],
-            []);
-    }
-
-    function verifyInstance() {
-        marker++;
-        goTo.marker(marker.toString());
-        verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName(marker.toString()).position, length: instanceName.length },
-            [{ text: "var", kind: "keyword" },
-                { text: " ", kind: "space" }, { text: instanceName, kind: "localName" }, { text: ":", kind: "punctuation" },
-                { text: " ", kind: "space" }, { text: enumName, kind: "enumName" }],
-            []);
-    }
-}
-
-verifyEnumDeclaration("E", "eInstance");
-verifyEnumDeclaration("constE", "eInstance1", /*isConst*/ true);
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsEnum3.ts

@@ -19,62 +19,4 @@
 /////*25*/eInstance1 = /*26*/constE[/*27*/"e2"];
 /////*28*/eInstance1 = /*29*/constE[/*30*/'e3'];
 
-var marker = 0;
-function verifyEnumDeclaration(enumName: string, instanceName: string, isConst?: boolean) {
-    verifyEnumDisplay();
-
-    verifyEnumMemberDisplay('"e1"', /*spanLength*/ 4, 0);
-    verifyEnumMemberDisplay("'e2'", /*spanLength*/ 4, 10);
-    verifyEnumMemberDisplay('"e3"', /*spanLength*/ 4, 11);
-
-    verifyInstance();
-    verifyEnumDisplay();
-
-    verifyInstance();
-    verifyEnumDisplay();
-    verifyEnumMemberDisplay('"e1"', /*spanLength*/ 4, 0);
-
-    verifyInstance();
-    verifyEnumDisplay();
-    verifyEnumMemberDisplay("'e2'", /*spanLength*/ 4, 10);
-
-    verifyInstance();
-    verifyEnumDisplay();
-    verifyEnumMemberDisplay('"e3"', /*spanLength*/ 4, 11);
-
-    function verifyEnumDisplay() {
-        marker++;
-        goTo.marker(marker.toString());
-        verify.verifyQuickInfoDisplayParts("enum", "", { start: test.markerByName(marker.toString()).position, length: enumName.length },
-            (isConst ? [{ text: "const", kind: "keyword" }, { text: " ", kind: "space" }] : []).concat(
-                [{ text: "enum", kind: "keyword" }, { text: " ", kind: "space" }, { text: enumName, kind: "enumName" }]),
-            []);;
-    }
-
-    function verifyEnumMemberDisplay(enumMemberName: string, spanLength: number, initializer: number) {
-        marker++;
-        goTo.marker(marker.toString());
-        // Each of these names is a string literal,
-        // but since they're accessed by property accesses,
-        // we need to account for the quotes at the beginning and end.
-        verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName(marker.toString()).position, length: spanLength },
-            [{ text: "(", kind: "punctuation" }, { text: "enum member", kind: "text" }, { text: ")", kind: "punctuation" },
-                { text: " ", kind: "space" }, { text: enumName, kind: "enumName" }, { text: "[", kind: "punctuation" }, { text: enumMemberName, kind: "stringLiteral" }, { text: "]", kind: "punctuation" },
-                { text: " ", kind: "space" }, { text: "=", kind: "operator" }, { text: " ", kind: "space" }, { text: initializer.toString(), kind: "numericLiteral" }],
-            []);
-    }
-
-    function verifyInstance() {
-        marker++;
-        goTo.marker(marker.toString());
-        verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName(marker.toString()).position, length: instanceName.length },
-            [{ text: "var", kind: "keyword" },
-                { text: " ", kind: "space" }, { text: instanceName, kind: "localName" }, { text: ":", kind: "punctuation" },
-                { text: " ", kind: "space" }, { text: enumName, kind: "enumName" }],
-            []);
-    }
-}
-
-verifyEnumDeclaration("E", "eInstance");
-marker = 15;
-//verifyEnumDeclaration("constE", "eInstance1", /*isConst*/ true);
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsExternalModuleAlias.ts

@@ -12,33 +12,4 @@
 ////export import /*3*/a2 = require(/*mod2*/"./quickInfoDisplayPartsExternalModuleAlias_file0");
 ////new /*4*/a2.m1.c();
 
-var marker = 0;
-function goToMarker() {
-    marker++;
-    goTo.marker(marker.toString());
-}
-
-function verifyImport(name: string, isExported: boolean) {
-    goToMarker();
-    verify.verifyQuickInfoDisplayParts("alias", isExported ? "export" : "", { start: test.markerByName(marker.toString()).position, length: name.length },
-        [{ text: "import", kind: "keyword" }, { text: " ", kind: "space" }, { text: name, kind: "aliasName" },
-            { text: " ", kind: "space" }, { text: "=", kind: "operator" }, { text: " ", kind: "space" },
-            { text: "require", kind: "keyword" }, { text: "(", kind: "punctuation" },
-            { text: "\"./quickInfoDisplayPartsExternalModuleAlias_file0\"", kind: "stringLiteral" },
-            { text: ")", kind: "punctuation" }],
-        []);
-}
-verifyImport("a1", /*isExported*/false);
-verifyImport("a1", /*isExported*/false);
-verifyImport("a2", /*isExported*/true);
-verifyImport("a2", /*isExported*/true);
-
-function verifyExternalModuleStringLiteral(marker: string) {
-    goTo.marker(marker);
-    verify.verifyQuickInfoDisplayParts("module", "", { start: test.markerByName(marker).position, length: "\"./quickInfoDisplayPartsExternalModuleAlias_file0\"".length },
-        [{ text: "module", kind: "keyword" }, { text: " ", kind: "space" }, { text: "a1", kind: "aliasName" }],
-        []);
-}
-
-verifyExternalModuleStringLiteral("mod1");
-verifyExternalModuleStringLiteral("mod2");
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsExternalModules.ts

@@ -13,51 +13,4 @@
 ////export var /*12*/x = /*13*/m1./*14*/m2;
 ////export var /*15*/y: typeof /*16*/m1./*17*/m2;
 
-var marker = 0;
-function goToMarker() {
-    marker++;
-    goTo.marker(marker.toString());
-}
-
-function verifyNamespace(name: string, optionalParentName?: string) {
-    goToMarker();
-    var namespaceNameDisplay = [{ text: name, kind: "moduleName" }];
-    if (optionalParentName) {
-        namespaceNameDisplay = [{ text: optionalParentName, kind: "moduleName" }, { text: ".", kind: "punctuation" }].concat(namespaceNameDisplay);
-    }
-    verify.verifyQuickInfoDisplayParts("module", "export", { start: test.markerByName(marker.toString()).position, length: name.length },
-        [{ text: "namespace", kind: "keyword" }, { text: " ", kind: "space" }].concat(namespaceNameDisplay),
-        []);
-}
-
-function verifyVar(name: string, optionalFullName?: ts.SymbolDisplayPart[], typeDisplay: ts.SymbolDisplayPart[]= [{ text: "number", kind: "keyword" }]) {
-    goToMarker();
-    verify.verifyQuickInfoDisplayParts("var", name === "namespaceElemWithoutExport" ? "" : "export", { start: test.markerByName(marker.toString()).position, length: name.length },
-        [{ text: "var", kind: "keyword" },
-            { text: " ", kind: "space" }].concat(optionalFullName || [{ text: name, kind: "localName" }]).concat(
-            { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }).concat(typeDisplay),
-        []);
-}
-
-verifyNamespace("m");
-verifyVar("namespaceElemWithoutExport");
-verifyVar("namespaceElemWithExport", [{ text: "m", kind: "moduleName" }, { text: ".", kind: "punctuation" }, { text: "namespaceElemWithExport", kind: "localName" }]);
-
-verifyVar("a", /*optionalFullName*/ undefined, [{ text: "typeof", kind: "keyword" }, { text: " ", kind: "space" }, { text: "m", kind: "moduleName" }]);
-verifyNamespace("m");
-verifyVar("b", /*optionalFullName*/ undefined, [{ text: "typeof", kind: "keyword" }, { text: " ", kind: "space" }, { text: "m", kind: "moduleName" }]);
-verifyNamespace("m");
-
-verifyNamespace("m1");
-verifyNamespace("m2", "m1");
-verifyVar("namespaceElemWithoutExport");
-verifyVar("namespaceElemWithExport", [{ text: "m1", kind: "moduleName" }, { text: ".", kind: "punctuation" },
-    { text: "m2", kind: "moduleName" }, { text: ".", kind: "punctuation" }, { text: "namespaceElemWithExport", kind: "localName" }]);
-verifyVar("x", /*optionalFullName*/ undefined, [{ text: "typeof", kind: "keyword" }, { text: " ", kind: "space" },
-    { text: "m1", kind: "moduleName" }, { text: ".", kind: "punctuation" }, { text: "m2", kind: "moduleName" }]);
-verifyNamespace("m1");
-verifyNamespace("m2", "m1");
-verifyVar("y", /*optionalFullName*/ undefined, [{ text: "typeof", kind: "keyword" }, { text: " ", kind: "space" },
-    { text: "m1", kind: "moduleName" }, { text: ".", kind: "punctuation" }, { text: "m2", kind: "moduleName" }]);
-verifyNamespace("m1");
-verifyNamespace("m2", "m1");
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsFunction.ts

@@ -20,57 +20,4 @@
 /////*13*/foowith3overload(10);
 /////*14*/foowith3overload(true);
 
-var marker = 0;
-function verifyFunctionWithoutOverload() {
-    marker++;
-    goTo.marker(marker.toString());
-    verify.verifyQuickInfoDisplayParts("function", "", { start: test.markerByName(marker.toString()).position, length: "foo".length },
-        [{ text: "function", kind: "keyword" },
-            { text: " ", kind: "space" }, { text: "foo", kind: "functionName" }, { text: "(", kind: "punctuation" },
-            { text: "param", kind: "parameterName" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "string", kind: "keyword" },
-            { text: ",", kind: "punctuation" }, { text: " ", kind: "space" },
-            { text: "optionalParam", kind: "parameterName" }, { text: "?", kind: "punctuation" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "string", kind: "keyword" },
-            { text: ",", kind: "punctuation" }, { text: " ", kind: "space" },
-            { text: "paramWithInitializer", kind: "parameterName" }, { text: "?", kind: "punctuation" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "string", kind: "keyword" },
-            { text: ",", kind: "punctuation" }, { text: " ", kind: "space" },
-            { text: "...", kind: "punctuation" }, { text: "restParam", kind: "parameterName" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: "string", kind: "keyword" }, { text: "[", kind: "punctuation" }, { text: "]", kind: "punctuation" },
-            { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "void", kind: "keyword" }],
-        []);
-}
-
-function verifyFunctionWithOverload(functionName: string, type: string, overloadCount: number) {
-    marker++;
-    goTo.marker(marker.toString());
-    verify.verifyQuickInfoDisplayParts("function", "", { start: test.markerByName(marker.toString()).position, length: functionName.length },
-        [{ text: "function", kind: "keyword" },
-            { text: " ", kind: "space" }, { text: functionName, kind: "functionName" }, { text: "(", kind: "punctuation" },
-            { text: "a", kind: "parameterName" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: type, kind: "keyword" },
-            { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: type, kind: "keyword" },
-            { text: " ", kind: "space" }, { text: "(", kind: "punctuation" }, { text: "+", kind: "operator" }, { text: overloadCount.toString(), kind: "numericLiteral" },
-            { text: " ", kind: "space" }, { text: overloadCount === 1 ? "overload" : "overloads", kind: "text" }, { text: ")", kind: "punctuation" }],
-        []);
-}
-
-
-// Declarations
-verifyFunctionWithoutOverload();
-
-verifyFunctionWithOverload("foowithoverload", "string", 1);
-verifyFunctionWithOverload("foowithoverload", "number", 1);
-verifyFunctionWithOverload("foowithoverload", "string", 1);
-
-verifyFunctionWithOverload("foowith3overload", "string", 2);
-verifyFunctionWithOverload("foowith3overload", "number", 2);
-verifyFunctionWithOverload("foowith3overload", "boolean", 2);
-verifyFunctionWithOverload("foowith3overload", "string", 2);
-
-// Calls
-verifyFunctionWithoutOverload();
-
-verifyFunctionWithOverload("foowithoverload", "string", 1);
-verifyFunctionWithOverload("foowithoverload", "number", 1);
-
-verifyFunctionWithOverload("foowith3overload", "string", 2);
-verifyFunctionWithOverload("foowith3overload", "number", 2);
-verifyFunctionWithOverload("foowith3overload", "boolean", 2);
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsFunctionExpression.ts

@@ -9,37 +9,4 @@
 ////    /*6*/foo1();
 ////})();
 
-var marker = 0;
-function verifyInstance(instanceName: string) {
-    marker++;
-    goTo.marker(marker.toString());
-    verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName(marker.toString()).position, length: instanceName.length },
-        [{ text: "var", kind: "keyword" },
-            { text: " ", kind: "space" }, { text: instanceName, kind: "localName" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: "(", kind: "punctuation" }, { text: ")", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: "=>", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "void", kind: "keyword" }],
-        []);
-}
-
-function verifyNamedFunctionExpression(functionName: string) {
-    marker++;
-    goTo.marker(marker.toString());
-    verify.verifyQuickInfoDisplayParts("local function", "", { start: test.markerByName(marker.toString()).position, length: functionName.length },
-        [{ text: "(", kind: "punctuation" }, { text: "local function", kind: "text" }, { text: ")", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: functionName, kind: "functionName" }, { text: "(", kind: "punctuation" },
-            { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "void", kind: "keyword" }],
-        []);
-}
-
-verifyInstance("x");
-// Declaration
-verifyNamedFunctionExpression("foo");
-// Call
-verifyNamedFunctionExpression("foo");
-
-verifyInstance("y");
-
-// Declaration
-verifyNamedFunctionExpression("foo1");
-// Call
-verifyNamedFunctionExpression("foo1");
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsInterface.ts

@@ -4,19 +4,4 @@
 ////}
 ////var /*2*/iInstance: /*3*/i;
 
-goTo.marker('1');
-verify.verifyQuickInfoDisplayParts("interface", "", { start: test.markerByName("1").position, length: "i".length },
-    [{ text: "interface", kind: "keyword" }, { text: " ", kind: "space" }, { text: "i", kind: "interfaceName" }],
-    []);
-
-goTo.marker('2');
-verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName("2").position, length: "iInstance".length },
-    [{ text: "var", kind: "keyword" },
-        { text: " ", kind: "space" }, { text: "iInstance", kind: "localName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "i", kind: "interfaceName" }],
-    []);
-
-goTo.marker('3');
-verify.verifyQuickInfoDisplayParts("interface", "", { start: test.markerByName("3").position, length: "i".length },
-    [{ text: "interface", kind: "keyword" }, { text: " ", kind: "space" }, { text: "i", kind: "interfaceName" }],
-    []);
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsInterfaceMembers.ts

@@ -11,65 +11,4 @@
 /////*7*/iInstance();
 ////var /*8*/anotherInstance = new /*9*/iInstance();
 
-function verifyInterfaceProperty(markerName: string) {
-    goTo.marker(markerName);
-    verify.verifyQuickInfoDisplayParts("property", "", { start: test.markerByName(markerName).position, length: "property".length },
-        [{ text: "(", kind: "punctuation" }, { text: "property", kind: "text" }, { text: ")", kind: "punctuation" },
-            { text: " ", kind: "space" },
-            { text: "I", kind: "interfaceName" }, { text: ".", kind: "punctuation" }, { text: "property", kind: "propertyName" },
-            { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "string", kind: "keyword" }],
-        []);
-}
-
-function verifyInterfaceMethod(markerName: string) {
-    goTo.marker(markerName);
-    verify.verifyQuickInfoDisplayParts("method", "", { start: test.markerByName(markerName).position, length: "method".length },
-        [{ text: "(", kind: "punctuation" }, { text: "method", kind: "text" }, { text: ")", kind: "punctuation" },
-            { text: " ", kind: "space" },
-            { text: "I", kind: "interfaceName" }, { text: ".", kind: "punctuation" }, { text: "method", kind: "methodName" },
-            { text: "(", kind: "punctuation" }, { text: ")", kind: "punctuation" },
-            { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "string", kind: "keyword" }],
-        []);
-}
-
-function verifyInterfaceInstanceVar(markerName: string, instanceName: string) {
-    goTo.marker(markerName);
-    verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName(markerName).position, length: instanceName.length },
-        [{ text: "var", kind: "keyword" },
-            { text: " ", kind: "space" }, { text: instanceName, kind: "localName" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: "I", kind: "interfaceName" }],
-        []);
-}
-
-verifyInterfaceProperty('1');
-verifyInterfaceMethod("2");
-
-verifyInterfaceInstanceVar("3", "iInstance");
-verifyInterfaceProperty("4");
-verifyInterfaceInstanceVar("5", "iInstance");
-verifyInterfaceMethod("6");
- 
-// Call signature
-goTo.marker("7");
-verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName("7").position, length: "iInstance".length },
-    [{ text: "var", kind: "keyword" },
-        { text: " ", kind: "space" }, { text: "iInstance", kind: "localName" },
-        { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "I", kind: "interfaceName" },
-        { text: "(", kind: "punctuation" }, { text: ")", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "=>", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "string", kind: "keyword" }],
-    []);
-
-verifyInterfaceInstanceVar("8", "anotherInstance");
-
-// Cosntruct signature
-goTo.marker("9");
-verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName("9").position, length: "iInstance".length },
-    [{ text: "var", kind: "keyword" },
-        { text: " ", kind: "space" }, { text: "iInstance", kind: "localName" },
-        { text: ":", kind: "punctuation" }, { text: " ", kind: "space" },
-        { text: "new", kind: "keyword" }, { text: " ", kind: "space" }, { text: "I", kind: "interfaceName" },
-        { text: "(", kind: "punctuation" }, { text: ")", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "=>", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "I", kind: "interfaceName" }],
-    []);
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsLet.ts

@@ -22,62 +22,4 @@
 /////*15*/h(10);
 /////*16*/h("hello");
 
-var marker = 0;
-function verifyVar(name: string, typeDisplay: ts.SymbolDisplayPart[], optionalNameDisplay?: ts.SymbolDisplayPart[], optionalKindModifiers?: string) {
-    marker++;
-    goTo.marker(marker.toString());
-    verify.verifyQuickInfoDisplayParts("let", optionalKindModifiers || "", { start: test.markerByName(marker.toString()).position, length: name.length },
-        [{ text: "let", kind: "keyword" },
-            { text: " ", kind: "space" }].concat(optionalNameDisplay || [{ text: name, kind: "localName" }]).concat(
-            { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }).concat(typeDisplay),
-        []);
-}
-
-var numberTypeDisplay: ts.SymbolDisplayPart[] = [{ text: "number", kind: "keyword" }];
-
-verifyVar("a", numberTypeDisplay);
-verifyVar("b", numberTypeDisplay);
-verifyVar("a", numberTypeDisplay);
-verifyVar("b1", numberTypeDisplay);
-verifyVar("c", numberTypeDisplay);
-verifyVar("d", numberTypeDisplay, [{ text: "m", kind: "moduleName" }, { text: ".", kind: "punctuation" }, { text: "d", kind: "localName" }], "export");
-verifyVar("e", numberTypeDisplay);
-
-var functionTypeReturningNumber: ts.SymbolDisplayPart[] = [{ text: "(", kind: "punctuation" }, { text: ")", kind: "punctuation" },
-    { text: " ", kind: "space" }, { text: "=>", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "number", kind: "keyword" }];
-verifyVar("f", functionTypeReturningNumber);
-verifyVar("g", functionTypeReturningNumber);
-verifyVar("f", functionTypeReturningNumber);
-verifyVar("f", functionTypeReturningNumber);
-
-
-function getFunctionType(parametertype: string, returnType: string, isArrow?: boolean): ts.SymbolDisplayPart[] {
-    var functionTypeDisplay = [{ text: "(", kind: "punctuation" }, { text: "a", kind: "parameterName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: parametertype, kind: "keyword" }, { text: ")", kind: "punctuation" }];
-
-    if (isArrow) {
-        functionTypeDisplay = functionTypeDisplay.concat({ text: " ", kind: "space" }, { text: "=>", kind: "punctuation" });
-    }
-    else {
-        functionTypeDisplay = functionTypeDisplay.concat({ text: ":", kind: "punctuation" });
-    }
-
-    return functionTypeDisplay.concat({ text: " ", kind: "space" }, { text: returnType, kind: "keyword" });
-}
-
-var typeLiteralWithOverloadCall: ts.SymbolDisplayPart[] = [{ text: "{", kind: "punctuation" }, { text: "\n", kind: "lineBreak" },
-    { text: "    ", kind: "space" }].concat(getFunctionType("string", "number")).concat(
-    { text: ";", kind: "punctuation" }, { text: "\n", kind: "lineBreak" },
-    { text: "    ", kind: "space" }).concat(getFunctionType("number", "string")).concat(
-    { text: ";", kind: "punctuation" }, { text: "\n", kind: "lineBreak" }, { text: "}", kind: "punctuation" });
-
-verifyVar("h", typeLiteralWithOverloadCall);
-verifyVar("i", typeLiteralWithOverloadCall);
-verifyVar("h", typeLiteralWithOverloadCall);
-
-var overloadDisplay: ts.SymbolDisplayPart[] = [{ text: " ", kind: "space" }, { text: "(", kind: "punctuation" },
-    { text: "+", kind: "operator" }, { text: "1", kind: "numericLiteral" },
-    { text: " ", kind: "space" }, { text: "overload", kind: "text" }, { text: ")", kind: "punctuation" }];
-
-verifyVar("h", getFunctionType("number", "string", /*isArrow*/true).concat(overloadDisplay));
-verifyVar("h", getFunctionType("string", "number", /*isArrow*/true).concat(overloadDisplay));
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsLiteralLikeNames01.ts

@@ -14,36 +14,4 @@
 ////        C./*10*/stringLiteralName();
 ////    }
 
-verifyClassMethodWithElementAccessDisplay("1", "public", "1", "methodName", /*spanLength*/ "1".length);
-verifyClassMethodWithPropertyAccessDisplay("2", "private", "Infinity", /*spanLength*/ "Infinity".length);
-verifyClassMethodWithPropertyAccessDisplay("3", "protected", "NaN", /*spanLength*/ "NaN".length);
-verifyClassMethodWithElementAccessDisplay("4", "static", '"stringLiteralName"', "stringLiteral", /*spanLength*/ '"stringLiteralName"'.length);
-verifyClassMethodWithElementAccessDisplay("5", "public", "1", "methodName", /*spanLength*/ "1".length);
-verifyClassMethodWithElementAccessDisplay("6", "public", "1", "methodName", /*spanLength*/ "1".length + 2);
-verifyClassMethodWithPropertyAccessDisplay("7", "private", "Infinity", /*spanLength*/ "Infinity".length);
-verifyClassMethodWithPropertyAccessDisplay("8", "private", "Infinity", /*spanLength*/ "Infinity".length + 2);
-verifyClassMethodWithPropertyAccessDisplay("9", "protected", "NaN", /*spanLength*/ "NaN".length);
-verifyClassMethodWithElementAccessDisplay("10", "static", '"stringLiteralName"', "stringLiteral", /*spanLength*/ "stringLiteralName".length);
-
-
-function verifyClassMethodWithPropertyAccessDisplay(markerName: string, kindModifiers: string, methodName: string, spanLength: number) {
-    goTo.marker(markerName);
-    verify.verifyQuickInfoDisplayParts("method", kindModifiers, { start: test.markerByName(markerName).position, length: spanLength },
-        [{ text: "(", kind: "punctuation" }, { text: "method", kind: "text" }, { text: ")", kind: "punctuation" },
-            { text: " ", kind: "space" },
-            { text: "C", kind: "className" }, { text: ".", kind: "punctuation" }, { text: methodName, kind: "methodName" },
-            { text: "(", kind: "punctuation" }, { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: "void", kind: "keyword" }],
-        []);
-}
-
-function verifyClassMethodWithElementAccessDisplay(markerName: string, kindModifiers: string, methodName: string, methodDisplay: "methodName" | "stringLiteral", spanLength: number) {
-    goTo.marker(markerName);
-    verify.verifyQuickInfoDisplayParts("method", kindModifiers, { start: test.markerByName(markerName).position, length: spanLength },
-        [{ text: "(", kind: "punctuation" }, { text: "method", kind: "text" }, { text: ")", kind: "punctuation" },
-            { text: " ", kind: "space" },
-            { text: "C", kind: "className" }, { text: "[", kind: "punctuation" }, { text: methodName, kind: methodDisplay }, { text: "]", kind: "punctuation" },
-            { text: "(", kind: "punctuation" }, { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: "void", kind: "keyword" }],
-        []);
-}
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsLocalFunction.ts

@@ -23,70 +23,4 @@
 ////}
 /////*16*/outerFoo();
 
-var marker = 0;
-function verifyOuterFunction() {
-    marker++;
-    goTo.marker(marker.toString());
-    verify.verifyQuickInfoDisplayParts("function", "", { start: test.markerByName(marker.toString()).position, length: "outerFoo".length },
-        [{ text: "function", kind: "keyword" },
-            { text: " ", kind: "space" }, { text: "outerFoo", kind: "functionName" }, { text: "(", kind: "punctuation" },
-            { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "void", kind: "keyword" }],
-        []);
-}
-
-function verifyFunctionWithoutOverload() {
-    marker++;
-    goTo.marker(marker.toString());
-    verify.verifyQuickInfoDisplayParts("local function", "", { start: test.markerByName(marker.toString()).position, length: "foo".length },
-        [{ text: "(", kind: "punctuation" }, { text: "local function", kind: "text" }, { text: ")", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: "foo", kind: "functionName" }, { text: "(", kind: "punctuation" },
-            { text: "param", kind: "parameterName" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "string", kind: "keyword" },
-            { text: ",", kind: "punctuation" }, { text: " ", kind: "space" },
-            { text: "optionalParam", kind: "parameterName" }, { text: "?", kind: "punctuation" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "string", kind: "keyword" },
-            { text: ",", kind: "punctuation" }, { text: " ", kind: "space" },
-            { text: "paramWithInitializer", kind: "parameterName" }, { text: "?", kind: "punctuation" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "string", kind: "keyword" },
-            { text: ",", kind: "punctuation" }, { text: " ", kind: "space" },
-            { text: "...", kind: "punctuation" }, { text: "restParam", kind: "parameterName" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: "string", kind: "keyword" }, { text: "[", kind: "punctuation" }, { text: "]", kind: "punctuation" },
-            { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "void", kind: "keyword" }],
-        []);
-}
-
-function verifyFunctionWithOverload(functionName: string, type: string, overloadCount: number) {
-    marker++;
-    goTo.marker(marker.toString());
-    verify.verifyQuickInfoDisplayParts("local function", "", { start: test.markerByName(marker.toString()).position, length: functionName.length },
-        [{ text: "(", kind: "punctuation" }, { text: "local function", kind: "text" }, { text: ")", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: functionName, kind: "functionName" }, { text: "(", kind: "punctuation" },
-            { text: "a", kind: "parameterName" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: type, kind: "keyword" },
-            { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: type, kind: "keyword" },
-            { text: " ", kind: "space" }, { text: "(", kind: "punctuation" }, { text: "+", kind: "operator" }, { text: overloadCount.toString(), kind: "numericLiteral" },
-            { text: " ", kind: "space" }, { text: overloadCount === 1 ? "overload" : "overloads", kind: "text" }, { text: ")", kind: "punctuation" }],
-        []);
-}
-
-
-// Declarations
-verifyOuterFunction();
-
-verifyFunctionWithoutOverload();
-
-verifyFunctionWithOverload("foowithoverload", "string", 1);
-verifyFunctionWithOverload("foowithoverload", "number", 1);
-verifyFunctionWithOverload("foowithoverload", "string", 1);
-
-verifyFunctionWithOverload("foowith3overload", "string", 2);
-verifyFunctionWithOverload("foowith3overload", "number", 2);
-verifyFunctionWithOverload("foowith3overload", "boolean", 2);
-verifyFunctionWithOverload("foowith3overload", "string", 2);
-
-// Calls
-verifyFunctionWithoutOverload();
-
-verifyFunctionWithOverload("foowithoverload", "string", 1);
-verifyFunctionWithOverload("foowithoverload", "number", 1);
-
-verifyFunctionWithOverload("foowith3overload", "string", 2);
-verifyFunctionWithOverload("foowith3overload", "number", 2);
-verifyFunctionWithOverload("foowith3overload", "boolean", 2);
-verifyOuterFunction();
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsModules.ts

@@ -13,51 +13,4 @@
 ////var /*12*/x = /*13*/m1./*14*/m2;
 ////var /*15*/y: typeof /*16*/m1./*17*/m2;
 
-var marker = 0;
-function goToMarker() {
-    marker++;
-    goTo.marker(marker.toString());
-}
-
-function verifyNamespace(name: string, optionalParentName?: string) {
-    goToMarker();
-    var namespaceNameDisplay = [{ text: name, kind: "moduleName" }];
-    if (optionalParentName) {
-        namespaceNameDisplay = [{ text: optionalParentName, kind: "moduleName" }, { text: ".", kind: "punctuation" }].concat(namespaceNameDisplay);
-    }
-    verify.verifyQuickInfoDisplayParts("module", optionalParentName ? "export" : "", { start: test.markerByName(marker.toString()).position, length: name.length },
-        [{ text: "namespace", kind: "keyword" }, { text: " ", kind: "space" }].concat(namespaceNameDisplay),
-        []);
-}
-
-function verifyVar(name: string, optionalFullName?: ts.SymbolDisplayPart[], typeDisplay: ts.SymbolDisplayPart[]= [{ text: "number", kind: "keyword" }]) {
-    goToMarker();
-    verify.verifyQuickInfoDisplayParts("var", optionalFullName ? "export" : "", { start: test.markerByName(marker.toString()).position, length: name.length },
-        [{ text: "var", kind: "keyword" },
-            { text: " ", kind: "space" }].concat(optionalFullName || [{ text: name, kind: "localName" }]).concat(
-            { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }).concat(typeDisplay),
-        []);
-}
-
-verifyNamespace("m");
-verifyVar("namespaceElemWithoutExport");
-verifyVar("namespaceElemWithExport", [{ text: "m", kind: "moduleName" }, { text: ".", kind: "punctuation" }, { text: "namespaceElemWithExport", kind: "localName" }]);
-
-verifyVar("a", /*optionalFullName*/ undefined, [{ text: "typeof", kind: "keyword" }, { text: " ", kind: "space" }, { text: "m", kind: "moduleName" }]);
-verifyNamespace("m");
-verifyVar("b", /*optionalFullName*/ undefined, [{ text: "typeof", kind: "keyword" }, { text: " ", kind: "space" }, { text: "m", kind: "moduleName" }]);
-verifyNamespace("m");
-
-verifyNamespace("m1");
-verifyNamespace("m2", "m1");
-verifyVar("namespaceElemWithoutExport");
-verifyVar("namespaceElemWithExport", [{ text: "m1", kind: "moduleName" }, { text: ".", kind: "punctuation" },
-    { text: "m2", kind: "moduleName" }, { text: ".", kind: "punctuation" }, { text: "namespaceElemWithExport", kind: "localName" }]);
-verifyVar("x", /*optionalFullName*/ undefined, [{ text: "typeof", kind: "keyword" }, { text: " ", kind: "space" },
-    { text: "m1", kind: "moduleName" }, { text: ".", kind: "punctuation" }, { text: "m2", kind: "moduleName" }]);
-verifyNamespace("m1");
-verifyNamespace("m2", "m1");
-verifyVar("y", /*optionalFullName*/ undefined, [{ text: "typeof", kind: "keyword" }, { text: " ", kind: "space" },
-    { text: "m1", kind: "moduleName" }, { text: ".", kind: "punctuation" }, { text: "m2", kind: "moduleName" }]);
-verifyNamespace("m1");
-verifyNamespace("m2", "m1");
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsParameters.ts

@@ -7,39 +7,4 @@
 ////    /*9*/restParam[0] = "World";
 ////}
 
-goTo.marker("1");
-verify.verifyQuickInfoDisplayParts("function", "", { start: test.markerByName('1').position, length: "foo".length },
-    [{ text: "function", kind: "keyword" },
-        { text: " ", kind: "space" }, { text: "foo", kind: "functionName" }, { text: "(", kind: "punctuation" }, 
-        { text: "param", kind: "parameterName" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "string", kind: "keyword" },
-        { text: ",", kind: "punctuation" }, { text: " ", kind: "space" }, 
-        { text: "optionalParam", kind: "parameterName" }, { text: "?", kind: "punctuation" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "string", kind: "keyword" },
-        { text: ",", kind: "punctuation" }, { text: " ", kind: "space" },
-        { text: "paramWithInitializer", kind: "parameterName" }, { text: "?", kind: "punctuation" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "string", kind: "keyword" },
-        { text: ",", kind: "punctuation" }, { text: " ", kind: "space" },
-        { text: "...", kind: "punctuation" }, { text: "restParam", kind: "parameterName" }, { text: ":", kind: "punctuation" }, 
-        { text: " ", kind: "space" }, { text: "string", kind: "keyword" } , { text: "[", kind: "punctuation" }, { text: "]", kind: "punctuation" },
-        { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "void", kind: "keyword" }],
-    []);
-
-var marker = 1;
-function verifyParam(parameterName: string, isRest: boolean) {
-    marker++;
-    goTo.marker(marker.toString());
-    var displayParts = [{ text: "(", kind: "punctuation" }, { text: "parameter", kind: "text" }, { text: ")", kind: "punctuation" }, { text: " ", kind: "space" },
-        { text: parameterName, kind: "parameterName" }, { text: ":", kind: "punctuation" }, { text: " ", kind: "space" }, { text: "string", kind: "keyword" }];
-    if (isRest) {
-        displayParts.push({ text: "[", kind: "punctuation" }, { text: "]", kind: "punctuation" });
-    }
-    verify.verifyQuickInfoDisplayParts("parameter", "", { start: test.markerByName(marker.toString()).position, length: parameterName.length }, displayParts, []);
-}
-
-verifyParam('param', /*isRest*/false);
-verifyParam('optionalParam', /*isRest*/false);
-verifyParam('paramWithInitializer', /*isRest*/false); 
-verifyParam('restParam', /*isRest*/true);
-
-verifyParam('param', /*isRest*/false);
-verifyParam('optionalParam', /*isRest*/false);
-verifyParam('paramWithInitializer', /*isRest*/false);
-verifyParam('restParam', /*isRest*/true);
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsTypeAlias.ts

@@ -5,38 +5,4 @@
 ////type /*2*/t1 = /*3*/c;
 ////var /*4*/cInstance: /*5*/t1 = new /*6*/c();
 
-function verifyClassDisplay(markerName: string) {
-    goTo.marker(markerName);
-    verify.verifyQuickInfoDisplayParts("class", "", { start: test.markerByName(markerName).position, length: "c".length },
-        [{ text: "class", kind: "keyword" }, { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-        []);
-}
-
-function verifyTypeAliasDisplay(markerName: string) {
-    goTo.marker(markerName);
-    verify.verifyQuickInfoDisplayParts("type", "", { start: test.markerByName(markerName).position, length: "t1".length },
-        [{ text: "type", kind: "keyword" }, { text: " ", kind: "space" }, { text: "t1", kind: "aliasName" },
-            { text: " ", kind: "space" }, { text: "=", kind: "operator" }, { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-        []);
-}
-
-verifyClassDisplay('1');
-verifyTypeAliasDisplay('2');
-verifyClassDisplay('3');
-
-goTo.marker('4');
-verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName("4").position, length: "cInstance".length },
-    [{ text: "var", kind: "keyword" },
-        { text: " ", kind: "space" }, { text: "cInstance", kind: "localName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
-
-verifyTypeAliasDisplay('5');
-
-goTo.marker('6');
-verify.verifyQuickInfoDisplayParts("constructor", "", { start: test.markerByName("6").position, length: "c".length },
-    [{ text: "constructor", kind: "keyword" },
-        { text: " ", kind: "space" }, { text: "c", kind: "className" },
-        { text: "(", kind: "punctuation" }, { text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "c", kind: "className" }],
-    []);
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInClass.ts

@@ -21,219 +21,4 @@
 ////var /*36*/cVal2 = /*37*/c2;
 /////*38*/cInstance1./*39*/method(/*40*/cInstance, /*41*/cInstance);
 
-var marker = 0;
-var markerName: string;
-
-function goToMarker() {
-    marker++;
-    markerName = marker.toString();
-    goTo.marker(markerName);
-}
-
-function getTypeParameterDisplay(instanceType: ts.SymbolDisplayPart[],
-    name: string, optionalExtends?: ts.SymbolDisplayPart[]) {
-    return instanceType ||
-        function () {
-            var typeParameterDisplay = [{ text: name, kind: "typeParameterName" }];
-            if (optionalExtends) {
-                typeParameterDisplay.push({ text: " ", kind: "space" }, { text: "extends", kind: "keyword" },
-                    { text: " ", kind: "space" });
-                typeParameterDisplay = typeParameterDisplay.concat(optionalExtends);
-            }
-            return typeParameterDisplay
-        } ();
-}
-
-function getClassDisplay(name: string, optionalInstanceType?: ts.SymbolDisplayPart[],
-    optionalExtends?: ts.SymbolDisplayPart[]) {
-    var classDisplay = [{ text: name, kind: "className" }, { text: "<", kind: "punctuation" }];
-    classDisplay = classDisplay.concat(getTypeParameterDisplay(optionalInstanceType, "T", optionalExtends));
-    classDisplay.push({ text: ">", kind: "punctuation" });
-    return classDisplay;
-}
-
-function verifyClassDisplay(name: string, optionalExtends?: ts.SymbolDisplayPart[]) {
-    goToMarker();
-
-    verify.verifyQuickInfoDisplayParts("class", "", { start: test.markerByName(markerName).position, length: name.length },
-        [{ text: "class", kind: "keyword" }, { text: " ", kind: "space" }].concat(
-            getClassDisplay(name, undefined, optionalExtends)), []);
-}
-
-function verifyTypeParameter(name: string, inDisplay: ts.SymbolDisplayPart[]) {
-    goToMarker();
-
-    var typeParameterDisplay = [{ text: "(", kind: "punctuation" }, { text: "type parameter", kind: "text" }, { text: ")", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: name, kind: "typeParameterName" },
-        { text: " ", kind: "space" }, { text: "in", kind: "keyword" }, { text: " ", kind: "space" }];
-    typeParameterDisplay = typeParameterDisplay.concat(inDisplay);
-
-    verify.verifyQuickInfoDisplayParts("type parameter", "", { start: test.markerByName(markerName).position, length: name.length },
-        typeParameterDisplay, []);
-}
-
-function verifyConstructor(name: string, optionalInstanceType?: ts.SymbolDisplayPart[],
-    optionalExtends?: ts.SymbolDisplayPart[]) {
-    goToMarker();
-    var constructorDisplay = [{ text: "constructor", kind: "keyword" },
-        { text: " ", kind: "space" }];
-    constructorDisplay = constructorDisplay.concat(getClassDisplay(name, optionalInstanceType, optionalExtends));
-
-    constructorDisplay.push({ text: "(", kind: "punctuation" }, { text: "a", kind: "parameterName" },
-        { text: ":", kind: "punctuation" }, { text: " ", kind: "space" });
-    
-    constructorDisplay = constructorDisplay.concat(
-        getTypeParameterDisplay(optionalInstanceType, "T"));
-
-    constructorDisplay.push({ text: ")", kind: "punctuation" },
-        { text: ":", kind: "punctuation" }, { text: " ", kind: "space" });
-
-    constructorDisplay = constructorDisplay.concat(getClassDisplay(name, optionalInstanceType));
-
-    verify.verifyQuickInfoDisplayParts("constructor", "", { start: test.markerByName(markerName).position, length: optionalInstanceType ? name.length : "constructor".length },
-        constructorDisplay, []);
-}
-
-function verifyParameter(name: string, type: string, optionalExtends?: ts.SymbolDisplayPart[]) {
-    goToMarker();
-    var parameterDisplay = [{ text: "(", kind: "punctuation" }, { text: "parameter", kind: "text" }, { text: ")", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: name, kind: "parameterName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: type, kind: "typeParameterName" }];
-    if (optionalExtends) {
-        parameterDisplay.push({ text: " ", kind: "space" }, { text: "extends", kind: "keyword" },
-            { text: " ", kind: "space" });
-        parameterDisplay = parameterDisplay.concat(optionalExtends);
-    }
-    verify.verifyQuickInfoDisplayParts("parameter", "", { start: test.markerByName(markerName).position, length: name.length },
-        parameterDisplay, []);
-}
-
-function getMethodDisplay(name: string, className: string,
-    optionalInstanceType?: ts.SymbolDisplayPart[], optionalExtends?: ts.SymbolDisplayPart[]) {
-    var functionDisplay = getClassDisplay(className, optionalInstanceType, optionalExtends);
-
-    functionDisplay.push({ text: ".", kind: "punctuation" }, { text: name, kind: "methodName" },
-        { text: "<", kind: "punctuation" });
-
-    functionDisplay = functionDisplay.concat(
-        getTypeParameterDisplay(optionalInstanceType, "U", optionalExtends));
-
-    functionDisplay.push({ text: ">", kind: "punctuation" }, { text: "(", kind: "punctuation" },
-        { text: "a", kind: "parameterName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" });
-    functionDisplay = functionDisplay.concat(
-        getTypeParameterDisplay(optionalInstanceType, "U"));
-    functionDisplay.push({ text: ",", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: "b", kind: "parameterName" },
-        { text: ":", kind: "punctuation" }, { text: " ", kind: "space" });
-    functionDisplay = functionDisplay.concat(
-        getTypeParameterDisplay(optionalInstanceType, "T"));
-
-    functionDisplay.push({ text: ")", kind: "punctuation" },
-        { text: ":", kind: "punctuation" }, { text: " ", kind: "space" });
-
-    functionDisplay = functionDisplay.concat(
-        getTypeParameterDisplay(optionalInstanceType, "U"));
-
-    return functionDisplay;
-}
-
-function verifyMethodDisplay(name: string, className: string,
-    optionalInstanceType?: ts.SymbolDisplayPart[], optionalExtends?: ts.SymbolDisplayPart[]) {
-    goToMarker();
-    var functionDisplay = [{ text: "(", kind: "punctuation" }, { text: "method", kind: "text" },
-        { text: ")", kind: "punctuation" }, { text: " ", kind: "space" }].concat(
-        getMethodDisplay(name, className, optionalInstanceType, optionalExtends));
-
-    verify.verifyQuickInfoDisplayParts("method", "",
-        { start: test.markerByName(markerName).position, length: name.length },
-        functionDisplay, []);
-}
-
-function verifyClassInstance(name: string, typeDisplay: ts.SymbolDisplayPart[]) {
-    goToMarker();
-    verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName(markerName).position, length: name.length },
-        [{ text: "var", kind: "keyword" },
-            { text: " ", kind: "space" }, { text: name, kind: "localName" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }].concat(typeDisplay),
-        []);
-}
-
-function verifyVarTypeOf(name: string, typeOfSymbol: ts.SymbolDisplayPart) {
-    goToMarker();
-    verify.verifyQuickInfoDisplayParts("var", "", { start: test.markerByName(markerName).position, length: name.length },
-        [{ text: "var", kind: "keyword" },
-            { text: " ", kind: "space" }, { text: name, kind: "localName" }, { text: ":", kind: "punctuation" },
-            { text: " ", kind: "space" }, { text: "typeof", kind: "keyword" },
-            { text: " ", kind: "space" }].concat(typeOfSymbol),
-        []);
-}
-
-var stringTypeDisplay = [{ text: "string", kind: "keyword" }];
-var extendsTypeDisplay = getClassDisplay("c", stringTypeDisplay);
-
-// Declaration
-verifyClassDisplay("c");
-verifyTypeParameter("T", getClassDisplay("c"));
-
-// Constructor declaration
-verifyConstructor("c");
-verifyParameter("a", "T");
-verifyTypeParameter("T", getClassDisplay("c"));
-
-// Method declaration
-verifyMethodDisplay("method", "c");
-verifyTypeParameter("U", getMethodDisplay("method", "c"));
-verifyParameter("a", "U");
-verifyTypeParameter("U", getMethodDisplay("method", "c"));
-verifyParameter("b", "T");
-verifyTypeParameter("T", getClassDisplay("c"));
-verifyParameter("a", "U");
-
-// Instance creation
-verifyClassInstance("cInstance", getClassDisplay("c", stringTypeDisplay));
-verifyConstructor("c", stringTypeDisplay);
-
-// typeof assignment
-verifyVarTypeOf("cVal", { text: "c", kind: "className" });
-verifyClassDisplay("c");
-
-// Method call
-verifyClassInstance("cInstance", getClassDisplay("c", stringTypeDisplay));
-verifyMethodDisplay("method", "c", stringTypeDisplay);
-
-// With constraint
-// Declaration
-verifyClassDisplay("c2", getClassDisplay("c", stringTypeDisplay));
-verifyTypeParameter("T", getClassDisplay("c2", /*instanceType*/undefined, extendsTypeDisplay));
-verifyClassDisplay("c");
-
-// Constructor declaration
-verifyConstructor("c2", /*instanceType*/undefined, extendsTypeDisplay);
-verifyParameter("a", "T", extendsTypeDisplay);
-verifyTypeParameter("T", getClassDisplay("c2", /*instanceType*/undefined, extendsTypeDisplay));
-
-// Method declaration
-verifyMethodDisplay("method", "c2", /*instance*/undefined, extendsTypeDisplay);
-verifyTypeParameter("U", getMethodDisplay("method", "c2", /*instance*/undefined, extendsTypeDisplay));
-verifyClassDisplay("c");
-verifyParameter("a", "U", extendsTypeDisplay);
-verifyTypeParameter("U", getMethodDisplay("method", "c2", /*instance*/undefined, extendsTypeDisplay));
-verifyParameter("b", "T", extendsTypeDisplay);
-verifyTypeParameter("T", getClassDisplay("c2", /*instanceType*/undefined, extendsTypeDisplay));
-verifyParameter("a", "U", extendsTypeDisplay);
-
-// Instance creation
-verifyClassInstance("cInstance1", getClassDisplay("c2", extendsTypeDisplay));
-verifyConstructor("c2", extendsTypeDisplay);
-verifyClassInstance("cInstance", getClassDisplay("c", stringTypeDisplay));
-
-// typeof assignment
-verifyVarTypeOf("cVal2", { text: "c2", kind: "className" });
-verifyClassDisplay("c2", getClassDisplay("c", stringTypeDisplay));
-
-// Method call
-verifyClassInstance("cInstance1", getClassDisplay("c2", extendsTypeDisplay));
-verifyMethodDisplay("method", "c2", extendsTypeDisplay);
-verifyClassInstance("cInstance", getClassDisplay("c", stringTypeDisplay));
-verifyClassInstance("cInstance", getClassDisplay("c", stringTypeDisplay));
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunction.ts

@@ -10,108 +10,4 @@
 ////}
 /////*12*/foo2("hello");
 
-var marker = 0;
-var markerName: string;
-
-function goToMarker() {
-    marker++;
-    markerName = marker.toString();
-    goTo.marker(markerName);
-}
-
-function getTypeParameterDisplay(instanceType: ts.SymbolDisplayPart[],
-    name: string, optionalExtends?: ts.SymbolDisplayPart[]) {
-    return instanceType ||
-        function () {
-            var typeParameterDisplay = [{ text: name, kind: "typeParameterName" }];
-            if (optionalExtends) {
-                typeParameterDisplay.push({ text: " ", kind: "space" }, { text: "extends", kind: "keyword" },
-                    { text: " ", kind: "space" });
-                typeParameterDisplay = typeParameterDisplay.concat(optionalExtends);
-            }
-            return typeParameterDisplay
-        } ();
-}
-
-function verifyTypeParameter(name: string, inDisplay: ts.SymbolDisplayPart[]) {
-    goToMarker();
-
-    var typeParameterDisplay = [{ text: "(", kind: "punctuation" }, { text: "type parameter", kind: "text" }, { text: ")", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: name, kind: "typeParameterName" },
-        { text: " ", kind: "space" }, { text: "in", kind: "keyword" }, { text: " ", kind: "space" }];
-    typeParameterDisplay = typeParameterDisplay.concat(inDisplay);
-
-    verify.verifyQuickInfoDisplayParts("type parameter", "", { start: test.markerByName(markerName).position, length: name.length },
-        typeParameterDisplay, []);
-}
-
-function verifyParameter(name: string, typeParameterName: string, optionalExtends?: ts.SymbolDisplayPart[]) {
-    goToMarker();
-    var parameterDisplay = [{ text: "(", kind: "punctuation" }, { text: "parameter", kind: "text" }, { text: ")", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: name, kind: "parameterName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" }, { text: typeParameterName, kind: "typeParameterName" }];
-    if (optionalExtends) {
-        parameterDisplay.push({ text: " ", kind: "space" }, { text: "extends", kind: "keyword" },
-            { text: " ", kind: "space" });
-        parameterDisplay = parameterDisplay.concat(optionalExtends);
-    }
-    verify.verifyQuickInfoDisplayParts("parameter", "", { start: test.markerByName(markerName).position, length: name.length },
-        parameterDisplay, []);
-}
-
-function getFunctionDisplay(name: string, optionalInstanceType?: ts.SymbolDisplayPart[],
-    optionalExtends?: ts.SymbolDisplayPart[]) {
-    var functionDisplay = [{ text: name, kind: "functionName" }, { text: "<", kind: "punctuation" }];
-
-    functionDisplay = functionDisplay.concat(
-        getTypeParameterDisplay(optionalInstanceType, "U", optionalExtends));
-
-    functionDisplay.push({ text: ">", kind: "punctuation" }, { text: "(", kind: "punctuation" },
-        { text: "a", kind: "parameterName" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" });
-
-    functionDisplay = functionDisplay.concat(
-        getTypeParameterDisplay(optionalInstanceType, "U"));
-
-    functionDisplay.push({ text: ")", kind: "punctuation" }, { text: ":", kind: "punctuation" },
-        { text: " ", kind: "space" });
-
-    functionDisplay = functionDisplay.concat(
-        getTypeParameterDisplay(optionalInstanceType, "U"));
-
-    return functionDisplay;
-}
-
-function verifyFunctionDisplay(name: string, optionalInstanceType?: ts.SymbolDisplayPart[],
-    optionalExtends?: ts.SymbolDisplayPart[]) {
-    goToMarker();
-    var functionDisplay = [{ text: "function", kind: "keyword" }, { text: " ", kind: "space" }].concat(
-        getFunctionDisplay(name, optionalInstanceType, optionalExtends));
-
-    verify.verifyQuickInfoDisplayParts("function", "",
-        { start: test.markerByName(markerName).position, length: name.length },
-        functionDisplay, []);
-}
-
-var stringTypeDisplay = [{ text: "string", kind: "keyword" }];
-
-// Declaration
-verifyFunctionDisplay("foo");
-verifyTypeParameter("U", getFunctionDisplay("foo"));
-verifyParameter("a", "U");
-verifyTypeParameter("U", getFunctionDisplay("foo"));
-verifyParameter("a", "U");
-
-// Call
-verifyFunctionDisplay("foo", stringTypeDisplay);
-
-// With constraint
-// Declaration
-verifyFunctionDisplay("foo2", /*instance*/ undefined, stringTypeDisplay);
-verifyTypeParameter("U", getFunctionDisplay("foo2", /*instance*/ undefined, stringTypeDisplay));
-verifyParameter("a", "U", stringTypeDisplay);
-verifyTypeParameter("U", getFunctionDisplay("foo2", /*instance*/ undefined, stringTypeDisplay));
-verifyParameter("a", "U", stringTypeDisplay);
-
-// Call
-verifyFunctionDisplay("foo2", [{ text: "\"hello\"", kind: "stringLiteral" }]);
+verify.baselineQuickInfo();

tests/cases/fourslash/quickInfoDisplayPartsTypeParameterInFunctionLikeInTypeAlias.ts

@@ -3,20 +3,4 @@
 //// type MixinCtor<A> = new () => /*0*/A & { constructor: MixinCtor</*1*/A> };
 //// type MixinCtor<A> = new () => A & { constructor: { constructor: MixinCtor</*2*/A> } };
 
-let typeAliashDisplayParts = [{ text: "type", kind: "keyword" }, { text: " ", kind: "space" }, { text: "MixinCtor", kind: "aliasName" },
-    { text: "<", kind: "punctuation" }, { text: "A", kind: "typeParameterName" }, { text: ">", kind: "punctuation" }];
-
-let typeParameterDisplayParts = [{ text: "(", kind: "punctuation" }, { text: "type parameter", kind: "text" }, { text: ")", kind: "punctuation" }, { text: " ", kind: "space" },
-    { text: "A", kind: "typeParameterName" }, { text: " ", kind: "space" }, { text: "in", kind: "keyword" }, { text: " ", kind: "space" }];
-
-goTo.marker('0');
-verify.verifyQuickInfoDisplayParts("type parameter", "", { start: test.markerByName("0").position, length: "A".length },
-    typeParameterDisplayParts.concat(typeAliashDisplayParts), []);
-
-goTo.marker('1');
-verify.verifyQuickInfoDisplayParts("type parameter", "", { start: test.markerByName("1").position, length: "A".length },
-    typeParameterDisplayParts.concat(typeAliashDisplayParts), []);;
-
-goTo.marker('2');
-verify.verifyQuickInfoDisplayParts("type parameter", "", { start: test.markerByName("2").position, length: "A".length },
-    typeParameterDisplayParts.concat(typeAliashDisplayParts), []);
+verify.baselineQuickInfo();