Merge branch 'master' into enum-number-assignability-in-unions

Gulpfile.ts

@@ -39,6 +39,8 @@ const gulp = helpMaker(originalGulp);
 const mochaParallel = require("./scripts/mocha-parallel.js");
 const {runTestsInParallel} = mochaParallel;
 
+Error.stackTraceLimit = 1000;
+
 const cmdLineOptions = minimist(process.argv.slice(2), {
     boolean: ["debug", "light", "colors", "lint", "soft"],
     string: ["browser", "tests", "host", "reporter"],
@@ -727,6 +729,7 @@ gulp.task("browserify", "Runs browserify on run.js to produce a file suitable fo
                         sourcemaps: {
                             "built/local/_stream_0.js": originalMap,
                             "built/local/bundle.js": maps,
+                            "node_modules/source-map-support/source-map-support.js": undefined,
                         }
                     });
                     const finalMap = chain.apply();

Jakefile.js

@@ -120,16 +120,28 @@ var servicesSources = [
 ].map(function (f) {
     return path.join(compilerDirectory, f);
 }).concat([
+    "types.ts",
+    "utilities.ts",
     "breakpoints.ts",
+    "classifier.ts",
+    "completions.ts",
+    "documentHighlights.ts",
+    "documentRegistry.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",
@@ -992,15 +1004,18 @@ function acceptBaseline(containerFolder) {
     var deleteEnding = '.delete';
     for (var i in files) {
         var filename = files[i];
-        if (filename.substr(filename.length - deleteEnding.length) === deleteEnding) {
-            filename = filename.substr(0, filename.length - deleteEnding.length);
-            fs.unlinkSync(path.join(targetFolder, filename));
-        } else {
-            var target = path.join(targetFolder, filename);
-            if (fs.existsSync(target)) {
-                fs.unlinkSync(target);
+        var fullLocalPath = path.join(sourceFolder, filename);
+        if (fs.statSync(fullLocalPath).isFile()) {
+            if (filename.substr(filename.length - deleteEnding.length) === deleteEnding) {
+                filename = filename.substr(0, filename.length - deleteEnding.length);
+                fs.unlinkSync(path.join(targetFolder, filename));
+            } else {
+                var target = path.join(targetFolder, filename);
+                if (fs.existsSync(target)) {
+                    fs.unlinkSync(target);
+                }
+                fs.renameSync(path.join(sourceFolder, filename), target);
             }
-            fs.renameSync(path.join(sourceFolder, filename), target);
         }
     }
 }

lib/lib.es2015.collection.d.ts

@@ -20,7 +20,7 @@ interface Map<K, V> {
     forEach(callbackfn: (value: V, index: K, map: Map<K, V>) => void, thisArg?: any): void;
     get(key: K): V | undefined;
     has(key: K): boolean;
-    set(key: K, value?: V): this;
+    set(key: K, value: V): this;
     readonly size: number;
 }
 
@@ -36,7 +36,7 @@ interface WeakMap<K, V> {
     delete(key: K): boolean;
     get(key: K): V | undefined;
     has(key: K): boolean;
-    set(key: K, value?: V): this;
+    set(key: K, value: V): this;
 }
 
 interface WeakMapConstructor {

scripts/tslint/preferConstRule.ts

@@ -93,11 +93,16 @@ class PreferConstWalker extends Lint.RuleWalker {
 
     private visitBindingPatternIdentifiers(pattern: ts.BindingPattern) {
         for (const element of pattern.elements) {
-            if (element.name.kind === ts.SyntaxKind.Identifier) {
-                this.markAssignment(element.name as ts.Identifier);
+            if (element.kind !== ts.SyntaxKind.BindingElement) {
+                continue;
+            }
+
+            const name = (<ts.BindingElement>element).name;
+            if (name.kind === ts.SyntaxKind.Identifier) {
+                this.markAssignment(name as ts.Identifier);
             }
             else {
-                this.visitBindingPatternIdentifiers(element.name as ts.BindingPattern);
+                this.visitBindingPatternIdentifiers(name as ts.BindingPattern);
             }
         }
     }
@@ -191,7 +196,9 @@ class PreferConstWalker extends Lint.RuleWalker {
 
     private collectBindingPatternIdentifiers(value: ts.VariableDeclaration, pattern: ts.BindingPattern, table: ts.MapLike<DeclarationUsages>) {
         for (const element of pattern.elements) {
-            this.collectNameIdentifiers(value, element.name, table);
+            if (element.kind === ts.SyntaxKind.BindingElement) {
+                this.collectNameIdentifiers(value, (<ts.BindingElement>element).name, table);
+            }
         }
     }
 }

src/compiler/binder.ts

@@ -591,6 +591,9 @@ namespace ts {
                 case SyntaxKind.PrefixUnaryExpression:
                     bindPrefixUnaryExpressionFlow(<PrefixUnaryExpression>node);
                     break;
+                case SyntaxKind.PostfixUnaryExpression:
+                    bindPostfixUnaryExpressionFlow(<PostfixUnaryExpression>node);
+                    break;
                 case SyntaxKind.BinaryExpression:
                     bindBinaryExpressionFlow(<BinaryExpression>node);
                     break;
@@ -1106,6 +1109,16 @@ namespace ts {
             }
             else {
                 forEachChild(node, bind);
+                if (node.operator === SyntaxKind.PlusEqualsToken || node.operator === SyntaxKind.MinusMinusToken) {
+                    bindAssignmentTargetFlow(node.operand);
+                }
+            }
+        }
+
+        function bindPostfixUnaryExpressionFlow(node: PostfixUnaryExpression) {
+            forEachChild(node, bind);
+            if (node.operator === SyntaxKind.PlusPlusToken || node.operator === SyntaxKind.MinusMinusToken) {
+                bindAssignmentTargetFlow(node.operand);
             }
         }
 
@@ -1150,8 +1163,8 @@ namespace ts {
             currentFlow = finishFlowLabel(postExpressionLabel);
         }
 
-        function bindInitializedVariableFlow(node: VariableDeclaration | BindingElement) {
-            const name = node.name;
+        function bindInitializedVariableFlow(node: VariableDeclaration | ArrayBindingElement) {
+            const name = !isOmittedExpression(node) ? node.name : undefined;
             if (isBindingPattern(name)) {
                 for (const child of name.elements) {
                     bindInitializedVariableFlow(child);

src/compiler/checker.ts

@@ -1044,7 +1044,7 @@ namespace ts {
             const moduleSymbol = resolveExternalModuleName(node, (<ImportDeclaration>node.parent).moduleSpecifier);
 
             if (moduleSymbol) {
-                const exportDefaultSymbol = isShorthandAmbientModule(moduleSymbol.valueDeclaration) ?
+                const exportDefaultSymbol = isShorthandAmbientModuleSymbol(moduleSymbol) ?
                     moduleSymbol :
                     moduleSymbol.exports["export="] ?
                         getPropertyOfType(getTypeOfSymbol(moduleSymbol.exports["export="]), "default") :
@@ -1120,7 +1120,7 @@ namespace ts {
             if (targetSymbol) {
                 const name = specifier.propertyName || specifier.name;
                 if (name.text) {
-                    if (isShorthandAmbientModule(moduleSymbol.valueDeclaration)) {
+                    if (isShorthandAmbientModuleSymbol(moduleSymbol)) {
                         return moduleSymbol;
                     }
 
@@ -2069,7 +2069,7 @@ namespace ts {
                     parentSymbol = symbol;
                 }
 
-                // const the writer know we just wrote out a symbol.  The declaration emitter writer uses
+                // Let the writer know we just wrote out a symbol.  The declaration emitter writer uses
                 // this to determine if an import it has previously seen (and not written out) needs
                 // to be written to the file once the walk of the tree is complete.
                 //
@@ -2077,37 +2077,34 @@ namespace ts {
                 // up front (for example, during checking) could determine if we need to emit the imports
                 // and we could then access that data during declaration emit.
                 writer.trackSymbol(symbol, enclosingDeclaration, meaning);
-                function walkSymbol(symbol: Symbol, meaning: SymbolFlags): void {
-                    if (symbol) {
-                        const accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, !!(flags & SymbolFormatFlags.UseOnlyExternalAliasing));
+                /** @param endOfChain Set to false for recursive calls; non-recursive calls should always output something. */
+                function walkSymbol(symbol: Symbol, meaning: SymbolFlags, endOfChain: boolean): void {
+                    const accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, !!(flags & SymbolFormatFlags.UseOnlyExternalAliasing));
 
-                        if (!accessibleSymbolChain ||
-                            needsQualification(accessibleSymbolChain[0], enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) {
+                    if (!accessibleSymbolChain ||
+                        needsQualification(accessibleSymbolChain[0], enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) {
 
-                            // Go up and add our parent.
-                            walkSymbol(
-                                getParentOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol),
-                                getQualifiedLeftMeaning(meaning));
+                        // Go up and add our parent.
+                        const parent = getParentOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol);
+                        if (parent) {
+                            walkSymbol(parent, getQualifiedLeftMeaning(meaning), /*endOfChain*/ false);
                         }
+                    }
 
-                        if (accessibleSymbolChain) {
-                            for (const accessibleSymbol of accessibleSymbolChain) {
-                                appendParentTypeArgumentsAndSymbolName(accessibleSymbol);
-                            }
+                    if (accessibleSymbolChain) {
+                        for (const accessibleSymbol of accessibleSymbolChain) {
+                            appendParentTypeArgumentsAndSymbolName(accessibleSymbol);
                         }
-                        else {
-                            // If we didn't find accessible symbol chain for this symbol, break if this is external module
-                            if (!parentSymbol && ts.forEach(symbol.declarations, hasExternalModuleSymbol)) {
-                                return;
-                            }
+                    }
+                    else if (
+                        // If this is the last part of outputting the symbol, always output. The cases apply only to parent symbols.
+                        endOfChain ||
+                        // If a parent symbol is an external module, don't write it. (We prefer just `x` vs `"foo/bar".x`.)
+                        !(!parentSymbol && ts.forEach(symbol.declarations, hasExternalModuleSymbol)) &&
+                        // If a parent symbol is an anonymous type, don't write it.
+                        !(symbol.flags & (SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral))) {
 
-                            // if this is anonymous type break
-                            if (symbol.flags & SymbolFlags.TypeLiteral || symbol.flags & SymbolFlags.ObjectLiteral) {
-                                return;
-                            }
-
-                            appendParentTypeArgumentsAndSymbolName(symbol);
-                        }
+                        appendParentTypeArgumentsAndSymbolName(symbol);
                     }
                 }
 
@@ -2117,11 +2114,11 @@ namespace ts {
                 const isTypeParameter = symbol.flags & SymbolFlags.TypeParameter;
                 const typeFormatFlag = TypeFormatFlags.UseFullyQualifiedType & typeFlags;
                 if (!isTypeParameter && (enclosingDeclaration || typeFormatFlag)) {
-                    walkSymbol(symbol, meaning);
-                    return;
+                    walkSymbol(symbol, meaning, /*endOfChain*/ true);
+                }
+                else {
+                    appendParentTypeArgumentsAndSymbolName(symbol);
                 }
-
-                return appendParentTypeArgumentsAndSymbolName(symbol);
             }
 
             function buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, globalFlags?: TypeFormatFlags, symbolStack?: Symbol[]) {
@@ -2506,8 +2503,8 @@ namespace ts {
                 }
             }
 
-            function buildBindingElementDisplay(bindingElement: BindingElement, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, symbolStack?: Symbol[]) {
-                if (bindingElement.kind === SyntaxKind.OmittedExpression) {
+            function buildBindingElementDisplay(bindingElement: ArrayBindingElement, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, symbolStack?: Symbol[]) {
+                if (isOmittedExpression(bindingElement)) {
                     return;
                 }
                 Debug.assert(bindingElement.kind === SyntaxKind.BindingElement);
@@ -2923,7 +2920,7 @@ namespace ts {
             // undefined or any type of the parent.
             if (!parentType || isTypeAny(parentType)) {
                 if (declaration.initializer) {
-                    return checkExpressionCached(declaration.initializer);
+                    return getBaseTypeOfLiteralType(checkExpressionCached(declaration.initializer));
                 }
                 return parentType;
             }
@@ -2983,7 +2980,9 @@ namespace ts {
             if (strictNullChecks && declaration.initializer && !(getFalsyFlags(checkExpressionCached(declaration.initializer)) & TypeFlags.Undefined)) {
                 type = getTypeWithFacts(type, TypeFacts.NEUndefined);
             }
-            return type;
+            return declaration.initializer ?
+                getUnionType([type, checkExpressionCached(declaration.initializer)], /*subtypeReduction*/ true) :
+                type;
         }
 
         function getTypeForVariableLikeDeclarationFromJSDocComment(declaration: VariableLikeDeclaration) {
@@ -3092,7 +3091,9 @@ namespace ts {
 
             // Use the type of the initializer expression if one is present
             if (declaration.initializer) {
-                return addOptionality(checkExpressionCached(declaration.initializer), /*optional*/ declaration.questionToken && includeOptionality);
+                const exprType = checkExpressionCached(declaration.initializer);
+                const type = getCombinedNodeFlags(declaration) & NodeFlags.Const || getCombinedModifierFlags(declaration) & ModifierFlags.Readonly ? exprType : getBaseTypeOfLiteralType(exprType);
+                return addOptionality(type, /*optional*/ declaration.questionToken && includeOptionality);
             }
 
             // If it is a short-hand property assignment, use the type of the identifier
@@ -3114,7 +3115,8 @@ namespace ts {
         // pattern. Otherwise, it is the type any.
         function getTypeFromBindingElement(element: BindingElement, includePatternInType?: boolean, reportErrors?: boolean): Type {
             if (element.initializer) {
-                return checkExpressionCached(element.initializer);
+                const exprType = checkExpressionCached(element.initializer);
+                return getCombinedNodeFlags(element) & NodeFlags.Const ? exprType : getBaseTypeOfLiteralType(exprType);
             }
             if (isBindingPattern(element.name)) {
                 return getTypeFromBindingPattern(<BindingPattern>element.name, includePatternInType, reportErrors);
@@ -3126,7 +3128,7 @@ namespace ts {
         }
 
         // Return the type implied by an object binding pattern
-        function getTypeFromObjectBindingPattern(pattern: BindingPattern, includePatternInType: boolean, reportErrors: boolean): Type {
+        function getTypeFromObjectBindingPattern(pattern: ObjectBindingPattern, includePatternInType: boolean, reportErrors: boolean): Type {
             const members = createMap<Symbol>();
             let hasComputedProperties = false;
             forEach(pattern.elements, e => {
@@ -3157,11 +3159,12 @@ namespace ts {
         // Return the type implied by an array binding pattern
         function getTypeFromArrayBindingPattern(pattern: BindingPattern, includePatternInType: boolean, reportErrors: boolean): Type {
             const elements = pattern.elements;
-            if (elements.length === 0 || elements[elements.length - 1].dotDotDotToken) {
+            const lastElement = lastOrUndefined(elements);
+            if (elements.length === 0 || (!isOmittedExpression(lastElement) && lastElement.dotDotDotToken)) {
                 return languageVersion >= ScriptTarget.ES6 ? createIterableType(anyType) : anyArrayType;
             }
             // If the pattern has at least one element, and no rest element, then it should imply a tuple type.
-            const elementTypes = map(elements, e => e.kind === SyntaxKind.OmittedExpression ? anyType : getTypeFromBindingElement(e, includePatternInType, reportErrors));
+            const elementTypes = map(elements, e => isOmittedExpression(e) ? anyType : getTypeFromBindingElement(e, includePatternInType, reportErrors));
             let result = createTupleType(elementTypes);
             if (includePatternInType) {
                 result = cloneTypeReference(result);
@@ -3179,8 +3182,8 @@ namespace ts {
         // the parameter.
         function getTypeFromBindingPattern(pattern: BindingPattern, includePatternInType?: boolean, reportErrors?: boolean): Type {
             return pattern.kind === SyntaxKind.ObjectBindingPattern
-                ? getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors)
-                : getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors);
+                ? getTypeFromObjectBindingPattern(<ObjectBindingPattern>pattern, includePatternInType, reportErrors)
+                : getTypeFromArrayBindingPattern(<ArrayBindingPattern>pattern, includePatternInType, reportErrors);
         }
 
         // Return the type associated with a variable, parameter, or property declaration. In the simple case this is the type
@@ -3382,7 +3385,7 @@ namespace ts {
         function getTypeOfFuncClassEnumModule(symbol: Symbol): Type {
             const links = getSymbolLinks(symbol);
             if (!links.type) {
-                if (symbol.valueDeclaration.kind === SyntaxKind.ModuleDeclaration && isShorthandAmbientModule(<ModuleDeclaration>symbol.valueDeclaration)) {
+                if (symbol.valueDeclaration.kind === SyntaxKind.ModuleDeclaration && isShorthandAmbientModuleSymbol(symbol)) {
                     links.type = anyType;
                 }
                 else {
@@ -3397,7 +3400,7 @@ namespace ts {
         function getTypeOfEnumMember(symbol: Symbol): Type {
             const links = getSymbolLinks(symbol);
             if (!links.type) {
-                links.type = getDeclaredTypeOfEnum(getParentOfSymbol(symbol));
+                links.type = getDeclaredTypeOfEnumMember(symbol);
             }
             return links.type;
         }
@@ -5712,7 +5715,7 @@ namespace ts {
         function getInferenceMapper(context: InferenceContext): TypeMapper {
             if (!context.mapper) {
                 const mapper: TypeMapper = t => {
-                    const typeParameters = context.typeParameters;
+                    const typeParameters = context.signature.typeParameters;
                     for (let i = 0; i < typeParameters.length; i++) {
                         if (t === typeParameters[i]) {
                             context.inferences[i].isFixed = true;
@@ -5721,7 +5724,7 @@ namespace ts {
                     }
                     return t;
                 };
-                mapper.mappedTypes = context.typeParameters;
+                mapper.mappedTypes = context.signature.typeParameters;
                 mapper.context = context;
                 context.mapper = mapper;
             }
@@ -7173,15 +7176,36 @@ namespace ts {
             return true;
         }
 
+        function literalTypesWithSameBaseType(types: Type[]): boolean {
+            let commonBaseType: Type;
+            for (const t of types) {
+                const baseType = getBaseTypeOfLiteralType(t);
+                if (!commonBaseType) {
+                    commonBaseType = baseType;
+                }
+                if (baseType === t || baseType !== commonBaseType) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        // When the candidate types are all literal types with the same base type, the common
+        // supertype is a union of those literal types. Otherwise, the common supertype is the
+        // first type that is a supertype of each of the other types.
+        function getSupertypeOrUnion(types: Type[]): Type {
+            return literalTypesWithSameBaseType(types) ? getUnionType(types) : forEach(types, t => isSupertypeOfEach(t, types) ? t : undefined);
+        }
+
         function getCommonSupertype(types: Type[]): Type {
             if (!strictNullChecks) {
-                return forEach(types, t => isSupertypeOfEach(t, types) ? t : undefined);
+                return getSupertypeOrUnion(types);
             }
             const primaryTypes = filter(types, t => !(t.flags & TypeFlags.Nullable));
             if (!primaryTypes.length) {
                 return getUnionType(types, /*subtypeReduction*/ true);
             }
-            const supertype = forEach(primaryTypes, t => isSupertypeOfEach(t, primaryTypes) ? t : undefined);
+            const supertype = getSupertypeOrUnion(primaryTypes);
             return supertype && includeFalsyTypes(supertype, getFalsyFlagsOfTypes(types) & TypeFlags.Nullable);
         }
 
@@ -7245,18 +7269,18 @@ namespace ts {
             return (type.flags & (TypeFlags.Literal | TypeFlags.Undefined | TypeFlags.Null)) !== 0;
         }
 
-        function isUnitUnionType(type: Type): boolean {
+        function isLiteralType(type: Type): boolean {
             return type.flags & TypeFlags.Boolean ? true :
                 type.flags & TypeFlags.Union ? type.flags & TypeFlags.Enum ? true : !forEach((<UnionType>type).types, t => !isUnitType(t)) :
                 isUnitType(type);
         }
 
-        function getBaseTypeOfUnitType(type: Type): Type {
+        function getBaseTypeOfLiteralType(type: Type): Type {
             return type.flags & TypeFlags.StringLiteral ? stringType :
                 type.flags & TypeFlags.NumberLiteral ? numberType :
                 type.flags & TypeFlags.BooleanLiteral ? booleanType :
                 type.flags & TypeFlags.EnumLiteral ? (<EnumLiteralType>type).baseType :
-                type.flags & TypeFlags.Union && !(type.flags & TypeFlags.Enum) ? getUnionType(map((<UnionType>type).types, getBaseTypeOfUnitType)) :
+                type.flags & TypeFlags.Union && !(type.flags & TypeFlags.Enum) ? getUnionType(map((<UnionType>type).types, getBaseTypeOfLiteralType)) :
                 type;
         }
 
@@ -7510,14 +7534,13 @@ namespace ts {
             }
         }
 
-        function createInferenceContext(typeParameters: TypeParameter[], inferUnionTypes: boolean): InferenceContext {
-            const inferences = map(typeParameters, createTypeInferencesObject);
-
+        function createInferenceContext(signature: Signature, inferUnionTypes: boolean): InferenceContext {
+            const inferences = map(signature.typeParameters, createTypeInferencesObject);
             return {
-                typeParameters,
+                signature,
                 inferUnionTypes,
                 inferences,
-                inferredTypes: new Array(typeParameters.length),
+                inferredTypes: new Array(signature.typeParameters.length),
             };
         }
 
@@ -7525,6 +7548,7 @@ namespace ts {
             return {
                 primary: undefined,
                 secondary: undefined,
+                topLevel: true,
                 isFixed: false,
             };
         }
@@ -7546,13 +7570,18 @@ namespace ts {
             return type.couldContainTypeParameters;
         }
 
-        function inferTypes(context: InferenceContext, source: Type, target: Type) {
+        function isTypeParameterAtTopLevel(type: Type, typeParameter: TypeParameter): boolean {
+            return type === typeParameter || type.flags & TypeFlags.UnionOrIntersection && forEach((<UnionOrIntersectionType>type).types, t => isTypeParameterAtTopLevel(t, typeParameter));
+        }
+
+        function inferTypes(context: InferenceContext, originalSource: Type, originalTarget: Type) {
+            const typeParameters = context.signature.typeParameters;
             let sourceStack: Type[];
             let targetStack: Type[];
             let depth = 0;
             let inferiority = 0;
             const visited = createMap<boolean>();
-            inferFromTypes(source, target);
+            inferFromTypes(originalSource, originalTarget);
 
             function isInProcess(source: Type, target: Type) {
                 for (let i = 0; i < depth; i++) {
@@ -7606,7 +7635,6 @@ namespace ts {
                     if (source.flags & TypeFlags.ContainsAnyFunctionType) {
                         return;
                     }
-                    const typeParameters = context.typeParameters;
                     for (let i = 0; i < typeParameters.length; i++) {
                         if (target === typeParameters[i]) {
                             const inferences = context.inferences[i];
@@ -7623,6 +7651,9 @@ namespace ts {
                                 if (!contains(candidates, source)) {
                                     candidates.push(source);
                                 }
+                                if (!isTypeParameterAtTopLevel(originalTarget, <TypeParameter>target)) {
+                                    inferences.topLevel = false;
+                                }
                             }
                             return;
                         }
@@ -7643,7 +7674,7 @@ namespace ts {
                     let typeParameter: TypeParameter;
                     // First infer to each type in union or intersection that isn't a type parameter
                     for (const t of targetTypes) {
-                        if (t.flags & TypeFlags.TypeParameter && contains(context.typeParameters, t)) {
+                        if (t.flags & TypeFlags.TypeParameter && contains(typeParameters, t)) {
                             typeParameter = <TypeParameter>t;
                             typeParameterCount++;
                         }
@@ -7718,8 +7749,12 @@ namespace ts {
                 }
             }
 
+            function inferFromParameterTypes(source: Type, target: Type) {
+                return inferFromTypes(source, target);
+            }
+
             function inferFromSignature(source: Signature, target: Signature) {
-                forEachMatchingParameterType(source, target, inferFromTypes);
+                forEachMatchingParameterType(source, target, inferFromParameterTypes);
 
                 if (source.typePredicate && target.typePredicate && source.typePredicate.kind === target.typePredicate.kind) {
                     inferFromTypes(source.typePredicate.type, target.typePredicate.type);
@@ -7778,14 +7813,28 @@ namespace ts {
             return inferences.primary || inferences.secondary || emptyArray;
         }
 
+        function hasPrimitiveConstraint(type: TypeParameter): boolean {
+            const constraint = getConstraintOfTypeParameter(type);
+            return constraint && maybeTypeOfKind(constraint, TypeFlags.Primitive);
+        }
+
         function getInferredType(context: InferenceContext, index: number): Type {
             let inferredType = context.inferredTypes[index];
             let inferenceSucceeded: boolean;
             if (!inferredType) {
                 const inferences = getInferenceCandidates(context, index);
                 if (inferences.length) {
+                    // We widen inferred literal types if
+                    // all inferences were made to top-level ocurrences of the type parameter, and
+                    // the type parameter has no constraint or its constraint includes no primitive or literal types, and
+                    // the type parameter was fixed during inference or does not occur at top-level in the return type.
+                    const signature = context.signature;
+                    const widenLiteralTypes = context.inferences[index].topLevel &&
+                        !hasPrimitiveConstraint(signature.typeParameters[index]) &&
+                        (context.inferences[index].isFixed || !isTypeParameterAtTopLevel(getReturnTypeOfSignature(signature), signature.typeParameters[index]));
+                    const baseInferences = widenLiteralTypes ? map(inferences, getBaseTypeOfLiteralType) : inferences;
                     // Infer widened union or supertype, or the unknown type for no common supertype
-                    const unionOrSuperType = context.inferUnionTypes ? getUnionType(inferences, /*subtypeReduction*/ true) : getCommonSupertype(inferences);
+                    const unionOrSuperType = context.inferUnionTypes ? getUnionType(baseInferences, /*subtypeReduction*/ true) : getCommonSupertype(baseInferences);
                     inferredType = unionOrSuperType ? getWidenedType(unionOrSuperType) : unknownType;
                     inferenceSucceeded = !!unionOrSuperType;
                 }
@@ -7801,7 +7850,7 @@ namespace ts {
 
                 // Only do the constraint check if inference succeeded (to prevent cascading errors)
                 if (inferenceSucceeded) {
-                    const constraint = getConstraintOfTypeParameter(context.typeParameters[index]);
+                    const constraint = getConstraintOfTypeParameter(context.signature.typeParameters[index]);
                     if (constraint) {
                         const instantiatedConstraint = instantiateType(constraint, getInferenceMapper(context));
                         if (!isTypeAssignableTo(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
@@ -7948,7 +7997,7 @@ namespace ts {
                 if (prop && prop.flags & SymbolFlags.SyntheticProperty) {
                     if ((<TransientSymbol>prop).isDiscriminantProperty === undefined) {
                         (<TransientSymbol>prop).isDiscriminantProperty = !(<TransientSymbol>prop).hasCommonType &&
-                            isUnitUnionType(getTypeOfSymbol(prop));
+                            isLiteralType(getTypeOfSymbol(prop));
                     }
                     return (<TransientSymbol>prop).isDiscriminantProperty;
                 }
@@ -8351,7 +8400,8 @@ namespace ts {
                 // Assignments only narrow the computed type if the declared type is a union type. Thus, we
                 // only need to evaluate the assigned type if the declared type is a union type.
                 if (isMatchingReference(reference, node)) {
-                    return declaredType.flags & TypeFlags.Union ?
+                    const isIncrementOrDecrement = node.parent.kind === SyntaxKind.PrefixUnaryExpression || node.parent.kind === SyntaxKind.PostfixUnaryExpression;
+                    return declaredType.flags & TypeFlags.Union && !isIncrementOrDecrement ?
                         getAssignmentReducedType(<UnionType>declaredType, getInitialOrAssignedType(node)) :
                         declaredType;
                 }
@@ -8947,6 +8997,7 @@ namespace ts {
             const isParameter = getRootDeclaration(declaration).kind === SyntaxKind.Parameter;
             const declarationContainer = getControlFlowContainer(declaration);
             let flowContainer = getControlFlowContainer(node);
+            const isOuterVariable = flowContainer !== declarationContainer;
             // When the control flow originates in a function expression or arrow function and we are referencing
             // a const variable or parameter from an outer function, we extend the origin of the control flow
             // analysis to include the immediately enclosing function.
@@ -8959,7 +9010,7 @@ namespace ts {
             // the entire control flow graph from the variable's declaration (i.e. when the flow container and
             // declaration container are the same).
             const assumeInitialized = !strictNullChecks || (type.flags & TypeFlags.Any) !== 0 || isParameter ||
-                flowContainer !== declarationContainer || isInAmbientContext(declaration);
+                isOuterVariable || isInAmbientContext(declaration);
             const flowType = getFlowTypeOfReference(node, type, assumeInitialized, flowContainer);
             // A variable is considered uninitialized when it is possible to analyze the entire control flow graph
             // from declaration to use, and when the variable's declared type doesn't include undefined but the
@@ -9466,14 +9517,14 @@ namespace ts {
                         if (parameter.dotDotDotToken) {
                             const restTypes: Type[] = [];
                             for (let i = indexOfParameter; i < iife.arguments.length; i++) {
-                                restTypes.push(getTypeOfExpression(iife.arguments[i]));
+                                restTypes.push(getBaseTypeOfLiteralType(checkExpression(iife.arguments[i])));
                             }
                             return createArrayType(getUnionType(restTypes));
                         }
                         const links = getNodeLinks(iife);
                         const cached = links.resolvedSignature;
                         links.resolvedSignature = anySignature;
-                        const type = checkExpression(iife.arguments[indexOfParameter]);
+                        const type = getBaseTypeOfLiteralType(checkExpression(iife.arguments[indexOfParameter]));
                         links.resolvedSignature = cached;
                         return type;
                     }
@@ -9824,6 +9875,7 @@ namespace ts {
                 case SyntaxKind.BinaryExpression:
                     return getContextualTypeForBinaryOperand(node);
                 case SyntaxKind.PropertyAssignment:
+                case SyntaxKind.ShorthandPropertyAssignment:
                     return getContextualTypeForObjectLiteralElement(<ObjectLiteralElement>parent);
                 case SyntaxKind.ArrayLiteralExpression:
                     return getContextualTypeForElementExpression(node);
@@ -9843,31 +9895,6 @@ namespace ts {
             return undefined;
         }
 
-        function isLiteralTypeLocation(node: Node): boolean {
-            const parent = node.parent;
-            switch (parent.kind) {
-                case SyntaxKind.BinaryExpression:
-                    switch ((<BinaryExpression>parent).operatorToken.kind) {
-                        case SyntaxKind.EqualsEqualsEqualsToken:
-                        case SyntaxKind.ExclamationEqualsEqualsToken:
-                        case SyntaxKind.EqualsEqualsToken:
-                        case SyntaxKind.ExclamationEqualsToken:
-                            return true;
-                    }
-                    break;
-                case SyntaxKind.ConditionalExpression:
-                    return (node === (<ConditionalExpression>parent).whenTrue ||
-                        node === (<ConditionalExpression>parent).whenFalse) &&
-                        isLiteralTypeLocation(parent);
-                case SyntaxKind.ParenthesizedExpression:
-                    return isLiteralTypeLocation(parent);
-                case SyntaxKind.CaseClause:
-                case SyntaxKind.LiteralType:
-                    return true;
-            }
-            return false;
-        }
-
         // If the given type is an object or union type, if that type has a single signature, and if
         // that signature is non-generic, return the signature. Otherwise return undefined.
         function getNonGenericSignature(type: Type): Signature {
@@ -10004,7 +10031,7 @@ namespace ts {
                     }
                 }
                 else {
-                    const type = checkExpression(e, contextualMapper);
+                    const type = checkExpressionForMutableLocation(e, contextualMapper);
                     elementTypes.push(type);
                 }
                 hasSpreadElement = hasSpreadElement || e.kind === SyntaxKind.SpreadElementExpression;
@@ -10148,7 +10175,7 @@ namespace ts {
                     }
                     else {
                         Debug.assert(memberDecl.kind === SyntaxKind.ShorthandPropertyAssignment);
-                        type = checkExpression((<ShorthandPropertyAssignment>memberDecl).name, contextualMapper);
+                        type = checkExpressionForMutableLocation((<ShorthandPropertyAssignment>memberDecl).name, contextualMapper);
                     }
                     typeFlags |= type.flags;
                     const prop = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient | member.flags, member.name);
@@ -10873,10 +10900,7 @@ namespace ts {
                 checkClassPropertyAccess(node, left, apparentType, prop);
             }
 
-            let propType = getTypeOfSymbol(prop);
-            if (prop.flags & SymbolFlags.EnumMember && isLiteralContextForType(<Expression>node, propType)) {
-                propType = getDeclaredTypeOfSymbol(prop);
-            }
+            const propType = getTypeOfSymbol(prop);
 
             // Only compute control flow type if this is a property access expression that isn't an
             // assignment target, and the referenced property was declared as a variable, property,
@@ -11294,7 +11318,7 @@ namespace ts {
 
         // Instantiate a generic signature in the context of a non-generic signature (section 3.8.5 in TypeScript spec)
         function instantiateSignatureInContextOf(signature: Signature, contextualSignature: Signature, contextualMapper: TypeMapper): Signature {
-            const context = createInferenceContext(signature.typeParameters, /*inferUnionTypes*/ true);
+            const context = createInferenceContext(signature, /*inferUnionTypes*/ true);
             forEachMatchingParameterType(contextualSignature, signature, (source, target) => {
                 // Type parameters from outer context referenced by source type are fixed by instantiation of the source type
                 inferTypes(context, instantiateType(source, contextualMapper), target);
@@ -11950,7 +11974,7 @@ namespace ts {
                     let candidate: Signature;
                     let typeArgumentsAreValid: boolean;
                     const inferenceContext = originalCandidate.typeParameters
-                        ? createInferenceContext(originalCandidate.typeParameters, /*inferUnionTypes*/ false)
+                        ? createInferenceContext(originalCandidate, /*inferUnionTypes*/ false)
                         : undefined;
 
                     while (true) {
@@ -12381,7 +12405,7 @@ namespace ts {
         }
 
         function checkAssertion(node: AssertionExpression) {
-            const exprType = getRegularTypeOfObjectLiteral(checkExpression(node.expression));
+            const exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(checkExpression(node.expression)));
 
             checkSourceElement(node.type);
             const targetType = getTypeFromTypeNode(node.type);
@@ -12441,7 +12465,7 @@ namespace ts {
         function assignBindingElementTypes(node: VariableLikeDeclaration) {
             if (isBindingPattern(node.name)) {
                 for (const element of (<BindingPattern>node.name).elements) {
-                    if (element.kind !== SyntaxKind.OmittedExpression) {
+                    if (!isOmittedExpression(element)) {
                         if (element.name.kind === SyntaxKind.Identifier) {
                             getSymbolLinks(getSymbolOfNode(element)).type = getTypeForBindingElement(element);
                         }
@@ -12571,20 +12595,8 @@ namespace ts {
                         return isAsync ? createPromiseReturnType(func, voidType) : voidType;
                     }
                 }
-                // When yield/return statements are contextually typed we allow the return type to be a union type.
-                // Otherwise we require the yield/return expressions to have a best common supertype.
-                type = contextualSignature ? getUnionType(types, /*subtypeReduction*/ true) : getCommonSupertype(types);
-                if (!type) {
-                    if (funcIsGenerator) {
-                        error(func, Diagnostics.No_best_common_type_exists_among_yield_expressions);
-                        return createIterableIteratorType(unknownType);
-                    }
-                    else {
-                        error(func, Diagnostics.No_best_common_type_exists_among_return_expressions);
-                        // Defer to unioning the return types so we get a) downstream errors earlier and b) better Salsa experience
-                        return isAsync ? createPromiseReturnType(func, getUnionType(types, /*subtypeReduction*/ true)) : getUnionType(types, /*subtypeReduction*/ true);
-                    }
-                }
+                // Return a union of the return expression types.
+                type = getUnionType(types, /*subtypeReduction*/ true);
 
                 if (funcIsGenerator) {
                     type = createIterableIteratorType(type);
@@ -12593,6 +12605,9 @@ namespace ts {
             if (!contextualSignature) {
                 reportErrorsFromWidening(func, type);
             }
+            if (isUnitType(type) && !(contextualSignature && isLiteralContextualType(getReturnTypeOfSignature(contextualSignature)))) {
+                type = getBaseTypeOfLiteralType(type);
+            }
 
             const widenedType = getWidenedType(type);
             // From within an async function you can return either a non-promise value or a promise. Any
@@ -12628,7 +12643,7 @@ namespace ts {
                 return false;
             }
             const type = checkExpression(node.expression);
-            if (!isUnitUnionType(type)) {
+            if (!isLiteralType(type)) {
                 return false;
             }
             const switchTypes = getSwitchClauseTypes(node);
@@ -12971,7 +12986,7 @@ namespace ts {
 
         function checkPrefixUnaryExpression(node: PrefixUnaryExpression): Type {
             const operandType = checkExpression(node.operand);
-            if (node.operator === SyntaxKind.MinusToken && node.operand.kind === SyntaxKind.NumericLiteral && isLiteralContextForType(node, numberType)) {
+            if (node.operator === SyntaxKind.MinusToken && node.operand.kind === SyntaxKind.NumericLiteral) {
                 return getLiteralTypeForText(TypeFlags.NumberLiteral, "" + -(<LiteralExpression>node.operand).text);
             }
             switch (node.operator) {
@@ -13371,11 +13386,11 @@ namespace ts {
                 case SyntaxKind.ExclamationEqualsToken:
                 case SyntaxKind.EqualsEqualsEqualsToken:
                 case SyntaxKind.ExclamationEqualsEqualsToken:
-                    const leftIsUnit = isUnitUnionType(leftType);
-                    const rightIsUnit = isUnitUnionType(rightType);
-                    if (!leftIsUnit || !rightIsUnit) {
-                        leftType = leftIsUnit ? getBaseTypeOfUnitType(leftType) : leftType;
-                        rightType = rightIsUnit ? getBaseTypeOfUnitType(rightType) : rightType;
+                    const leftIsLiteral = isLiteralType(leftType);
+                    const rightIsLiteral = isLiteralType(rightType);
+                    if (!leftIsLiteral || !rightIsLiteral) {
+                        leftType = leftIsLiteral ? getBaseTypeOfLiteralType(leftType) : leftType;
+                        rightType = rightIsLiteral ? getBaseTypeOfLiteralType(rightType) : rightType;
                     }
                     if (!isTypeEqualityComparableTo(leftType, rightType) && !isTypeEqualityComparableTo(rightType, leftType)) {
                         reportOperatorError();
@@ -13387,7 +13402,7 @@ namespace ts {
                     return checkInExpression(left, right, leftType, rightType);
                 case SyntaxKind.AmpersandAmpersandToken:
                     return getTypeFacts(leftType) & TypeFacts.Truthy ?
-                        includeFalsyTypes(rightType, getFalsyFlags(strictNullChecks ? leftType : getBaseTypeOfUnitType(rightType))) :
+                        includeFalsyTypes(rightType, getFalsyFlags(strictNullChecks ? leftType : getBaseTypeOfLiteralType(rightType))) :
                         leftType;
                 case SyntaxKind.BarBarToken:
                     return getTypeFacts(leftType) & TypeFacts.Falsy ?
@@ -13521,64 +13536,18 @@ namespace ts {
             return getBestChoiceType(type1, type2);
         }
 
-        function typeContainsLiteralFromEnum(type: Type, enumType: EnumType) {
-            if (type.flags & TypeFlags.Union) {
-                for (const t of (<UnionType>type).types) {
-                    if (t.flags & TypeFlags.EnumLiteral && (<EnumLiteralType>t).baseType === enumType) {
-                        return true;
-                    }
-                }
-            }
-            if (type.flags & TypeFlags.EnumLiteral) {
-                return (<EnumLiteralType>type).baseType === enumType;
-            }
-            return false;
-        }
-
-        function isLiteralContextForType(node: Expression, type: Type) {
-            if (isLiteralTypeLocation(node)) {
-                return true;
-            }
-            let contextualType = getContextualType(node);
-            if (contextualType) {
-                if (contextualType.flags & TypeFlags.TypeParameter) {
-                    const apparentType = getApparentTypeOfTypeParameter(<TypeParameter>contextualType);
-                    // If the type parameter is constrained to the base primitive type we're checking for,
-                    // consider this a literal context. For example, given a type parameter 'T extends string',
-                    // this causes us to infer string literal types for T.
-                    if (type === apparentType) {
-                        return true;
-                    }
-                    contextualType = apparentType;
-                }
-                if (type.flags & TypeFlags.String) {
-                    return maybeTypeOfKind(contextualType, TypeFlags.StringLiteral);
-                }
-                if (type.flags & TypeFlags.Number) {
-                    return maybeTypeOfKind(contextualType, (TypeFlags.NumberLiteral | TypeFlags.EnumLiteral));
-                }
-                if (type.flags & TypeFlags.Boolean) {
-                    return maybeTypeOfKind(contextualType, TypeFlags.BooleanLiteral) && !isTypeAssignableTo(booleanType, contextualType);
-                }
-                if (type.flags & TypeFlags.Enum) {
-                    return typeContainsLiteralFromEnum(contextualType, <EnumType>type);
-                }
-            }
-            return false;
-        }
-
         function checkLiteralExpression(node: Expression): Type {
             if (node.kind === SyntaxKind.NumericLiteral) {
                 checkGrammarNumericLiteral(<NumericLiteral>node);
             }
             switch (node.kind) {
                 case SyntaxKind.StringLiteral:
-                    return isLiteralContextForType(node, stringType) ? getLiteralTypeForText(TypeFlags.StringLiteral, (<LiteralExpression>node).text) : stringType;
+                    return getLiteralTypeForText(TypeFlags.StringLiteral, (<LiteralExpression>node).text);
                 case SyntaxKind.NumericLiteral:
-                    return isLiteralContextForType(node, numberType) ? getLiteralTypeForText(TypeFlags.NumberLiteral, (<LiteralExpression>node).text) : numberType;
+                    return getLiteralTypeForText(TypeFlags.NumberLiteral, (<LiteralExpression>node).text);
                 case SyntaxKind.TrueKeyword:
                 case SyntaxKind.FalseKeyword:
-                    return isLiteralContextForType(node, booleanType) ? node.kind === SyntaxKind.TrueKeyword ? trueType : falseType : booleanType;
+                    return node.kind === SyntaxKind.TrueKeyword ? trueType : falseType;
             }
         }
 
@@ -13617,6 +13586,28 @@ namespace ts {
             return links.resolvedType;
         }
 
+        function isLiteralContextualType(contextualType: Type) {
+            if (contextualType) {
+                if (contextualType.flags & TypeFlags.TypeParameter) {
+                    const apparentType = getApparentTypeOfTypeParameter(<TypeParameter>contextualType);
+                    // If the type parameter is constrained to the base primitive type we're checking for,
+                    // consider this a literal context. For example, given a type parameter 'T extends string',
+                    // this causes us to infer string literal types for T.
+                    if (apparentType.flags & (TypeFlags.String | TypeFlags.Number | TypeFlags.Boolean | TypeFlags.Enum)) {
+                        return true;
+                    }
+                    contextualType = apparentType;
+                }
+                return maybeTypeOfKind(contextualType, TypeFlags.Literal);
+            }
+            return false;
+        }
+
+        function checkExpressionForMutableLocation(node: Expression, contextualMapper?: TypeMapper): Type {
+            const type = checkExpression(node, contextualMapper);
+            return isLiteralContextualType(getContextualType(node)) ? type : getBaseTypeOfLiteralType(type);
+        }
+
         function checkPropertyAssignment(node: PropertyAssignment, contextualMapper?: TypeMapper): Type {
             // Do not use hasDynamicName here, because that returns false for well known symbols.
             // We want to perform checkComputedPropertyName for all computed properties, including
@@ -13625,7 +13616,7 @@ namespace ts {
                 checkComputedPropertyName(<ComputedPropertyName>node.name);
             }
 
-            return checkExpression((<PropertyAssignment>node).initializer, contextualMapper);
+            return checkExpressionForMutableLocation((<PropertyAssignment>node).initializer, contextualMapper);
         }
 
         function checkObjectLiteralMethod(node: MethodDeclaration, contextualMapper?: TypeMapper): Type {
@@ -13917,7 +13908,12 @@ namespace ts {
             pattern: BindingPattern,
             predicateVariableNode: Node,
             predicateVariableName: string) {
-            for (const { name } of pattern.elements) {
+            for (const element of pattern.elements) {
+                if (isOmittedExpression(element)) {
+                    continue;
+                }
+
+                const name = element.name;
                 if (name.kind === SyntaxKind.Identifier &&
                     (<Identifier>name).text === predicateVariableName) {
                     error(predicateVariableNode,
@@ -18393,8 +18389,8 @@ namespace ts {
 
         function moduleExportsSomeValue(moduleReferenceExpression: Expression): boolean {
             let moduleSymbol = resolveExternalModuleName(moduleReferenceExpression.parent, moduleReferenceExpression);
-            if (!moduleSymbol) {
-                // module not found - be conservative
+            if (!moduleSymbol || isShorthandAmbientModuleSymbol(moduleSymbol)) {
+                // If the module is not found or is shorthand, assume that it may export a value.
                 return true;
             }
 
@@ -20027,7 +20023,7 @@ namespace ts {
             else {
                 const elements = (<BindingPattern>name).elements;
                 for (const element of elements) {
-                    if (element.kind !== SyntaxKind.OmittedExpression) {
+                    if (!isOmittedExpression(element)) {
                         checkGrammarNameInLetOrConstDeclarations(element.name);
                     }
                 }

src/compiler/diagnosticMessages.json

@@ -1063,10 +1063,6 @@
         "category": "Error",
         "code": 2353
     },
-    "No best common type exists among return expressions.": {
-        "category": "Error",
-        "code": 2354
-    },
     "A function whose declared type is neither 'void' nor 'any' must return a value.": {
         "category": "Error",
         "code": 2355
@@ -1631,10 +1627,6 @@
         "category": "Error",
         "code": 2503
     },
-    "No best common type exists among yield expressions.": {
-        "category": "Error",
-        "code": 2504
-    },
     "A generator cannot have a 'void' type annotation.": {
         "category": "Error",
         "code": 2505

src/compiler/emitter.ts

@@ -554,9 +554,9 @@ const _super = (function (geti, seti) {
 
                 // Binding patterns
                 case SyntaxKind.ObjectBindingPattern:
-                    return emitObjectBindingPattern(<BindingPattern>node);
+                    return emitObjectBindingPattern(<ObjectBindingPattern>node);
                 case SyntaxKind.ArrayBindingPattern:
-                    return emitArrayBindingPattern(<BindingPattern>node);
+                    return emitArrayBindingPattern(<ArrayBindingPattern>node);
                 case SyntaxKind.BindingElement:
                     return emitBindingElement(<BindingElement>node);
 
@@ -2030,7 +2030,7 @@ const _super = (function (geti, seti) {
                 emitTrailingCommentsOfPosition(commentRange.pos);
             }
 
-            emitExpression(node.initializer);
+            emitExpression(initializer);
         }
 
         function emitShorthandPropertyAssignment(node: ShorthandPropertyAssignment) {

src/compiler/factory.ts

@@ -368,13 +368,13 @@ namespace ts {
         return node;
     }
 
-    export function createArrayBindingPattern(elements: BindingElement[], location?: TextRange) {
+    export function createArrayBindingPattern(elements: ArrayBindingElement[], location?: TextRange) {
         const node = <ArrayBindingPattern>createNode(SyntaxKind.ArrayBindingPattern, location);
         node.elements = createNodeArray(elements);
         return node;
     }
 
-    export function updateArrayBindingPattern(node: ArrayBindingPattern, elements: BindingElement[]) {
+    export function updateArrayBindingPattern(node: ArrayBindingPattern, elements: ArrayBindingElement[]) {
         if (node.elements !== elements) {
             return updateNode(createArrayBindingPattern(elements, node), node);
         }

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;
@@ -4811,9 +4815,9 @@ namespace ts {
 
         // DECLARATIONS
 
-        function parseArrayBindingElement(): BindingElement {
+        function parseArrayBindingElement(): ArrayBindingElement {
             if (token() === SyntaxKind.CommaToken) {
-                return <BindingElement>createNode(SyntaxKind.OmittedExpression);
+                return <OmittedExpression>createNode(SyntaxKind.OmittedExpression);
             }
             const node = <BindingElement>createNode(SyntaxKind.BindingElement);
             node.dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken);
@@ -4838,16 +4842,16 @@ namespace ts {
             return finishNode(node);
         }
 
-        function parseObjectBindingPattern(): BindingPattern {
-            const node = <BindingPattern>createNode(SyntaxKind.ObjectBindingPattern);
+        function parseObjectBindingPattern(): ObjectBindingPattern {
+            const node = <ObjectBindingPattern>createNode(SyntaxKind.ObjectBindingPattern);
             parseExpected(SyntaxKind.OpenBraceToken);
             node.elements = parseDelimitedList(ParsingContext.ObjectBindingElements, parseObjectBindingElement);
             parseExpected(SyntaxKind.CloseBraceToken);
             return finishNode(node);
         }
 
-        function parseArrayBindingPattern(): BindingPattern {
-            const node = <BindingPattern>createNode(SyntaxKind.ArrayBindingPattern);
+        function parseArrayBindingPattern(): ArrayBindingPattern {
+            const node = <ArrayBindingPattern>createNode(SyntaxKind.ArrayBindingPattern);
             parseExpected(SyntaxKind.OpenBracketToken);
             node.elements = parseDelimitedList(ParsingContext.ArrayBindingElements, parseArrayBindingElement);
             parseExpected(SyntaxKind.CloseBracketToken);

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/destructuring.ts

@@ -326,12 +326,15 @@ namespace ts {
                 }
                 for (let i = 0; i < numElements; i++) {
                     const element = elements[i];
-                    if (name.kind === SyntaxKind.ObjectBindingPattern) {
+                    if (isOmittedExpression(element)) {
+                        continue;
+                    }
+                    else if (name.kind === SyntaxKind.ObjectBindingPattern) {
                         // Rewrite element to a declaration with an initializer that fetches property
                         const propName = element.propertyName || <Identifier>element.name;
                         emitBindingElement(element, createDestructuringPropertyAccess(value, propName));
                     }
-                    else if (element.kind !== SyntaxKind.OmittedExpression) {
+                    else {
                         if (!element.dotDotDotToken) {
                             // Rewrite element to a declaration that accesses array element at index i
                             emitBindingElement(element, createElementAccess(value, i));

src/compiler/transformers/es6.ts

@@ -1945,7 +1945,9 @@ namespace ts {
                 }
                 else {
                     for (const element of (<BindingPattern>node).elements) {
-                        visit(element.name);
+                        if (!isOmittedExpression(element)) {
+                            visit(element.name);
+                        }
                     }
                 }
             }
@@ -2289,7 +2291,9 @@ namespace ts {
             const name = decl.name;
             if (isBindingPattern(name)) {
                 for (const element of name.elements) {
-                    processLoopVariableDeclaration(element, loopParameters, loopOutParameters);
+                    if (!isOmittedExpression(element)) {
+                        processLoopVariableDeclaration(element, loopParameters, loopOutParameters);
+                    }
                 }
             }
             else {

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/compiler/transformers/module/module.ts

@@ -660,7 +660,9 @@ namespace ts {
         function addExportMemberAssignmentsForBindingName(resultStatements: Statement[], name: BindingName): void {
             if (isBindingPattern(name)) {
                 for (const element of name.elements) {
-                    addExportMemberAssignmentsForBindingName(resultStatements, element.name);
+                    if (!isOmittedExpression(element)) {
+                        addExportMemberAssignmentsForBindingName(resultStatements, element.name);
+                    }
                 }
             }
             else {

src/compiler/transformers/module/system.ts

@@ -1368,7 +1368,11 @@ namespace ts {
             exportedFunctionDeclarations.push(createDeclarationExport(node));
         }
 
-        function hoistBindingElement(node: VariableDeclaration | BindingElement, isExported: boolean): void {
+        function hoistBindingElement(node: VariableDeclaration | ArrayBindingElement, isExported: boolean): void {
+            if (isOmittedExpression(node)) {
+                return;
+            }
+
             const name = node.name;
             if (isIdentifier(name)) {
                 hoistVariableDeclaration(getSynthesizedClone(name));
@@ -1381,11 +1385,11 @@ namespace ts {
             }
         }
 
-        function hoistExportedBindingElement(node: VariableDeclaration | BindingElement) {
+        function hoistExportedBindingElement(node: VariableDeclaration | ArrayBindingElement) {
             hoistBindingElement(node, /*isExported*/ true);
         }
 
-        function hoistNonExportedBindingElement(node: VariableDeclaration | BindingElement) {
+        function hoistNonExportedBindingElement(node: VariableDeclaration | ArrayBindingElement) {
             hoistBindingElement(node, /*isExported*/ false);
         }
 

src/compiler/transformers/ts.ts

@@ -2187,7 +2187,7 @@ namespace ts {
          *
          * @param node The function expression node.
          */
-        function visitFunctionExpression(node: FunctionExpression) {
+        function visitFunctionExpression(node: FunctionExpression): Expression {
             if (nodeIsMissing(node.body)) {
                 return createOmittedExpression();
             }

src/compiler/types.ts

@@ -688,14 +688,20 @@ namespace ts {
     }
 
     export interface BindingPattern extends Node {
-        elements: NodeArray<BindingElement>;
+        elements: NodeArray<BindingElement | ArrayBindingElement>;
     }
 
     // @kind(SyntaxKind.ObjectBindingPattern)
-    export interface ObjectBindingPattern extends BindingPattern { }
+    export interface ObjectBindingPattern extends BindingPattern {
+        elements: NodeArray<BindingElement>;
+    }
+
+    export type ArrayBindingElement = BindingElement | OmittedExpression;
 
     // @kind(SyntaxKind.ArrayBindingPattern)
-    export interface ArrayBindingPattern extends BindingPattern { }
+    export interface ArrayBindingPattern extends BindingPattern {
+        elements: NodeArray<ArrayBindingElement>;
+    }
 
     /**
      * Several node kinds share function-like features such as a signature,
@@ -868,7 +874,9 @@ namespace ts {
     }
 
     // @kind(SyntaxKind.OmittedExpression)
-    export interface OmittedExpression extends Expression { }
+    export interface OmittedExpression extends Expression {
+        _omittedExpressionBrand: any;
+    }
 
     // Represents an expression that is elided as part of a transformation to emit comments on a
     // not-emitted node. The 'expression' property of a NotEmittedExpression should be emitted.
@@ -2585,13 +2593,14 @@ namespace ts {
     export interface TypeInferences {
         primary: Type[];    // Inferences made directly to a type parameter
         secondary: Type[];  // Inferences made to a type parameter in a union type
+        topLevel: boolean;  // True if all inferences were made from top-level (not nested in object type) locations
         isFixed: boolean;   // Whether the type parameter is fixed, as defined in section 4.12.2 of the TypeScript spec
                             // If a type parameter is fixed, no more inferences can be made for the type parameter
     }
 
     /* @internal */
     export interface InferenceContext {
-        typeParameters: TypeParameter[];    // Type parameters for which inferences are made
+        signature: Signature;               // Generic signature for which inferences are made
         inferUnionTypes: boolean;           // Infer union types for disjoint candidates (otherwise undefinedType)
         inferences: TypeInferences[];       // Inferences made for each type parameter
         inferredTypes: Type[];              // Inferred type for each type parameter

src/compiler/utilities.ts

@@ -414,7 +414,11 @@ namespace ts {
             ((<ModuleDeclaration>node).name.kind === SyntaxKind.StringLiteral || isGlobalScopeAugmentation(<ModuleDeclaration>node));
     }
 
-    export function isShorthandAmbientModule(node: Node): boolean {
+    export function isShorthandAmbientModuleSymbol(moduleSymbol: Symbol): boolean {
+        return isShorthandAmbientModule(moduleSymbol.valueDeclaration);
+    }
+
+    function isShorthandAmbientModule(node: Node): boolean {
         // The only kind of module that can be missing a body is a shorthand ambient module.
         return node.kind === SyntaxKind.ModuleDeclaration && (!(<ModuleDeclaration>node).body);
     }
@@ -3701,6 +3705,12 @@ namespace ts {
         return node.kind === SyntaxKind.BindingElement;
     }
 
+    export function isArrayBindingElement(node: Node): node is ArrayBindingElement {
+        const kind = node.kind;
+        return kind === SyntaxKind.BindingElement
+            || kind === SyntaxKind.OmittedExpression;
+    }
+
     // Expression
 
     export function isPropertyAccessExpression(node: Node): node is PropertyAccessExpression {
@@ -3817,6 +3827,10 @@ namespace ts {
             || isPartiallyEmittedExpression(node);
     }
 
+    export function isOmittedExpression(node: Node): node is OmittedExpression {
+        return node.kind === SyntaxKind.OmittedExpression;
+    }
+
     // Misc
 
     export function isTemplateSpan(node: Node): node is TemplateSpan {

src/compiler/visitor.ts

@@ -757,7 +757,7 @@ namespace ts {
 
             case SyntaxKind.ArrayBindingPattern:
                 return updateArrayBindingPattern(<ArrayBindingPattern>node,
-                    visitNodes((<ArrayBindingPattern>node).elements, visitor, isBindingElement));
+                    visitNodes((<ArrayBindingPattern>node).elements, visitor, isArrayBindingElement));
 
             case SyntaxKind.BindingElement:
                 return updateBindingElement(<BindingElement>node,

src/harness/fourslash.ts

@@ -954,26 +954,20 @@ namespace FourSlash {
             assert.equal(actual, expected);
         }
 
-        public verifyQuickInfoString(negative: boolean, expectedText?: string, expectedDocumentation?: string) {
+        public verifyQuickInfoString(negative: boolean, expectedText: string, expectedDocumentation?: string) {
             const actualQuickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition);
             const actualQuickInfoText = actualQuickInfo ? ts.displayPartsToString(actualQuickInfo.displayParts) : "";
             const actualQuickInfoDocumentation = actualQuickInfo ? ts.displayPartsToString(actualQuickInfo.documentation) : "";
 
             if (negative) {
-                if (expectedText !== undefined) {
-                    assert.notEqual(actualQuickInfoText, expectedText, this.messageAtLastKnownMarker("quick info text"));
-                }
-                // TODO: should be '==='?
-                if (expectedDocumentation != undefined) {
+                assert.notEqual(actualQuickInfoText, expectedText, this.messageAtLastKnownMarker("quick info text"));
+                if (expectedDocumentation !== undefined) {
                     assert.notEqual(actualQuickInfoDocumentation, expectedDocumentation, this.messageAtLastKnownMarker("quick info doc comment"));
                 }
             }
             else {
-                if (expectedText !== undefined) {
-                    assert.equal(actualQuickInfoText, expectedText, this.messageAtLastKnownMarker("quick info text"));
-                }
-                // TODO: should be '==='?
-                if (expectedDocumentation != undefined) {
+                assert.equal(actualQuickInfoText, expectedText, this.messageAtLastKnownMarker("quick info text"));
+                if (expectedDocumentation !== undefined) {
                     assert.equal(actualQuickInfoDocumentation, expectedDocumentation, this.assertionMessageAtLastKnownMarker("quick info doc"));
                 }
             }
@@ -1294,6 +1288,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,
+                        quickInfo: this.languageService.getQuickInfoAtPosition(marker.fileName, marker.position)
+                    }))
+                ));
+        }
+
         public printBreakpointLocation(pos: number) {
             Harness.IO.log("\n**Pos: " + pos + " " + this.spanInfoToString(pos, this.getBreakpointStatementLocation(pos), "  "));
         }
@@ -2953,7 +2963,7 @@ namespace FourSlashInterface {
             this.state.verifyErrorExistsAfterMarker(markerName, !this.negative, /*after*/ false);
         }
 
-        public quickInfoIs(expectedText?: string, expectedDocumentation?: string) {
+        public quickInfoIs(expectedText: string, expectedDocumentation?: string) {
             this.state.verifyQuickInfoString(this.negative, expectedText, expectedDocumentation);
         }
 
@@ -3103,6 +3113,10 @@ namespace FourSlashInterface {
             this.state.baselineGetEmitOutput();
         }
 
+        public baselineQuickInfo() {
+            this.state.baselineQuickInfo();
+        }
+
         public nameOrDottedNameSpanTextIs(text: string) {
             this.state.verifyCurrentNameOrDottedNameSpanText(text);
         }

src/harness/harnessLanguageService.ts

@@ -408,6 +408,9 @@ namespace Harness.LanguageService {
         getCompletionEntryDetails(fileName: string, position: number, entryName: string): ts.CompletionEntryDetails {
             return unwrapJSONCallResult(this.shim.getCompletionEntryDetails(fileName, position, entryName));
         }
+        getCompletionEntrySymbol(fileName: string, position: number, entryName: string): ts.Symbol {
+            throw new Error("getCompletionEntrySymbol not implemented across the shim layer.");
+        }
         getQuickInfoAtPosition(fileName: string, position: number): ts.QuickInfo {
             return unwrapJSONCallResult(this.shim.getQuickInfoAtPosition(fileName, position));
         }

src/server/client.ts

@@ -246,6 +246,10 @@ namespace ts.server {
             return response.body[0];
         }
 
+        getCompletionEntrySymbol(fileName: string, position: number, entryName: string): Symbol {
+            throw new Error("Not Implemented Yet.");
+        }
+
         getNavigateToItems(searchValue: string): NavigateToItem[] {
             const args: protocol.NavtoRequestArgs = {
                 searchValue,

src/services/classifier.ts

@@ -0,0 +1,985 @@
+namespace ts {
+    /// 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
+        };
+    }
+
+    /* @internal */
+    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();
+        }
+    }
+
+    /* @internal */
+    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;
+    }
+
+    /* @internal */
+    export function getSyntacticClassifications(cancellationToken: CancellationToken, sourceFile: SourceFile, span: TextSpan): ClassifiedSpan[] {
+        return convertClassifications(getEncodedSyntacticClassifications(cancellationToken, sourceFile, span));
+    }
+
+    /* @internal */
+    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/documentRegistry.ts

@@ -0,0 +1,240 @@
+namespace ts {
+    /**
+      * The document registry represents a store of SourceFile objects that can be shared between
+      * multiple LanguageService instances. A LanguageService instance holds on the SourceFile (AST)
+      * of files in the context.
+      * SourceFile objects account for most of the memory usage by the language service. Sharing
+      * the same DocumentRegistry instance between different instances of LanguageService allow
+      * for more efficient memory utilization since all projects will share at least the library
+      * file (lib.d.ts).
+      *
+      * A more advanced use of the document registry is to serialize sourceFile objects to disk
+      * and re-hydrate them when needed.
+      *
+      * To create a default DocumentRegistry, use createDocumentRegistry to create one, and pass it
+      * to all subsequent createLanguageService calls.
+      */
+    export interface DocumentRegistry {
+        /**
+          * Request a stored SourceFile with a given fileName and compilationSettings.
+          * The first call to acquire will call createLanguageServiceSourceFile to generate
+          * the SourceFile if was not found in the registry.
+          *
+          * @param fileName The name of the file requested
+          * @param compilationSettings Some compilation settings like target affects the
+          * shape of a the resulting SourceFile. This allows the DocumentRegistry to store
+          * multiple copies of the same file for different compilation settings.
+          * @parm scriptSnapshot Text of the file. Only used if the file was not found
+          * in the registry and a new one was created.
+          * @parm version Current version of the file. Only used if the file was not found
+          * in the registry and a new one was created.
+          */
+        acquireDocument(
+            fileName: string,
+            compilationSettings: CompilerOptions,
+            scriptSnapshot: IScriptSnapshot,
+            version: string,
+            scriptKind?: ScriptKind): SourceFile;
+
+        acquireDocumentWithKey(
+            fileName: string,
+            path: Path,
+            compilationSettings: CompilerOptions,
+            key: DocumentRegistryBucketKey,
+            scriptSnapshot: IScriptSnapshot,
+            version: string,
+            scriptKind?: ScriptKind): SourceFile;
+
+        /**
+          * Request an updated version of an already existing SourceFile with a given fileName
+          * and compilationSettings. The update will in-turn call updateLanguageServiceSourceFile
+          * to get an updated SourceFile.
+          *
+          * @param fileName The name of the file requested
+          * @param compilationSettings Some compilation settings like target affects the
+          * shape of a the resulting SourceFile. This allows the DocumentRegistry to store
+          * multiple copies of the same file for different compilation settings.
+          * @param scriptSnapshot Text of the file.
+          * @param version Current version of the file.
+          */
+        updateDocument(
+            fileName: string,
+            compilationSettings: CompilerOptions,
+            scriptSnapshot: IScriptSnapshot,
+            version: string,
+            scriptKind?: ScriptKind): SourceFile;
+
+        updateDocumentWithKey(
+            fileName: string,
+            path: Path,
+            compilationSettings: CompilerOptions,
+            key: DocumentRegistryBucketKey,
+            scriptSnapshot: IScriptSnapshot,
+            version: string,
+            scriptKind?: ScriptKind): SourceFile;
+
+        getKeyForCompilationSettings(settings: CompilerOptions): DocumentRegistryBucketKey;
+        /**
+          * Informs the DocumentRegistry that a file is not needed any longer.
+          *
+          * Note: It is not allowed to call release on a SourceFile that was not acquired from
+          * this registry originally.
+          *
+          * @param fileName The name of the file to be released
+          * @param compilationSettings The compilation settings used to acquire the file
+          */
+        releaseDocument(fileName: string, compilationSettings: CompilerOptions): void;
+
+        releaseDocumentWithKey(path: Path, key: DocumentRegistryBucketKey): void;
+
+        reportStats(): string;
+    }
+
+    export type DocumentRegistryBucketKey = string & { __bucketKey: any };
+
+    interface DocumentRegistryEntry {
+        sourceFile: SourceFile;
+
+        // The number of language services that this source file is referenced in.   When no more
+        // language services are referencing the file, then the file can be removed from the
+        // registry.
+        languageServiceRefCount: number;
+        owners: string[];
+    }
+
+    export function createDocumentRegistry(useCaseSensitiveFileNames?: boolean, currentDirectory = ""): DocumentRegistry {
+        // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have
+        // for those settings.
+        const buckets = createMap<FileMap<DocumentRegistryEntry>>();
+        const getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames);
+
+        function getKeyForCompilationSettings(settings: CompilerOptions): DocumentRegistryBucketKey {
+            return <DocumentRegistryBucketKey>`_${settings.target}|${settings.module}|${settings.noResolve}|${settings.jsx}|${settings.allowJs}|${settings.baseUrl}|${JSON.stringify(settings.typeRoots)}|${JSON.stringify(settings.rootDirs)}|${JSON.stringify(settings.paths)}`;
+        }
+
+        function getBucketForCompilationSettings(key: DocumentRegistryBucketKey, createIfMissing: boolean): FileMap<DocumentRegistryEntry> {
+            let bucket = buckets[key];
+            if (!bucket && createIfMissing) {
+                buckets[key] = bucket = createFileMap<DocumentRegistryEntry>();
+            }
+            return bucket;
+        }
+
+        function reportStats() {
+            const bucketInfoArray = Object.keys(buckets).filter(name => name && name.charAt(0) === "_").map(name => {
+                const entries = buckets[name];
+                const sourceFiles: { name: string; refCount: number; references: string[]; }[] = [];
+                entries.forEachValue((key, entry) => {
+                    sourceFiles.push({
+                        name: key,
+                        refCount: entry.languageServiceRefCount,
+                        references: entry.owners.slice(0)
+                    });
+                });
+                sourceFiles.sort((x, y) => y.refCount - x.refCount);
+                return {
+                    bucket: name,
+                    sourceFiles
+                };
+            });
+            return JSON.stringify(bucketInfoArray, undefined, 2);
+        }
+
+        function acquireDocument(fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile {
+            const path = toPath(fileName, currentDirectory, getCanonicalFileName);
+            const key = getKeyForCompilationSettings(compilationSettings);
+            return acquireDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind);
+        }
+
+        function acquireDocumentWithKey(fileName: string, path: Path, compilationSettings: CompilerOptions, key: DocumentRegistryBucketKey, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile {
+            return acquireOrUpdateDocument(fileName, path, compilationSettings, key, scriptSnapshot, version, /*acquiring*/ true, scriptKind);
+        }
+
+        function updateDocument(fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile {
+            const path = toPath(fileName, currentDirectory, getCanonicalFileName);
+            const key = getKeyForCompilationSettings(compilationSettings);
+            return updateDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind);
+        }
+
+        function updateDocumentWithKey(fileName: string, path: Path, compilationSettings: CompilerOptions, key: DocumentRegistryBucketKey, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile {
+            return acquireOrUpdateDocument(fileName, path, compilationSettings, key, scriptSnapshot, version, /*acquiring*/ false, scriptKind);
+        }
+
+        function acquireOrUpdateDocument(
+            fileName: string,
+            path: Path,
+            compilationSettings: CompilerOptions,
+            key: DocumentRegistryBucketKey,
+            scriptSnapshot: IScriptSnapshot,
+            version: string,
+            acquiring: boolean,
+            scriptKind?: ScriptKind): SourceFile {
+
+            const bucket = getBucketForCompilationSettings(key, /*createIfMissing*/ true);
+            let entry = bucket.get(path);
+            if (!entry) {
+                Debug.assert(acquiring, "How could we be trying to update a document that the registry doesn't have?");
+
+                // Have never seen this file with these settings.  Create a new source file for it.
+                const sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, compilationSettings.target, version, /*setNodeParents*/ false, scriptKind);
+
+                entry = {
+                    sourceFile: sourceFile,
+                    languageServiceRefCount: 0,
+                    owners: []
+                };
+                bucket.set(path, entry);
+            }
+            else {
+                // We have an entry for this file.  However, it may be for a different version of
+                // the script snapshot.  If so, update it appropriately.  Otherwise, we can just
+                // return it as is.
+                if (entry.sourceFile.version !== version) {
+                    entry.sourceFile = updateLanguageServiceSourceFile(entry.sourceFile, scriptSnapshot, version,
+                        scriptSnapshot.getChangeRange(entry.sourceFile.scriptSnapshot));
+                }
+            }
+
+            // If we're acquiring, then this is the first time this LS is asking for this document.
+            // Increase our ref count so we know there's another LS using the document.  If we're
+            // not acquiring, then that means the LS is 'updating' the file instead, and that means
+            // it has already acquired the document previously.  As such, we do not need to increase
+            // the ref count.
+            if (acquiring) {
+                entry.languageServiceRefCount++;
+            }
+
+            return entry.sourceFile;
+        }
+
+        function releaseDocument(fileName: string, compilationSettings: CompilerOptions): void {
+            const path = toPath(fileName, currentDirectory, getCanonicalFileName);
+            const key = getKeyForCompilationSettings(compilationSettings);
+            return releaseDocumentWithKey(path, key);
+        }
+
+        function releaseDocumentWithKey(path: Path, key: DocumentRegistryBucketKey): void {
+            const bucket = getBucketForCompilationSettings(key, /*createIfMissing*/false);
+            Debug.assert(bucket !== undefined);
+
+            const entry = bucket.get(path);
+            entry.languageServiceRefCount--;
+
+            Debug.assert(entry.languageServiceRefCount >= 0);
+            if (entry.languageServiceRefCount === 0) {
+                bucket.remove(path);
+            }
+        }
+
+        return {
+            acquireDocument,
+            acquireDocumentWithKey,
+            updateDocument,
+            updateDocumentWithKey,
+            releaseDocument,
+            releaseDocumentWithKey,
+            reportStats,
+            getKeyForCompilationSettings
+        };
+    }
+}

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,359 @@
+namespace ts {
+    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/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,28 @@
         "../compiler/program.ts",
         "../compiler/commandLineParser.ts",
         "../compiler/diagnosticInformationMap.generated.ts",
+        "types.ts",
+        "utilities.ts",
         "breakpoints.ts",
+        "classifier.ts",
+        "completions.ts",
+        "documentHighlights.ts",
+        "documentRegistry.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/types.ts

@@ -194,6 +194,7 @@ namespace ts {
 
         getCompletionsAtPosition(fileName: string, position: number): CompletionInfo;
         getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails;
+        getCompletionEntrySymbol(fileName: string, position: number, entryName: string): Symbol;
 
         getQuickInfoAtPosition(fileName: string, position: number): QuickInfo;
 
@@ -575,99 +576,6 @@ namespace ts {
         getEncodedLexicalClassifications(text: string, endOfLineState: EndOfLineState, syntacticClassifierAbsent: boolean): Classifications;
     }
 
-    /**
-      * The document registry represents a store of SourceFile objects that can be shared between
-      * multiple LanguageService instances. A LanguageService instance holds on the SourceFile (AST)
-      * of files in the context.
-      * SourceFile objects account for most of the memory usage by the language service. Sharing
-      * the same DocumentRegistry instance between different instances of LanguageService allow
-      * for more efficient memory utilization since all projects will share at least the library
-      * file (lib.d.ts).
-      *
-      * A more advanced use of the document registry is to serialize sourceFile objects to disk
-      * and re-hydrate them when needed.
-      *
-      * To create a default DocumentRegistry, use createDocumentRegistry to create one, and pass it
-      * to all subsequent createLanguageService calls.
-      */
-    export interface DocumentRegistry {
-        /**
-          * Request a stored SourceFile with a given fileName and compilationSettings.
-          * The first call to acquire will call createLanguageServiceSourceFile to generate
-          * the SourceFile if was not found in the registry.
-          *
-          * @param fileName The name of the file requested
-          * @param compilationSettings Some compilation settings like target affects the
-          * shape of a the resulting SourceFile. This allows the DocumentRegistry to store
-          * multiple copies of the same file for different compilation settings.
-          * @parm scriptSnapshot Text of the file. Only used if the file was not found
-          * in the registry and a new one was created.
-          * @parm version Current version of the file. Only used if the file was not found
-          * in the registry and a new one was created.
-          */
-        acquireDocument(
-            fileName: string,
-            compilationSettings: CompilerOptions,
-            scriptSnapshot: IScriptSnapshot,
-            version: string,
-            scriptKind?: ScriptKind): SourceFile;
-
-        acquireDocumentWithKey(
-            fileName: string,
-            path: Path,
-            compilationSettings: CompilerOptions,
-            key: DocumentRegistryBucketKey,
-            scriptSnapshot: IScriptSnapshot,
-            version: string,
-            scriptKind?: ScriptKind): SourceFile;
-
-        /**
-          * Request an updated version of an already existing SourceFile with a given fileName
-          * and compilationSettings. The update will in-turn call updateLanguageServiceSourceFile
-          * to get an updated SourceFile.
-          *
-          * @param fileName The name of the file requested
-          * @param compilationSettings Some compilation settings like target affects the
-          * shape of a the resulting SourceFile. This allows the DocumentRegistry to store
-          * multiple copies of the same file for different compilation settings.
-          * @param scriptSnapshot Text of the file.
-          * @param version Current version of the file.
-          */
-        updateDocument(
-            fileName: string,
-            compilationSettings: CompilerOptions,
-            scriptSnapshot: IScriptSnapshot,
-            version: string,
-            scriptKind?: ScriptKind): SourceFile;
-
-        updateDocumentWithKey(
-            fileName: string,
-            path: Path,
-            compilationSettings: CompilerOptions,
-            key: DocumentRegistryBucketKey,
-            scriptSnapshot: IScriptSnapshot,
-            version: string,
-            scriptKind?: ScriptKind): SourceFile;
-
-        getKeyForCompilationSettings(settings: CompilerOptions): DocumentRegistryBucketKey;
-        /**
-          * Informs the DocumentRegistry that a file is not needed any longer.
-          *
-          * Note: It is not allowed to call release on a SourceFile that was not acquired from
-          * this registry originally.
-          *
-          * @param fileName The name of the file to be released
-          * @param compilationSettings The compilation settings used to acquire the file
-          */
-        releaseDocument(fileName: string, compilationSettings: CompilerOptions): void;
-
-        releaseDocumentWithKey(path: Path, key: DocumentRegistryBucketKey): void;
-
-        reportStats(): string;
-    }
-
-    export type DocumentRegistryBucketKey = string & { __bucketKey: any };
-
     // TODO: move these to enums
     export namespace ScriptElementKind {
         export const unknown = "";

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/AmbientModuleAndAmbientWithSameNameAndCommonRoot.types

@@ -56,6 +56,6 @@ var p = new A.Point(0, 0); // unexpected error here, bug 840000
 >A.Point : typeof A.Point
 >A : typeof A
 >Point : typeof A.Point
->0 : number
->0 : number
+>0 : 0
+>0 : 0
  

tests/baselines/reference/AmbientModuleAndNonAmbientClassWithSameNameAndCommonRoot.types

@@ -50,6 +50,6 @@ var p = new A.Point(0, 0); // unexpected error here, bug 840000
 >A.Point : typeof A.Point
 >A : typeof A
 >Point : typeof A.Point
->0 : number
->0 : number
+>0 : 0
+>0 : 0
 

tests/baselines/reference/AmbientModuleAndNonAmbientFunctionWithTheSameNameAndCommonRoot.types

@@ -15,9 +15,9 @@ function Point() {
     return { x: 0, y: 0 };
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 }
 
 === tests/cases/conformance/internalModules/DeclarationMerging/test.ts ===

tests/baselines/reference/ClassAndModuleThatMergeWithStaticFunctionAndNonExportedFunctionThatShareAName.types

@@ -11,9 +11,9 @@ class Point {
 >Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 }
 
 module Point {
@@ -21,7 +21,7 @@ module Point {
 
     function Origin() { return ""; }// not an error, since not exported
 >Origin : () => string
->"" : string
+>"" : ""
 }
 
 
@@ -40,9 +40,9 @@ module A {
 >Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
     }
 
     export module Point {
@@ -50,6 +50,6 @@ module A {
 
         function Origin() { return ""; }// not an error since not exported
 >Origin : () => string
->"" : string
+>"" : ""
     }
 }

tests/baselines/reference/ClassAndModuleThatMergeWithStaticVariableAndNonExportedVarThatShareAName.types

@@ -11,9 +11,9 @@ class Point {
 >Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 }
 
 module Point {
@@ -21,7 +21,7 @@ module Point {
 
     var Origin = ""; // not an error, since not exported
 >Origin : string
->"" : string
+>"" : ""
 }
 
 
@@ -40,9 +40,9 @@ module A {
 >Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
     }
 
     export module Point {
@@ -50,6 +50,6 @@ module A {
 
         var Origin = ""; // not an error since not exported
 >Origin : string
->"" : string
+>"" : ""
     }
 }

tests/baselines/reference/ClassDeclarationWithInvalidConstOnPropertyDeclaration2.types

@@ -7,5 +7,5 @@ class C {
 
     x = 10;
 >x : number
->10 : number
+>10 : 10
 }

tests/baselines/reference/ES3For-ofTypeCheck2.types

@@ -2,5 +2,5 @@
 for (var v of [true]) { }
 >v : boolean
 >[true] : boolean[]
->true : boolean
+>true : true
 

tests/baselines/reference/ES5For-of10.types

@@ -5,7 +5,7 @@ function foo() {
     return { x: 0 };
 >{ x: 0 } : { x: number; }
 >x : number
->0 : number
+>0 : 0
 }
 for (foo().x of []) {
 >foo().x : number

tests/baselines/reference/ES5For-of13.types

@@ -2,9 +2,9 @@
 for (let v of ['a', 'b', 'c']) {
 >v : string
 >['a', 'b', 'c'] : string[]
->'a' : string
->'b' : string
->'c' : string
+>'a' : "a"
+>'b' : "b"
+>'c' : "c"
 
     var x = v;
 >x : string

tests/baselines/reference/ES5For-of24.types

@@ -2,9 +2,9 @@
 var a = [1, 2, 3];
 >a : number[]
 >[1, 2, 3] : number[]
->1 : number
->2 : number
->3 : number
+>1 : 1
+>2 : 2
+>3 : 3
 
 for (var v of a) {
 >v : number
@@ -12,5 +12,5 @@ for (var v of a) {
 
     let a = 0;
 >a : number
->0 : number
+>0 : 0
 }

tests/baselines/reference/ES5For-of25.types

@@ -2,9 +2,9 @@
 var a = [1, 2, 3];
 >a : number[]
 >[1, 2, 3] : number[]
->1 : number
->2 : number
->3 : number
+>1 : 1
+>2 : 2
+>3 : 3
 
 for (var v of a) {
 >v : number

tests/baselines/reference/ES5For-of3.types

@@ -2,9 +2,9 @@
 for (var v of ['a', 'b', 'c'])
 >v : string
 >['a', 'b', 'c'] : string[]
->'a' : string
->'b' : string
->'c' : string
+>'a' : "a"
+>'b' : "b"
+>'c' : "c"
 
     var x = v;
 >x : string

tests/baselines/reference/ES5For-of30.errors.txt

@@ -1,6 +1,6 @@
 tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,6): error TS2461: Type 'string | number' is not an array type.
-tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,7): error TS2322: Type 'number' is not assignable to type 'string'.
-tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,14): error TS2322: Type 'string' is not assignable to type 'number'.
+tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,7): error TS2322: Type '1' is not assignable to type 'string'.
+tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,14): error TS2322: Type '""' is not assignable to type 'number'.
 
 
 ==== tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts (3 errors) ====
@@ -10,9 +10,9 @@ tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,14): error
          ~~~~~~~~~~~~~~~
 !!! error TS2461: Type 'string | number' is not an array type.
           ~
-!!! error TS2322: Type 'number' is not assignable to type 'string'.
+!!! error TS2322: Type '1' is not assignable to type 'string'.
                  ~
-!!! error TS2322: Type 'string' is not assignable to type 'number'.
+!!! error TS2322: Type '""' is not assignable to type 'number'.
         a;
         b;
     }

tests/baselines/reference/ES5For-of9.types

@@ -5,7 +5,7 @@ function foo() {
     return { x: 0 };
 >{ x: 0 } : { x: number; }
 >x : number
->0 : number
+>0 : 0
 }
 for (foo().x of []) {
 >foo().x : number

tests/baselines/reference/ES5For-ofTypeCheck1.types

@@ -1,5 +1,5 @@
 === tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck1.ts ===
 for (var v of "") { }
 >v : string
->"" : string
+>"" : ""
 

tests/baselines/reference/ES5For-ofTypeCheck12.errors.txt

@@ -1,7 +1,7 @@
-tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck12.ts(1,17): error TS2495: Type 'number' is not an array type or a string type.
+tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck12.ts(1,17): error TS2495: Type '0' is not an array type or a string type.
 
 
 ==== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck12.ts (1 errors) ====
     for (const v of 0) { }
                     ~
-!!! error TS2495: Type 'number' is not an array type or a string type.
+!!! error TS2495: Type '0' is not an array type or a string type.

tests/baselines/reference/ES5For-ofTypeCheck2.types

@@ -2,5 +2,5 @@
 for (var v of [true]) { }
 >v : boolean
 >[true] : boolean[]
->true : boolean
+>true : true
 

tests/baselines/reference/ES5For-ofTypeCheck3.types

@@ -2,8 +2,8 @@
 var tuple: [string, number] = ["", 0];
 >tuple : [string, number]
 >["", 0] : [string, number]
->"" : string
->0 : number
+>"" : ""
+>0 : 0
 
 for (var v of tuple) { }
 >v : string | number

tests/baselines/reference/ES5for-of32.types

@@ -3,13 +3,13 @@
 var array = [1,2,3];
 >array : number[]
 >[1,2,3] : number[]
->1 : number
->2 : number
->3 : number
+>1 : 1
+>2 : 2
+>3 : 3
 
 var sum = 0;
 >sum : number
->0 : number
+>0 : 0
 
 for (let num of array) {
 >num : number
@@ -24,9 +24,9 @@ for (let num of array) {
 >array = [4,5,6] : number[]
 >array : number[]
 >[4,5,6] : number[]
->4 : number
->5 : number
->6 : number
+>4 : 4
+>5 : 5
+>6 : 6
     }
     
     sum += num;

tests/baselines/reference/EnumAndModuleWithSameNameAndCommonRoot.types

@@ -3,8 +3,8 @@ enum enumdule {
 >enumdule : enumdule
 
     Red, Blue
->Red : enumdule
->Blue : enumdule
+>Red : enumdule.Red
+>Blue : enumdule.Blue
 }
 
 module enumdule {
@@ -25,9 +25,9 @@ var x: enumdule;
 
 var x = enumdule.Red;
 >x : enumdule
->enumdule.Red : enumdule
+>enumdule.Red : enumdule.Red
 >enumdule : typeof enumdule
->Red : enumdule
+>Red : enumdule.Red
 
 var y: { x: number; y: number };
 >y : { x: number; y: number; }
@@ -40,6 +40,6 @@ var y = new enumdule.Point(0, 0);
 >enumdule.Point : typeof enumdule.Point
 >enumdule : typeof enumdule
 >Point : typeof enumdule.Point
->0 : number
->0 : number
+>0 : 0
+>0 : 0
 

tests/baselines/reference/ExportClassWhichExtendsInterfaceWithInaccessibleType.types

@@ -31,7 +31,7 @@ module A {
 >Point : Point
 
             return 1;
->1 : number
+>1 : 1
         }
     }
 }

tests/baselines/reference/ExportClassWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types

@@ -17,9 +17,9 @@ module A {
 >Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 
     export class Point3d extends Point {
 >Point3d : Point3d
@@ -34,11 +34,11 @@ module A {
 >Point3d : Point3d
 >{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 >z : number
->0 : number
+>0 : 0
 
     export class Line<TPoint extends Point>{
 >Line : Line<TPoint>

tests/baselines/reference/ExportClassWithInaccessibleTypeInTypeParameterConstraint.types

@@ -17,9 +17,9 @@ module A {
 >Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 
     export class Point3d extends Point {
 >Point3d : Point3d
@@ -34,11 +34,11 @@ module A {
 >Point3d : Point3d
 >{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 >z : number
->0 : number
+>0 : 0
 
     export class Line<TPoint extends Point>{
 >Line : Line<TPoint>

tests/baselines/reference/ExportFunctionWithAccessibleTypesInParameterAndReturnTypeAnnotation.types

@@ -33,9 +33,9 @@ module A {
 >Line : typeof Line
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 >p : Point
     }
 }

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInParameterTypeAnnotation.types

@@ -33,9 +33,9 @@ module A {
 >Line : typeof Line
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 >p : Point
     }
 }

tests/baselines/reference/ExportFunctionWithInaccessibleTypesInReturnTypeAnnotation.types

@@ -33,9 +33,9 @@ module A {
 >Line : typeof Line
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 >p : Point
     }
 }

tests/baselines/reference/ExportInterfaceWithAccessibleTypesInTypeParameterConstraintsClassHeritageListMemberTypeAnnotations.types

@@ -17,9 +17,9 @@ module A {
 >Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 
     export interface Point3d extends Point {
 >Point3d : Point3d
@@ -34,11 +34,11 @@ module A {
 >Point3d : Point3d
 >{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 >z : number
->0 : number
+>0 : 0
 
     export interface Line<TPoint extends Point>{
 >Line : Line<TPoint>

tests/baselines/reference/ExportInterfaceWithInaccessibleTypeInTypeParameterConstraint.types

@@ -17,9 +17,9 @@ module A {
 >Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 
     export interface Point3d extends Point {
 >Point3d : Point3d
@@ -34,11 +34,11 @@ module A {
 >Point3d : Point3d
 >{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 >z : number
->0 : number
+>0 : 0
 
     export interface Line<TPoint extends Point>{
 >Line : Line<TPoint>

tests/baselines/reference/ExportModuleWithAccessibleTypesOnItsExportedMembers.types

@@ -18,8 +18,8 @@ module A {
 >Point : Point
 >new Point(0, 0) : Point
 >Point : typeof Point
->0 : number
->0 : number
+>0 : 0
+>0 : 0
 
         export class Line {
 >Line : Line
@@ -42,9 +42,9 @@ module A {
 >Line : typeof Line
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 >p : Point
             }
         }

tests/baselines/reference/ExportObjectLiteralAndObjectTypeLiteralWithAccessibleTypesInMemberTypeAnnotations.types

@@ -15,9 +15,9 @@ module A {
 >Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 
     export var Unity = { start: new Point(0, 0), end: new Point(1, 0) };
 >Unity : { start: Point; end: Point; }
@@ -25,12 +25,12 @@ module A {
 >start : Point
 >new Point(0, 0) : Point
 >Point : typeof Point
->0 : number
->0 : number
+>0 : 0
+>0 : 0
 >end : Point
 >new Point(1, 0) : Point
 >Point : typeof Point
->1 : number
->0 : number
+>1 : 1
+>0 : 0
 }
 

tests/baselines/reference/ExportVariableWithAccessibleTypeInTypeAnnotation.types

@@ -18,8 +18,8 @@ module A {
 >Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 }
 

tests/baselines/reference/ExportVariableWithInaccessibleTypeInTypeAnnotation.types

@@ -18,9 +18,9 @@ module A {
 >Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 
     interface Point3d extends Point {
 >Point3d : Point3d
@@ -36,10 +36,10 @@ module A {
 >Point3d : Point3d
 >{ x: 0, y: 0, z: 0 } : { x: number; y: number; z: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 >z : number
->0 : number
+>0 : 0
 }
 

tests/baselines/reference/FunctionAndModuleWithSameNameAndDifferentCommonRoot.types

@@ -8,9 +8,9 @@ module A {
         return { x: 0, y: 0 };
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
     }
 }
 
@@ -25,9 +25,9 @@ module B {
 >Origin : { x: number; y: number; }
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
     }
 }
 

tests/baselines/reference/ModuleAndEnumWithSameNameAndCommonRoot.types

@@ -15,8 +15,8 @@ enum enumdule {
 >enumdule : enumdule
 
     Red, Blue
->Red : enumdule
->Blue : enumdule
+>Red : enumdule.Red
+>Blue : enumdule.Blue
 }
 
 var x: enumdule;
@@ -25,9 +25,9 @@ var x: enumdule;
 
 var x = enumdule.Red;
 >x : enumdule
->enumdule.Red : enumdule
+>enumdule.Red : enumdule.Red
 >enumdule : typeof enumdule
->Red : enumdule
+>Red : enumdule.Red
 
 var y: { x: number; y: number };
 >y : { x: number; y: number; }
@@ -40,6 +40,6 @@ var y = new enumdule.Point(0, 0);
 >enumdule.Point : typeof enumdule.Point
 >enumdule : typeof enumdule
 >Point : typeof enumdule.Point
->0 : number
->0 : number
+>0 : 0
+>0 : 0
 

tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.types

@@ -39,9 +39,9 @@ module A {
 >Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 }
 
 === tests/cases/conformance/internalModules/DeclarationMerging/part2.ts ===
@@ -51,7 +51,7 @@ module A {
     // not a collision, since we don't export
     var Origin: string = "0,0";
 >Origin : string
->"0,0" : string
+>"0,0" : "0,0"
 
     export module Utils {
 >Utils : typeof Utils
@@ -123,8 +123,8 @@ var p = new A.Utils.Plane(o, { x: 1, y: 1 });
 >o : { x: number; y: number; }
 >{ x: 1, y: 1 } : { x: number; y: number; }
 >x : number
->1 : number
+>1 : 1
 >y : number
->1 : number
+>1 : 1
 
 

tests/baselines/reference/TwoInternalModulesWithTheSameNameAndDifferentCommonRoot.types

@@ -55,9 +55,9 @@ module otherRoot {
 >Point : Root.A.Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 
         export module Utils {
 >Utils : typeof Utils

tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.types

@@ -45,9 +45,9 @@ module A {
 >Point : Point
 >{ x: 0, y: 0 } : { x: number; y: number; }
 >x : number
->0 : number
+>0 : 0
 >y : number
->0 : number
+>0 : 0
 
     export module Utils {
 >Utils : typeof Utils
@@ -119,8 +119,8 @@ var p = new A.Utils.Plane(o, { x: 1, y: 1 });
 >o : { x: number; y: number; }
 >{ x: 1, y: 1 } : { x: number; y: number; }
 >x : number
->1 : number
+>1 : 1
 >y : number
->1 : number
+>1 : 1
 
 

tests/baselines/reference/TypeGuardWithEnumUnion.types

@@ -1,9 +1,9 @@
 === tests/cases/conformance/expressions/typeGuards/TypeGuardWithEnumUnion.ts ===
 enum Color { R, G, B }
 >Color : Color
->R : Color
->G : Color
->B : Color
+>R : Color.R
+>G : Color.G
+>B : Color.B
 
 function f1(x: Color | string) {
 >f1 : (x: string | Color) => void

tests/baselines/reference/VariableDeclaration10_es6.types

@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/variableDeclarations/VariableDeclaration10_es6.ts ===
 let a: number = 1
 >a : number
->1 : number
+>1 : 1
 

tests/baselines/reference/VariableDeclaration3_es6.types

@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/variableDeclarations/VariableDeclaration3_es6.ts ===
 const a = 1
->a : number
->1 : number
+>a : 1
+>1 : 1
 

tests/baselines/reference/VariableDeclaration5_es6.types

@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/variableDeclarations/VariableDeclaration5_es6.ts ===
 const a: number = 1
 >a : number
->1 : number
+>1 : 1
 

tests/baselines/reference/VariableDeclaration8_es6.types

@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/variableDeclarations/VariableDeclaration8_es6.ts ===
 let a = 1
 >a : number
->1 : number
+>1 : 1
 

tests/baselines/reference/abstractIdentifierNameStrict.types

@@ -1,15 +1,15 @@
 === tests/cases/compiler/abstractIdentifierNameStrict.ts ===
 var abstract = true;
 >abstract : boolean
->true : boolean
+>true : true
 
 function foo() {
 >foo : () => void
 
     "use strict";
->"use strict" : string
+>"use strict" : "use strict"
 
     var abstract = true;
 >abstract : boolean
->true : boolean
+>true : true
 }

tests/baselines/reference/abstractProperty.types

@@ -40,7 +40,7 @@ class C extends B {
 
     get prop() { return "foo"; }
 >prop : string
->"foo" : string
+>"foo" : "foo"
 
     set prop(v) { }
 >prop : string
@@ -48,11 +48,11 @@ class C extends B {
 
     raw = "edge";
 >raw : string
->"edge" : string
+>"edge" : "edge"
 
     readonly ro = "readonly please";
->ro : string
->"readonly please" : string
+>ro : "readonly please"
+>"readonly please" : "readonly please"
 
     readonlyProp: string; // don't have to give a value, in fact
 >readonlyProp : string

tests/baselines/reference/accessOverriddenBaseClassMember1.types

@@ -13,11 +13,11 @@ class Point {
 >"x=" + this.x + " y=" + this.y : string
 >"x=" + this.x + " y=" : string
 >"x=" + this.x : string
->"x=" : string
+>"x=" : "x="
 >this.x : number
 >this : this
 >x : number
->" y=" : string
+>" y=" : " y="
 >this.y : number
 >this : this
 >y : number
@@ -48,7 +48,7 @@ class ColoredPoint extends Point {
 >super.toString : () => string
 >super : Point
 >toString : () => string
->" color=" : string
+>" color=" : " color="
 >this.color : string
 >this : this
 >color : string

tests/baselines/reference/accessorWithES5.types

@@ -7,7 +7,7 @@ class C {
 >x : number
 
         return 1;
->1 : number
+>1 : 1
     }
 }
 
@@ -26,7 +26,7 @@ var x = {
 
     get a() { return 1 }
 >a : number
->1 : number
+>1 : 1
 }
 
 var y = {

tests/baselines/reference/accessors_spec_section-4.5_error-cases.errors.txt

@@ -1,14 +1,14 @@
 tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(2,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(3,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
-tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(3,55): error TS2322: Type 'string' is not assignable to type 'number'.
+tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(3,55): error TS2322: Type '""' is not assignable to type 'number'.
 tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(5,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
-tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(5,54): error TS2322: Type 'string' is not assignable to type 'number'.
+tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(5,54): error TS2322: Type '""' is not assignable to type 'number'.
 tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(6,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(8,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(9,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
-tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(9,52): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(9,52): error TS2322: Type '0' is not assignable to type 'string'.
 tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(11,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
-tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(11,51): error TS2322: Type 'number' is not assignable to type 'string'.
+tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(11,51): error TS2322: Type '0' is not assignable to type 'string'.
 tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(12,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
 
 
@@ -21,13 +21,13 @@ tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(12,16): error TS1
                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
                                                           ~~
-!!! error TS2322: Type 'string' is not assignable to type 'number'.
+!!! error TS2322: Type '""' is not assignable to type 'number'.
     
         public get AnnotatedSetter_SetterLast() { return ""; }
                    ~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
                                                          ~~
-!!! error TS2322: Type 'string' is not assignable to type 'number'.
+!!! error TS2322: Type '""' is not assignable to type 'number'.
         public set AnnotatedSetter_SetterLast(a: number) { }
                    ~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
@@ -39,13 +39,13 @@ tests/cases/compiler/accessors_spec_section-4.5_error-cases.ts(12,16): error TS1
                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
                                                        ~~~~
-!!! error TS2322: Type 'number' is not assignable to type 'string'.
+!!! error TS2322: Type '0' is not assignable to type 'string'.
     
         public set AnnotatedGetter_GetterLast(aStr) { aStr = 0; }
                    ~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.
                                                       ~~~~
-!!! error TS2322: Type 'number' is not assignable to type 'string'.
+!!! error TS2322: Type '0' is not assignable to type 'string'.
         public get AnnotatedGetter_GetterLast(): string { return ""; }
                    ~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher.

tests/baselines/reference/addMoreCallSignaturesToBaseSignature2.types

@@ -22,5 +22,5 @@ var kitty = a(1);
 >kitty : string
 >a(1) : string
 >a : Bar
->1 : number
+>1 : 1
 

tests/baselines/reference/additionOperatorWithAnyAndEveryType.types

@@ -13,9 +13,9 @@ class C {
 }
 enum E { a, b, c }
 >E : E
->a : E
->b : E
->c : E
+>a : E.a
+>b : E.b
+>c : E.c
 
 module M { export var a }
 >M : typeof M
@@ -130,9 +130,9 @@ var r15 = a + E.a;
 >r15 : any
 >a + E.a : any
 >a : any
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 
 var r16 = a + M;
 >r16 : any
@@ -144,13 +144,13 @@ var r17 = a + '';
 >r17 : string
 >a + '' : string
 >a : any
->'' : string
+>'' : ""
 
 var r18 = a + 123;
 >r18 : any
 >a + 123 : any
 >a : any
->123 : number
+>123 : 123
 
 var r19 = a + { a: '' };
 >r19 : any
@@ -158,7 +158,7 @@ var r19 = a + { a: '' };
 >a : any
 >{ a: '' } : { a: string; }
 >a : string
->'' : string
+>'' : ""
 
 var r20 = a + ((a: string) => { return a });
 >r20 : any

tests/baselines/reference/additionOperatorWithInvalidOperands.errors.txt

@@ -6,17 +6,17 @@ tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOpe
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(25,10): error TS2365: Operator '+' cannot be applied to types 'Object' and 'boolean'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(26,10): error TS2365: Operator '+' cannot be applied to types 'Object' and 'number'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(27,10): error TS2365: Operator '+' cannot be applied to types 'Object' and 'Object'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(30,11): error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(31,11): error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(32,11): error TS2365: Operator '+' cannot be applied to types 'boolean' and 'number'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(30,11): error TS2365: Operator '+' cannot be applied to types 'boolean' and 'true'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(31,11): error TS2365: Operator '+' cannot be applied to types 'true' and 'false'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(32,11): error TS2365: Operator '+' cannot be applied to types 'true' and '123'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(33,11): error TS2365: Operator '+' cannot be applied to types '{}' and '{}'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(34,11): error TS2365: Operator '+' cannot be applied to types 'number' and 'Number'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(35,11): error TS2365: Operator '+' cannot be applied to types 'number' and '() => void'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(36,11): error TS2365: Operator '+' cannot be applied to types 'number' and 'void'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(37,11): error TS2365: Operator '+' cannot be applied to types 'number' and 'typeof C'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(38,11): error TS2365: Operator '+' cannot be applied to types 'E' and 'C'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(39,11): error TS2365: Operator '+' cannot be applied to types 'E' and 'void'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(40,11): error TS2365: Operator '+' cannot be applied to types 'E' and 'typeof M'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(38,11): error TS2365: Operator '+' cannot be applied to types 'E.a' and 'C'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(39,11): error TS2365: Operator '+' cannot be applied to types 'E.a' and 'void'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts(40,11): error TS2365: Operator '+' cannot be applied to types 'E.a' and 'typeof M'.
 
 
 ==== tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithInvalidOperands.ts (19 errors) ====
@@ -67,13 +67,13 @@ tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOpe
     // other cases
     var r10 = a + true;
               ~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
+!!! error TS2365: Operator '+' cannot be applied to types 'boolean' and 'true'.
     var r11 = true + false;
               ~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
+!!! error TS2365: Operator '+' cannot be applied to types 'true' and 'false'.
     var r12 = true + 123;
               ~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'boolean' and 'number'.
+!!! error TS2365: Operator '+' cannot be applied to types 'true' and '123'.
     var r13 = {} + {};
               ~~~~~~~
 !!! error TS2365: Operator '+' cannot be applied to types '{}' and '{}'.
@@ -91,10 +91,10 @@ tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOpe
 !!! error TS2365: Operator '+' cannot be applied to types 'number' and 'typeof C'.
     var r18 = E.a + new C();
               ~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'E' and 'C'.
+!!! error TS2365: Operator '+' cannot be applied to types 'E.a' and 'C'.
     var r19 = E.a + C.foo();
               ~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'E' and 'void'.
+!!! error TS2365: Operator '+' cannot be applied to types 'E.a' and 'void'.
     var r20 = E.a + M;
               ~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'E' and 'typeof M'.
+!!! error TS2365: Operator '+' cannot be applied to types 'E.a' and 'typeof M'.

tests/baselines/reference/additionOperatorWithNullValueAndInvalidOperator.errors.txt

@@ -5,7 +5,7 @@ tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOpe
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(15,10): error TS2365: Operator '+' cannot be applied to types 'Object' and 'Object'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(16,10): error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(19,10): error TS2365: Operator '+' cannot be applied to types 'Number' and 'Number'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(20,10): error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(20,10): error TS2365: Operator '+' cannot be applied to types 'true' and 'true'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(21,10): error TS2365: Operator '+' cannot be applied to types '{ a: string; }' and '{ a: string; }'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(22,11): error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNullValueAndInvalidOperator.ts(23,11): error TS2365: Operator '+' cannot be applied to types '() => void' and '() => void'.
@@ -47,7 +47,7 @@ tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOpe
 !!! error TS2365: Operator '+' cannot be applied to types 'Number' and 'Number'.
     var r8 = null + true;
              ~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
+!!! error TS2365: Operator '+' cannot be applied to types 'true' and 'true'.
     var r9 = null + { a: '' };
              ~~~~~~~~~~~~~~~~
 !!! error TS2365: Operator '+' cannot be applied to types '{ a: string; }' and '{ a: string; }'.

tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.types

@@ -3,9 +3,9 @@
 
 enum E { a, b, c }
 >E : E
->a : E
->b : E
->c : E
+>a : E.a
+>b : E.b
+>c : E.c
 
 var a: any;
 >a : any
@@ -44,7 +44,7 @@ var r4 = null + 1;
 >r4 : number
 >null + 1 : number
 >null : null
->1 : number
+>1 : 1
 
 var r5 = null + c;
 >r5 : number
@@ -56,17 +56,17 @@ var r6 = null + E.a;
 >r6 : number
 >null + E.a : number
 >null : null
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 
 var r7 = null + E['a'];
 >r7 : number
 >null + E['a'] : number
 >null : null
->E['a'] : E
+>E['a'] : E.a
 >E : typeof E
->'a' : string
+>'a' : "a"
 
 var r8 = b + null;
 >r8 : number
@@ -77,7 +77,7 @@ var r8 = b + null;
 var r9 = 1 + null;
 >r9 : number
 >1 + null : number
->1 : number
+>1 : 1
 >null : null
 
 var r10 = c + null
@@ -89,17 +89,17 @@ var r10 = c + null
 var r11 = E.a + null;
 >r11 : number
 >E.a + null : number
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 >null : null
 
 var r12 = E['a'] + null;
 >r12 : number
 >E['a'] + null : number
->E['a'] : E
+>E['a'] : E.a
 >E : typeof E
->'a' : string
+>'a' : "a"
 >null : null
 
 // null + string
@@ -113,7 +113,7 @@ var r14 = null + '';
 >r14 : string
 >null + '' : string
 >null : null
->'' : string
+>'' : ""
 
 var r15 = d + null;
 >r15 : string
@@ -124,6 +124,6 @@ var r15 = d + null;
 var r16 = '' + null;
 >r16 : string
 >'' + null : string
->'' : string
+>'' : ""
 >null : null
 

tests/baselines/reference/additionOperatorWithNumberAndEnum.types

@@ -1,13 +1,13 @@
 === tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithNumberAndEnum.ts ===
 enum E { a, b }
 >E : E
->a : E
->b : E
+>a : E.a
+>b : E.b
 
 enum F { c, d }
 >F : F
->c : F
->d : F
+>c : F.c
+>d : F.d
 
 var a: number;
 >a : number
@@ -48,46 +48,46 @@ var r4 = b + b;
 var r5 = 0 + a;
 >r5 : number
 >0 + a : number
->0 : number
+>0 : 0
 >a : number
 
 var r6 = E.a + 0;
 >r6 : number
 >E.a + 0 : number
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
->0 : number
+>a : E.a
+>0 : 0
 
 var r7 = E.a + E.b;
 >r7 : number
 >E.a + E.b : number
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
->E.b : E
+>a : E.a
+>E.b : E.b
 >E : typeof E
->b : E
+>b : E.b
 
 var r8 = E['a'] + E['b'];
 >r8 : number
 >E['a'] + E['b'] : number
->E['a'] : E
+>E['a'] : E.a
 >E : typeof E
->'a' : string
->E['b'] : E
+>'a' : "a"
+>E['b'] : E.b
 >E : typeof E
->'b' : string
+>'b' : "b"
 
 var r9 = E['a'] + F['c'];
 >r9 : number
 >E['a'] + F['c'] : number
->E['a'] : E
+>E['a'] : E.a
 >E : typeof E
->'a' : string
->F['c'] : F
+>'a' : "a"
+>F['c'] : F.c
 >F : typeof F
->'c' : string
+>'c' : "c"
 
 var r10 = a + c;
 >r10 : number

tests/baselines/reference/additionOperatorWithStringAndEveryType.types

@@ -1,9 +1,9 @@
 === tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithStringAndEveryType.ts ===
 enum E { a, b, c }
 >E : E
->a : E
->b : E
->c : E
+>a : E.a
+>b : E.b
+>c : E.c
 
 var a: any;
 >a : any
@@ -129,21 +129,21 @@ var r16 = x + E.a;
 >r16 : string
 >x + E.a : string
 >x : string
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 
 var r17 = x + '';
 >r17 : string
 >x + '' : string
 >x : string
->'' : string
+>'' : ""
 
 var r18 = x + 0;
 >r18 : string
 >x + 0 : string
 >x : string
->0 : number
+>0 : 0
 
 var r19 = x + { a: '' };
 >r19 : string
@@ -151,7 +151,7 @@ var r19 = x + { a: '' };
 >x : string
 >{ a: '' } : { a: string; }
 >a : string
->'' : string
+>'' : ""
 
 var r20 = x + [];
 >r20 : string

tests/baselines/reference/additionOperatorWithUndefinedValueAndInvalidOperands.errors.txt

@@ -5,7 +5,7 @@ tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOpe
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(15,10): error TS2365: Operator '+' cannot be applied to types 'Object' and 'Object'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(16,10): error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(19,10): error TS2365: Operator '+' cannot be applied to types 'Number' and 'Number'.
-tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(20,10): error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
+tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(20,10): error TS2365: Operator '+' cannot be applied to types 'true' and 'true'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(21,10): error TS2365: Operator '+' cannot be applied to types '{ a: string; }' and '{ a: string; }'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(22,11): error TS2365: Operator '+' cannot be applied to types 'void' and 'void'.
 tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOperatorWithUndefinedValueAndInvalidOperands.ts(23,11): error TS2365: Operator '+' cannot be applied to types '() => void' and '() => void'.
@@ -47,7 +47,7 @@ tests/cases/conformance/expressions/binaryOperators/additionOperator/additionOpe
 !!! error TS2365: Operator '+' cannot be applied to types 'Number' and 'Number'.
     var r8 = undefined + true;
              ~~~~~~~~~~~~~~~~
-!!! error TS2365: Operator '+' cannot be applied to types 'boolean' and 'boolean'.
+!!! error TS2365: Operator '+' cannot be applied to types 'true' and 'true'.
     var r9 = undefined + { a: '' };
              ~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2365: Operator '+' cannot be applied to types '{ a: string; }' and '{ a: string; }'.

tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.types

@@ -3,9 +3,9 @@
 
 enum E { a, b, c }
 >E : E
->a : E
->b : E
->c : E
+>a : E.a
+>b : E.b
+>c : E.c
 
 var a: any;
 >a : any
@@ -44,7 +44,7 @@ var r4 = undefined + 1;
 >r4 : number
 >undefined + 1 : number
 >undefined : undefined
->1 : number
+>1 : 1
 
 var r5 = undefined + c;
 >r5 : number
@@ -56,17 +56,17 @@ var r6 = undefined + E.a;
 >r6 : number
 >undefined + E.a : number
 >undefined : undefined
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 
 var r7 = undefined + E['a'];
 >r7 : number
 >undefined + E['a'] : number
 >undefined : undefined
->E['a'] : E
+>E['a'] : E.a
 >E : typeof E
->'a' : string
+>'a' : "a"
 
 var r8 = b + undefined;
 >r8 : number
@@ -77,7 +77,7 @@ var r8 = b + undefined;
 var r9 = 1 + undefined;
 >r9 : number
 >1 + undefined : number
->1 : number
+>1 : 1
 >undefined : undefined
 
 var r10 = c + undefined
@@ -89,17 +89,17 @@ var r10 = c + undefined
 var r11 = E.a + undefined;
 >r11 : number
 >E.a + undefined : number
->E.a : E
+>E.a : E.a
 >E : typeof E
->a : E
+>a : E.a
 >undefined : undefined
 
 var r12 = E['a'] + undefined;
 >r12 : number
 >E['a'] + undefined : number
->E['a'] : E
+>E['a'] : E.a
 >E : typeof E
->'a' : string
+>'a' : "a"
 >undefined : undefined
 
 // undefined + string
@@ -113,7 +113,7 @@ var r14 = undefined + '';
 >r14 : string
 >undefined + '' : string
 >undefined : undefined
->'' : string
+>'' : ""
 
 var r15 = d + undefined;
 >r15 : string
@@ -124,6 +124,6 @@ var r15 = d + undefined;
 var r16 = '' + undefined;
 >r16 : string
 >'' + undefined : string
->'' : string
+>'' : ""
 >undefined : undefined
 

tests/baselines/reference/aliasAssignments.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/compiler/aliasAssignments_1.ts(3,1): error TS2322: Type 'number' is not assignable to type 'typeof "tests/cases/compiler/aliasAssignments_moduleA"'.
+tests/cases/compiler/aliasAssignments_1.ts(3,1): error TS2322: Type '1' is not assignable to type 'typeof "tests/cases/compiler/aliasAssignments_moduleA"'.
 tests/cases/compiler/aliasAssignments_1.ts(5,1): error TS2322: Type 'typeof "tests/cases/compiler/aliasAssignments_moduleA"' is not assignable to type 'number'.
 
 
@@ -7,7 +7,7 @@ tests/cases/compiler/aliasAssignments_1.ts(5,1): error TS2322: Type 'typeof "tes
     var x = moduleA;
     x = 1; // Should be error
     ~
-!!! error TS2322: Type 'number' is not assignable to type 'typeof "tests/cases/compiler/aliasAssignments_moduleA"'.
+!!! error TS2322: Type '1' is not assignable to type 'typeof "tests/cases/compiler/aliasAssignments_moduleA"'.
     var y = 1;
     y = moduleA; // should be error
     ~

tests/baselines/reference/ambientDeclarations.types

@@ -103,14 +103,14 @@ declare enum E2 {
 
     a = 1,
 >a : E2
->1 : number
+>1 : 1
 
     b,
 >b : E2
 
     c = 2,
 >c : E2
->2 : number
+>2 : 2
 
     d
 >d : E2

tests/baselines/reference/ambientEnumDeclaration1.types

@@ -6,13 +6,13 @@ declare enum E {
 
     a = 10,
 >a : E
->10 : number
+>10 : 10
 
     b = 10 + 1,
 >b : E
 >10 + 1 : number
->10 : number
->1 : number
+>10 : 10
+>1 : 1
 
     c = b,
 >c : E
@@ -23,13 +23,13 @@ declare enum E {
 >(c) + 1 : number
 >(c) : E
 >c : E
->1 : number
+>1 : 1
 
     e = 10 << 2 * 8,
 >e : E
 >10 << 2 * 8 : number
->10 : number
+>10 : 10
 >2 * 8 : number
->2 : number
->8 : number
+>2 : 2
+>8 : 8
 }

tests/baselines/reference/ambientEnumElementInitializer1.types

@@ -4,5 +4,5 @@ declare enum E {
 
  e = 3
 >e : E
->3 : number
+>3 : 3
 }

tests/baselines/reference/ambientEnumElementInitializer2.types

@@ -4,6 +4,6 @@ declare enum E {
 
  e = -3 // Negative
 >e : E
->-3 : number
->3 : number
+>-3 : -3
+>3 : 3
 }

tests/baselines/reference/ambientEnumElementInitializer3.types

@@ -4,5 +4,5 @@ declare enum E {
 
  e = 3.3 // Decimal
 >e : E
->3.3 : number
+>3.3 : 3.3
 }