Merge remote-tracking branch 'origin/master' into import_completions_pr

Gulpfile.ts

@@ -551,7 +551,7 @@ function restoreSavedNodeEnv() {
     process.env.NODE_ENV = savedNodeEnv;
 }
 
-let testTimeout = 20000;
+let testTimeout = 40000;
 function runConsoleTests(defaultReporter: string, runInParallel: boolean, done: (e?: any) => void) {
     const lintFlag = cmdLineOptions["lint"];
     cleanTestDirs((err) => {

src/compiler/checker.ts

@@ -109,7 +109,7 @@ namespace ts {
             isOptionalParameter
         };
 
-        const tupleTypes = createMap<TupleType>();
+        const tupleTypes: GenericType[] = [];
         const unionTypes = createMap<UnionType>();
         const intersectionTypes = createMap<IntersectionType>();
         const stringLiteralTypes = createMap<LiteralType>();
@@ -1026,8 +1026,8 @@ namespace ts {
             }
         }
 
-        function getDeclarationOfAliasSymbol(symbol: Symbol): Declaration {
-            return findMap(symbol.declarations, d => isAliasSymbolDeclaration(d) ? d : undefined);
+        function getDeclarationOfAliasSymbol(symbol: Symbol): Declaration | undefined {
+            return forEach(symbol.declarations, d => isAliasSymbolDeclaration(d) ? d : undefined);
         }
 
         function getTargetOfImportEqualsDeclaration(node: ImportEqualsDeclaration): Symbol {
@@ -1129,13 +1129,13 @@ namespace ts {
                     else {
                         symbolFromVariable = getPropertyOfVariable(targetSymbol, name.text);
                     }
-                    // If the export member we're looking for is default, and there is no real default but allowSyntheticDefaultImports is on, return the entire module as the default
-                    if (!symbolFromVariable && allowSyntheticDefaultImports && name.text === "default") {
-                        symbolFromVariable = resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol);
-                    }
                     // if symbolFromVariable is export - get its final target
                     symbolFromVariable = resolveSymbol(symbolFromVariable);
-                    const symbolFromModule = getExportOfModule(targetSymbol, name.text);
+                    let symbolFromModule = getExportOfModule(targetSymbol, name.text);
+                    // If the export member we're looking for is default, and there is no real default but allowSyntheticDefaultImports is on, return the entire module as the default
+                    if (!symbolFromModule && allowSyntheticDefaultImports && name.text === "default") {
+                        symbolFromModule = resolveExternalModuleSymbol(moduleSymbol) || resolveSymbol(moduleSymbol);
+                    }
                     const symbol = symbolFromModule && symbolFromVariable ?
                         combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) :
                         symbolFromModule || symbolFromVariable;
@@ -1194,6 +1194,7 @@ namespace ts {
             if (!links.target) {
                 links.target = resolvingSymbol;
                 const node = getDeclarationOfAliasSymbol(symbol);
+                Debug.assert(!!node);
                 const target = getTargetOfAliasDeclaration(node);
                 if (links.target === resolvingSymbol) {
                     links.target = target || unknownSymbol;
@@ -1229,6 +1230,7 @@ namespace ts {
             if (!links.referenced) {
                 links.referenced = true;
                 const node = getDeclarationOfAliasSymbol(symbol);
+                Debug.assert(!!node);
                 if (node.kind === SyntaxKind.ExportAssignment) {
                     // export default <symbol>
                     checkExpressionCached((<ExportAssignment>node).expression);
@@ -2148,9 +2150,6 @@ namespace ts {
                         // The specified symbol flags need to be reinterpreted as type flags
                         buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, nextFlags);
                     }
-                    else if (type.flags & TypeFlags.Tuple) {
-                        writeTupleType(<TupleType>type);
-                    }
                     else if (!(flags & TypeFormatFlags.InTypeAlias) && type.flags & (TypeFlags.Anonymous | TypeFlags.UnionOrIntersection) && type.aliasSymbol) {
                         const typeArguments = type.aliasTypeArguments;
                         writeSymbolTypeReference(type.aliasSymbol, typeArguments, 0, typeArguments ? typeArguments.length : 0, nextFlags);
@@ -2217,6 +2216,11 @@ namespace ts {
                         writePunctuation(writer, SyntaxKind.OpenBracketToken);
                         writePunctuation(writer, SyntaxKind.CloseBracketToken);
                     }
+                    else if (type.target.flags & TypeFlags.Tuple) {
+                        writePunctuation(writer, SyntaxKind.OpenBracketToken);
+                        writeTypeList(type.typeArguments.slice(0, getTypeReferenceArity(type)), SyntaxKind.CommaToken);
+                        writePunctuation(writer, SyntaxKind.CloseBracketToken);
+                    }
                     else {
                         // Write the type reference in the format f<A>.g<B>.C<X, Y> where A and B are type arguments
                         // for outer type parameters, and f and g are the respective declaring containers of those
@@ -2245,12 +2249,6 @@ namespace ts {
                     }
                 }
 
-                function writeTupleType(type: TupleType) {
-                    writePunctuation(writer, SyntaxKind.OpenBracketToken);
-                    writeTypeList(type.elementTypes, SyntaxKind.CommaToken);
-                    writePunctuation(writer, SyntaxKind.CloseBracketToken);
-                }
-
                 function writeUnionOrIntersectionType(type: UnionOrIntersectionType, flags: TypeFormatFlags) {
                     if (flags & TypeFormatFlags.InElementType) {
                         writePunctuation(writer, SyntaxKind.OpenParenToken);
@@ -2961,7 +2959,7 @@ namespace ts {
                         : elementType;
                     if (!type) {
                         if (isTupleType(parentType)) {
-                            error(declaration, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(parentType), (<TupleType>parentType).elementTypes.length, pattern.elements.length);
+                            error(declaration, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(parentType), getTypeReferenceArity(<TypeReference>parentType), pattern.elements.length);
                         }
                         else {
                             error(declaration, Diagnostics.Type_0_has_no_property_1, typeToString(parentType), propName);
@@ -3073,9 +3071,14 @@ namespace ts {
                     }
                 }
                 // Use contextual parameter type if one is available
-                const type = declaration.symbol.name === "this"
-                    ? getContextuallyTypedThisType(func)
-                    : getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
+                let type: Type;
+                if (declaration.symbol.name === "this") {
+                    const thisParameter = getContextualThisParameter(func);
+                    type = thisParameter ? getTypeOfSymbol(thisParameter) : undefined;
+                }
+                else {
+                    type = getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
+                }
                 if (type) {
                     return addOptionality(type, /*optional*/ declaration.questionToken && includeOptionality);
                 }
@@ -3153,12 +3156,12 @@ namespace ts {
             }
             // 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));
+            let result = createTupleType(elementTypes);
             if (includePatternInType) {
-                const result = createNewTupleType(elementTypes);
+                result = cloneTypeReference(result);
                 result.pattern = pattern;
-                return result;
             }
-            return createTupleType(elementTypes);
+            return result;
         }
 
         // Return the type implied by a binding pattern. This is the type implied purely by the binding pattern itself
@@ -3346,7 +3349,13 @@ namespace ts {
                         // Otherwise, fall back to 'any'.
                         else {
                             if (compilerOptions.noImplicitAny) {
-                                error(setter, Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_type_annotation, symbolToString(symbol));
+                                if (setter) {
+                                    error(setter, Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation, symbolToString(symbol));
+                                }
+                                else {
+                                    Debug.assert(!!getter, "there must existed getter as we are current checking either setter or getter in this function");
+                                    error(getter, Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation, symbolToString(symbol));
+                                }
                             }
                             type = anyType;
                         }
@@ -3567,18 +3576,21 @@ namespace ts {
         }
 
         function getBaseTypes(type: InterfaceType): ObjectType[] {
-            const isClass = type.symbol.flags & SymbolFlags.Class;
-            const isInterface = type.symbol.flags & SymbolFlags.Interface;
             if (!type.resolvedBaseTypes) {
-                if (!isClass && !isInterface) {
+                if (type.flags & TypeFlags.Tuple) {
+                    type.resolvedBaseTypes = [createArrayType(getUnionType(type.typeParameters))];
+                }
+                else if (type.symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
+                    if (type.symbol.flags & SymbolFlags.Class) {
+                        resolveBaseTypesOfClass(type);
+                    }
+                    if (type.symbol.flags & SymbolFlags.Interface) {
+                        resolveBaseTypesOfInterface(type);
+                    }
+                }
+                else {
                     Debug.fail("type must be class or interface");
                 }
-                if (isClass) {
-                    resolveBaseTypesOfClass(type);
-                }
-                if (isInterface) {
-                    resolveBaseTypesOfInterface(type);
-                }
             }
             return type.resolvedBaseTypes;
         }
@@ -4004,20 +4016,25 @@ namespace ts {
                 return createTypeReference((<TypeReference>type).target,
                     concatenate((<TypeReference>type).typeArguments, [thisArgument || (<TypeReference>type).target.thisType]));
             }
-            if (type.flags & TypeFlags.Tuple) {
-                return createTupleType((type as TupleType).elementTypes, thisArgument);
-            }
             return type;
         }
 
         function resolveObjectTypeMembers(type: ObjectType, source: InterfaceTypeWithDeclaredMembers, typeParameters: TypeParameter[], typeArguments: Type[]) {
-            let mapper = identityMapper;
-            let members = source.symbol.members;
-            let callSignatures = source.declaredCallSignatures;
-            let constructSignatures = source.declaredConstructSignatures;
-            let stringIndexInfo = source.declaredStringIndexInfo;
-            let numberIndexInfo = source.declaredNumberIndexInfo;
-            if (!rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
+            let mapper: TypeMapper;
+            let members: SymbolTable;
+            let callSignatures: Signature[];
+            let constructSignatures: Signature[];
+            let stringIndexInfo: IndexInfo;
+            let numberIndexInfo: IndexInfo;
+            if (rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) {
+                mapper = identityMapper;
+                members = source.symbol ? source.symbol.members : createSymbolTable(source.declaredProperties);
+                callSignatures = source.declaredCallSignatures;
+                constructSignatures = source.declaredConstructSignatures;
+                stringIndexInfo = source.declaredStringIndexInfo;
+                numberIndexInfo = source.declaredNumberIndexInfo;
+            }
+            else {
                 mapper = createTypeMapper(typeParameters, typeArguments);
                 members = createInstantiatedSymbolTable(source.declaredProperties, mapper, /*mappingThisOnly*/ typeParameters.length === 1);
                 callSignatures = instantiateList(source.declaredCallSignatures, mapper, instantiateSignature);
@@ -4027,7 +4044,7 @@ namespace ts {
             }
             const baseTypes = getBaseTypes(source);
             if (baseTypes.length) {
-                if (members === source.symbol.members) {
+                if (source.symbol && members === source.symbol.members) {
                     members = createSymbolTable(source.declaredProperties);
                 }
                 const thisArgument = lastOrUndefined(typeArguments);
@@ -4097,26 +4114,6 @@ namespace ts {
             return result;
         }
 
-        function createTupleTypeMemberSymbols(memberTypes: Type[]): SymbolTable {
-            const members = createMap<Symbol>();
-            for (let i = 0; i < memberTypes.length; i++) {
-                const symbol = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "" + i);
-                symbol.type = memberTypes[i];
-                members[i] = symbol;
-            }
-            return members;
-        }
-
-        function resolveTupleTypeMembers(type: TupleType) {
-            const arrayElementType = getUnionType(type.elementTypes);
-            // Make the tuple type itself the 'this' type by including an extra type argument
-            // (Unless it's provided in the case that the tuple is a type parameter constraint)
-            const arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, type.thisType || type]));
-            const members = createTupleTypeMemberSymbols(type.elementTypes);
-            addInheritedMembers(members, arrayType.properties);
-            setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexInfo, arrayType.numberIndexInfo);
-        }
-
         function findMatchingSignature(signatureList: Signature[], signature: Signature, partialMatch: boolean, ignoreThisTypes: boolean, ignoreReturnTypes: boolean): Signature {
             for (const s of signatureList) {
                 if (compareSignaturesIdentical(s, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes, compareTypesIdentical)) {
@@ -4295,9 +4292,6 @@ namespace ts {
                 else if (type.flags & TypeFlags.Anonymous) {
                     resolveAnonymousTypeMembers(<AnonymousType>type);
                 }
-                else if (type.flags & TypeFlags.Tuple) {
-                    resolveTupleTypeMembers(<TupleType>type);
-                }
                 else if (type.flags & TypeFlags.Union) {
                     resolveUnionTypeMembers(<UnionType>type);
                 }
@@ -4697,6 +4691,9 @@ namespace ts {
                 if (isJSConstructSignature) {
                     minArgumentCount--;
                 }
+                if (!thisParameter && isObjectLiteralMethod(declaration)) {
+                    thisParameter = getContextualThisParameter(declaration);
+                }
 
                 const classType = declaration.kind === SyntaxKind.Constructor ?
                     getDeclaredTypeOfClassOrInterface(getMergedSymbol((<ClassDeclaration>declaration.parent).symbol))
@@ -4995,6 +4992,17 @@ namespace ts {
             return type;
         }
 
+        function cloneTypeReference(source: TypeReference): TypeReference {
+            const type = <TypeReference>createObjectType(source.flags, source.symbol);
+            type.target = source.target;
+            type.typeArguments = source.typeArguments;
+            return type;
+        }
+
+        function getTypeReferenceArity(type: TypeReference): number {
+            return type.target.typeParameters ? type.target.typeParameters.length : 0;
+        }
+
         // Get type from reference to class or interface
         function getTypeFromClassOrInterfaceReference(node: TypeReferenceNode | ExpressionWithTypeArguments | JSDocTypeReference, symbol: Symbol): Type {
             const type = <InterfaceType>getDeclaredTypeOfSymbol(getMergedSymbol(symbol));
@@ -5237,17 +5245,47 @@ namespace ts {
             return links.resolvedType;
         }
 
-        function createTupleType(elementTypes: Type[], thisType?: Type) {
-            const id = getTypeListId(elementTypes) + "," + (thisType ? thisType.id : 0);
-            return tupleTypes[id] || (tupleTypes[id] = createNewTupleType(elementTypes, thisType));
+        // We represent tuple types as type references to synthesized generic interface types created by
+        // this function. The types are of the form:
+        //
+        //   interface Tuple<T0, T1, T2, ...> extends Array<T0 | T1 | T2 | ...> { 0: T0, 1: T1, 2: T2, ... }
+        //
+        // Note that the generic type created by this function has no symbol associated with it. The same
+        // is true for each of the synthesized type parameters.
+        function createTupleTypeOfArity(arity: number): GenericType {
+            const typeParameters: TypeParameter[] = [];
+            const properties: Symbol[] = [];
+            for (let i = 0; i < arity; i++) {
+                const typeParameter = <TypeParameter>createType(TypeFlags.TypeParameter);
+                typeParameters.push(typeParameter);
+                const property = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient, "" + i);
+                property.type = typeParameter;
+                properties.push(property);
+            }
+            const type = <GenericType & InterfaceTypeWithDeclaredMembers>createObjectType(TypeFlags.Tuple | TypeFlags.Reference);
+            type.typeParameters = typeParameters;
+            type.outerTypeParameters = undefined;
+            type.localTypeParameters = typeParameters;
+            type.instantiations = createMap<TypeReference>();
+            type.instantiations[getTypeListId(type.typeParameters)] = <GenericType>type;
+            type.target = <GenericType>type;
+            type.typeArguments = type.typeParameters;
+            type.thisType = <TypeParameter>createType(TypeFlags.TypeParameter | TypeFlags.ThisType);
+            type.thisType.constraint = type;
+            type.declaredProperties = properties;
+            type.declaredCallSignatures = emptyArray;
+            type.declaredConstructSignatures = emptyArray;
+            type.declaredStringIndexInfo = undefined;
+            type.declaredNumberIndexInfo = undefined;
+            return type;
         }
 
-        function createNewTupleType(elementTypes: Type[], thisType?: Type) {
-            const propagatedFlags = getPropagatingFlagsOfTypes(elementTypes, /*excludeKinds*/ 0);
-            const type = <TupleType>createObjectType(TypeFlags.Tuple | propagatedFlags);
-            type.elementTypes = elementTypes;
-            type.thisType = thisType;
-            return type;
+        function getTupleTypeOfArity(arity: number): GenericType {
+            return tupleTypes[arity] || (tupleTypes[arity] = createTupleTypeOfArity(arity));
+        }
+
+        function createTupleType(elementTypes: Type[]) {
+            return createTypeReference(getTupleTypeOfArity(elementTypes.length), elementTypes);
         }
 
         function getTypeFromTupleTypeNode(node: TupleTypeNode): Type {
@@ -5555,6 +5593,12 @@ namespace ts {
                     return nullType;
                 case SyntaxKind.NeverKeyword:
                     return neverType;
+                case SyntaxKind.JSDocNullKeyword:
+                    return nullType;
+                case SyntaxKind.JSDocUndefinedKeyword:
+                    return undefinedType;
+                case SyntaxKind.JSDocNeverKeyword:
+                    return neverType;
                 case SyntaxKind.ThisType:
                 case SyntaxKind.ThisKeyword:
                     return getTypeFromThisTypeNode(node);
@@ -5848,9 +5892,6 @@ namespace ts {
                 if (type.flags & TypeFlags.Reference) {
                     return createTypeReference((<TypeReference>type).target, instantiateList((<TypeReference>type).typeArguments, mapper, instantiateType));
                 }
-                if (type.flags & TypeFlags.Tuple) {
-                    return createTupleType(instantiateList((<TupleType>type).elementTypes, mapper, instantiateType));
-                }
                 if (type.flags & TypeFlags.Union && !(type.flags & TypeFlags.Primitive)) {
                     return getUnionType(instantiateList((<UnionType>type).types, mapper, instantiateType), /*subtypeReduction*/ false, type.aliasSymbol, mapper.targetTypes);
                 }
@@ -6270,6 +6311,18 @@ namespace ts {
                 reportError(message, sourceType, targetType);
             }
 
+            function tryElaborateErrorsForPrimitivesAndObjects(source: Type, target: Type) {
+                const sourceType = typeToString(source);
+                const targetType = typeToString(target);
+
+                if ((globalStringType === source && stringType === target) ||
+                    (globalNumberType === source && numberType === target) ||
+                    (globalBooleanType === source && booleanType === target) ||
+                    (getGlobalESSymbolType() === source && esSymbolType === target)) {
+                        reportError(Diagnostics._0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible, targetType, sourceType);
+                }
+            }
+
             // Compare two types and return
             // Ternary.True if they are related with no assumptions,
             // Ternary.Maybe if they are related with assumptions of other relationships, or
@@ -6393,6 +6446,9 @@ namespace ts {
                 }
 
                 if (reportErrors) {
+                    if (source.flags & TypeFlags.ObjectType && target.flags & TypeFlags.Primitive) {
+                        tryElaborateErrorsForPrimitivesAndObjects(source, target);
+                    }
                     reportRelationError(headMessage, source, target);
                 }
                 return Ternary.False;
@@ -7171,8 +7227,8 @@ namespace ts {
          * Check if a Type was written as a tuple type literal.
          * Prefer using isTupleLikeType() unless the use of `elementTypes` is required.
          */
-        function isTupleType(type: Type): type is TupleType {
-            return !!(type.flags & TypeFlags.Tuple);
+        function isTupleType(type: Type): boolean {
+            return !!(type.flags & TypeFlags.Reference && (<TypeReference>type).target.flags & TypeFlags.Tuple);
         }
 
         function getFalsyFlagsOfTypes(types: Type[]): TypeFlags {
@@ -7304,11 +7360,8 @@ namespace ts {
                 if (type.flags & TypeFlags.Union) {
                     return getUnionType(map((<UnionType>type).types, getWidenedConstituentType));
                 }
-                if (isArrayType(type)) {
-                    return createArrayType(getWidenedType((<TypeReference>type).typeArguments[0]));
-                }
-                if (isTupleType(type)) {
-                    return createTupleType(map(type.elementTypes, getWidenedType));
+                if (isArrayType(type) || isTupleType(type)) {
+                    return createTypeReference((<TypeReference>type).target, map((<TypeReference>type).typeArguments, getWidenedType));
                 }
             }
             return type;
@@ -7334,11 +7387,8 @@ namespace ts {
                     }
                 }
             }
-            if (isArrayType(type)) {
-                return reportWideningErrorsInType((<TypeReference>type).typeArguments[0]);
-            }
-            if (isTupleType(type)) {
-                for (const t of type.elementTypes) {
+            if (isArrayType(type) || isTupleType(type)) {
+                for (const t of (<TypeReference>type).typeArguments) {
                     if (reportWideningErrorsInType(t)) {
                         errorReported = true;
                     }
@@ -7448,7 +7498,6 @@ namespace ts {
         function couldContainTypeParameters(type: Type): boolean {
             return !!(type.flags & TypeFlags.TypeParameter ||
                 type.flags & TypeFlags.Reference && forEach((<TypeReference>type).typeArguments, couldContainTypeParameters) ||
-                type.flags & TypeFlags.Tuple && forEach((<TupleType>type).elementTypes, couldContainTypeParameters) ||
                 type.flags & TypeFlags.Anonymous && type.symbol && type.symbol.flags & (SymbolFlags.Method | SymbolFlags.TypeLiteral | SymbolFlags.Class) ||
                 type.flags & TypeFlags.UnionOrIntersection && couldUnionOrIntersectionContainTypeParameters(<UnionOrIntersectionType>type));
         }
@@ -7551,14 +7600,6 @@ namespace ts {
                         inferFromTypes(sourceTypes[i], targetTypes[i]);
                     }
                 }
-                else if (source.flags & TypeFlags.Tuple && target.flags & TypeFlags.Tuple && (<TupleType>source).elementTypes.length === (<TupleType>target).elementTypes.length) {
-                    // If source and target are tuples of the same size, infer from element types
-                    const sourceTypes = (<TupleType>source).elementTypes;
-                    const targetTypes = (<TupleType>target).elementTypes;
-                    for (let i = 0; i < sourceTypes.length; i++) {
-                        inferFromTypes(sourceTypes[i], targetTypes[i]);
-                    }
-                }
                 else if (target.flags & TypeFlags.UnionOrIntersection) {
                     const targetTypes = (<UnionOrIntersectionType>target).types;
                     let typeParameterCount = 0;
@@ -9103,10 +9144,6 @@ namespace ts {
                         return getInferredClassType(classSymbol);
                     }
                 }
-                const type = getContextuallyTypedThisType(container);
-                if (type) {
-                    return type;
-                }
 
                 const thisType = getThisTypeOfDeclaration(container);
                 if (thisType) {
@@ -9347,11 +9384,11 @@ namespace ts {
             }
         }
 
-        function getContextuallyTypedThisType(func: FunctionLikeDeclaration): Type {
+        function getContextualThisParameter(func: FunctionLikeDeclaration): Symbol {
             if (isContextSensitiveFunctionOrObjectLiteralMethod(func) && func.kind !== SyntaxKind.ArrowFunction) {
                 const contextualSignature = getContextualSignature(func);
                 if (contextualSignature) {
-                    return getThisTypeOfSignature(contextualSignature);
+                    return contextualSignature.thisParameter;
                 }
             }
 
@@ -9916,7 +9953,7 @@ namespace ts {
                 // If array literal is actually a destructuring pattern, mark it as an implied type. We do this such
                 // that we get the same behavior for "var [x, y] = []" and "[x, y] = []".
                 if (inDestructuringPattern && elementTypes.length) {
-                    const type = createNewTupleType(elementTypes);
+                    const type = cloneTypeReference(createTupleType(elementTypes));
                     type.pattern = node;
                     return type;
                 }
@@ -9930,7 +9967,7 @@ namespace ts {
                         for (let i = elementTypes.length; i < patternElements.length; i++) {
                             const patternElement = patternElements[i];
                             if (hasDefaultValue(patternElement)) {
-                                elementTypes.push((<TupleType>contextualType).elementTypes[i]);
+                                elementTypes.push((<TypeReference>contextualType).typeArguments[i]);
                             }
                             else {
                                 if (patternElement.kind !== SyntaxKind.OmittedExpression) {
@@ -11932,18 +11969,12 @@ namespace ts {
             // Function interface, since they have none by default. This is a bit of a leap of faith
             // that the user will not add any.
             const callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
-
             const constructSignatures = getSignaturesOfType(apparentType, SignatureKind.Construct);
-            // TS 1.0 spec: 4.12
-            // If FuncExpr is of type Any, or of an object type that has no call or construct signatures
-            // but is a subtype of the Function interface, the call is an untyped function call. In an
-            // untyped function call no TypeArgs are permitted, Args can be any argument list, no contextual
+
+            // TS 1.0 Spec: 4.12
+            // In an untyped function call no TypeArgs are permitted, Args can be any argument list, no contextual
             // types are provided for the argument expressions, and the result is always of type Any.
-            // We exclude union types because we may have a union of function types that happen to have
-            // no common signatures.
-            if (isTypeAny(funcType) ||
-                (isTypeAny(apparentType) && funcType.flags & TypeFlags.TypeParameter) ||
-                (!callSignatures.length && !constructSignatures.length && !(funcType.flags & TypeFlags.Union) && isTypeAssignableTo(funcType, globalFunctionType))) {
+            if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, constructSignatures.length)) {
                 // The unknownType indicates that an error already occurred (and was reported).  No
                 // need to report another error in this case.
                 if (funcType !== unknownType && node.typeArguments) {
@@ -11966,6 +11997,29 @@ namespace ts {
             return resolveCall(node, callSignatures, candidatesOutArray);
         }
 
+        /**
+         * TS 1.0 spec: 4.12
+         * If FuncExpr is of type Any, or of an object type that has no call or construct signatures
+         * but is a subtype of the Function interface, the call is an untyped function call.
+         */
+        function isUntypedFunctionCall(funcType: Type, apparentFuncType: Type, numCallSignatures: number, numConstructSignatures: number) {
+            if (isTypeAny(funcType)) {
+                return true;
+            }
+            if (isTypeAny(apparentFuncType) && funcType.flags & TypeFlags.TypeParameter) {
+                return true;
+            }
+            if (!numCallSignatures && !numConstructSignatures) {
+                // We exclude union types because we may have a union of function types that happen to have
+                // no common signatures.
+                if (funcType.flags & TypeFlags.Union) {
+                    return false;
+                }
+                return isTypeAssignableTo(funcType, globalFunctionType);
+            }
+            return false;
+        }
+
         function resolveNewExpression(node: NewExpression, candidatesOutArray: Signature[]): Signature {
             if (node.arguments && languageVersion < ScriptTarget.ES5) {
                 const spreadIndex = getSpreadArgumentIndex(node.arguments);
@@ -12091,8 +12145,9 @@ namespace ts {
             }
 
             const callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
+            const constructSignatures = getSignaturesOfType(apparentType, SignatureKind.Construct);
 
-            if (isTypeAny(tagType) || (!callSignatures.length && !(tagType.flags & TypeFlags.Union) && isTypeAssignableTo(tagType, globalFunctionType))) {
+            if (isUntypedFunctionCall(tagType, apparentType, callSignatures.length, constructSignatures.length)) {
                 return resolveUntypedCall(node);
             }
 
@@ -12137,7 +12192,8 @@ namespace ts {
             }
 
             const callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
-            if (funcType === anyType || (!callSignatures.length && !(funcType.flags & TypeFlags.Union) && isTypeAssignableTo(funcType, globalFunctionType))) {
+            const constructSignatures = getSignaturesOfType(apparentType, SignatureKind.Construct);
+            if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, constructSignatures.length)) {
                 return resolveUntypedCall(node);
             }
 
@@ -12294,6 +12350,12 @@ namespace ts {
 
         function assignContextualParameterTypes(signature: Signature, context: Signature, mapper: TypeMapper) {
             const len = signature.parameters.length - (signature.hasRestParameter ? 1 : 0);
+            if (context.thisParameter) {
+                if (!signature.thisParameter) {
+                    signature.thisParameter = createTransientSymbol(context.thisParameter, undefined);
+                }
+                assignTypeToParameterAndFixTypeParameters(signature.thisParameter, getTypeOfSymbol(context.thisParameter), mapper);
+            }
             for (let i = 0; i < len; i++) {
                 const parameter = signature.parameters[i];
                 const contextualParameterType = getTypeAtPosition(context, i);
@@ -13041,7 +13103,7 @@ namespace ts {
                         // such as NodeCheckFlags.LexicalThis on "this"expression.
                         checkExpression(element);
                         if (isTupleType(sourceType)) {
-                            error(element, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(sourceType), (<TupleType>sourceType).elementTypes.length, elements.length);
+                            error(element, Diagnostics.Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2, typeToString(sourceType), getTypeReferenceArity(<TypeReference>sourceType), elements.length);
                         }
                         else {
                             error(element, Diagnostics.Type_0_has_no_property_1, typeToString(sourceType), propName);
@@ -18518,7 +18580,7 @@ namespace ts {
             else if (isTypeOfKind(type, TypeFlags.StringLike)) {
                 return TypeReferenceSerializationKind.StringLikeType;
             }
-            else if (isTypeOfKind(type, TypeFlags.Tuple)) {
+            else if (isTupleType(type)) {
                 return TypeReferenceSerializationKind.ArrayLikeType;
             }
             else if (isTypeOfKind(type, TypeFlags.ESSymbol)) {
@@ -18729,7 +18791,13 @@ namespace ts {
                     (augmentations || (augmentations = [])).push(file.moduleAugmentations);
                 }
                 if (file.symbol && file.symbol.globalExports) {
-                    mergeSymbolTable(globals, file.symbol.globalExports);
+                    // Merge in UMD exports with first-in-wins semantics (see #9771)
+                    const source = file.symbol.globalExports;
+                    for (const id in source) {
+                        if (!(id in globals)) {
+                            globals[id] = source[id];
+                        }
+                    }
                 }
             });
 

src/compiler/commandLineParser.ts

@@ -885,7 +885,7 @@ namespace ts {
     function convertCompilerOptionsFromJsonWorker(jsonOptions: any,
         basePath: string, errors: Diagnostic[], configFileName?: string): CompilerOptions {
 
-        const options: CompilerOptions = getBaseFileName(configFileName) === "jsconfig.json" ? { allowJs: true } : {};
+        const options: CompilerOptions = getBaseFileName(configFileName) === "jsconfig.json" ? { allowJs: true, maxNodeModuleJsDepth: 2 } : {};
         convertOptionsFromJson(optionDeclarations, jsonOptions, basePath, options, Diagnostics.Unknown_compiler_option_0, errors);
         return options;
     }

src/compiler/declarationEmitter.ts

@@ -1132,8 +1132,10 @@ namespace ts {
                     // it if it's not a well known symbol. In that case, the text of the name will be exactly
                     // what we want, namely the name expression enclosed in brackets.
                     writeTextOfNode(currentText, node.name);
-                    // If optional property emit ?
-                    if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature || node.kind === SyntaxKind.Parameter) && hasQuestionToken(node)) {
+                    // If optional property emit ? but in the case of parameterProperty declaration with "?" indicating optional parameter for the constructor
+                    // we don't want to emit property declaration with "?"
+                    if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature ||
+                        (node.kind === SyntaxKind.Parameter && !isParameterPropertyDeclaration(node))) && hasQuestionToken(node)) {
                         write("?");
                     }
                     if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && node.parent.kind === SyntaxKind.TypeLiteral) {

src/compiler/diagnosticMessages.json

@@ -1955,6 +1955,10 @@
         "category": "Error",
         "code": 2691
     },
+    "'{0}' is a primitive, but '{1}' is a wrapper object. Prefer using '{0}' when possible.": {
+        "category": "Error",
+        "code": 2692
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
@@ -2867,11 +2871,7 @@
     "Element implicitly has an 'any' type because index expression is not of type 'number'.": {
         "category": "Error",
         "code": 7015
-    },
-    "Property '{0}' implicitly has type 'any', because its 'set' accessor lacks a type annotation.": {
-        "category": "Error",
-        "code": 7016
-    },
+    }, 
     "Index signature of object type implicitly has an 'any' type.": {
         "category": "Error",
         "code": 7017
@@ -2928,6 +2928,14 @@
         "category": "Error",
         "code": 7031
     },
+    "Property '{0}' implicitly has type 'any', because its set accessor lacks a parameter type annotation.": {
+        "category": "Error",
+        "code": 7032
+    },
+    "Property '{0}' implicitly has type 'any', because its get accessor lacks a return type annotation.": {
+        "category": "Error",
+        "code": 7033
+    },
     "You cannot rename this element.": {
         "category": "Error",
         "code": 8000

src/compiler/emitter.ts

@@ -1817,6 +1817,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 else if (node.parent.kind === SyntaxKind.ConditionalExpression && (<ConditionalExpression>node.parent).condition === node) {
                     return true;
                 }
+                else if (node.parent.kind === SyntaxKind.PrefixUnaryExpression || node.parent.kind === SyntaxKind.DeleteExpression ||
+                    node.parent.kind === SyntaxKind.TypeOfExpression || node.parent.kind === SyntaxKind.VoidExpression) {
+                    return true;
+                }
 
                 return false;
             }
@@ -6583,7 +6587,7 @@ const _super = (function (geti, seti) {
                             // import { x, y } from "foo"
                             // import d, * as x from "foo"
                             // import d, { x, y } from "foo"
-                            const isNakedImport = SyntaxKind.ImportDeclaration && !(<ImportDeclaration>node).importClause;
+                            const isNakedImport = node.kind === SyntaxKind.ImportDeclaration && !(<ImportDeclaration>node).importClause;
                             if (!isNakedImport) {
                                 write(varOrConst);
                                 write(getGeneratedNameForNode(<ImportDeclaration>node));

src/compiler/parser.ts

@@ -912,7 +912,7 @@ namespace ts {
             // Note: it is not actually necessary to save/restore the context flags here.  That's
             // because the saving/restoring of these flags happens naturally through the recursive
             // descent nature of our parser.  However, we still store this here just so we can
-            // assert that that invariant holds.
+            // assert that invariant holds.
             const saveContextFlags = contextFlags;
 
             // If we're only looking ahead, then tell the scanner to only lookahead as well.
@@ -2339,6 +2339,7 @@ namespace ts {
                     token() === SyntaxKind.LessThanToken ||
                     token() === SyntaxKind.QuestionToken ||
                     token() === SyntaxKind.ColonToken ||
+                    token() === SyntaxKind.CommaToken ||
                     canParseSemicolon();
             }
             return false;
@@ -2765,7 +2766,7 @@ namespace ts {
             // Note: for ease of implementation we treat productions '2' and '3' as the same thing.
             // (i.e. they're both BinaryExpressions with an assignment operator in it).
 
-            // First, do the simple check if we have a YieldExpression (production '5').
+            // First, do the simple check if we have a YieldExpression (production '6').
             if (isYieldExpression()) {
                 return parseYieldExpression();
             }
@@ -3373,24 +3374,40 @@ namespace ts {
         }
 
         /**
-         * Parse ES7 unary expression and await expression
+         * Parse ES7 exponential expression and await expression
+         *
+         * ES7 ExponentiationExpression:
+         *      1) UnaryExpression[?Yield]
+         *      2) UpdateExpression[?Yield] ** ExponentiationExpression[?Yield]
          *
-         * ES7 UnaryExpression:
-         *      1) SimpleUnaryExpression[?yield]
-         *      2) IncrementExpression[?yield] ** UnaryExpression[?yield]
          */
         function parseUnaryExpressionOrHigher(): UnaryExpression | BinaryExpression {
-            if (isAwaitExpression()) {
-                return parseAwaitExpression();
-            }
-
-            if (isIncrementExpression()) {
+            /**
+             * ES7 UpdateExpression:
+             *      1) LeftHandSideExpression[?Yield]
+             *      2) LeftHandSideExpression[?Yield][no LineTerminator here]++
+             *      3) LeftHandSideExpression[?Yield][no LineTerminator here]--
+             *      4) ++UnaryExpression[?Yield]
+             *      5) --UnaryExpression[?Yield]
+             */
+            if (isUpdateExpression()) {
                 const incrementExpression = parseIncrementExpression();
                 return token() === SyntaxKind.AsteriskAsteriskToken ?
                     <BinaryExpression>parseBinaryExpressionRest(getBinaryOperatorPrecedence(), incrementExpression) :
                     incrementExpression;
             }
 
+            /**
+             * ES7 UnaryExpression:
+             *      1) UpdateExpression[?yield]
+             *      2) delete UpdateExpression[?yield]
+             *      3) void UpdateExpression[?yield]
+             *      4) typeof UpdateExpression[?yield]
+             *      5) + UpdateExpression[?yield]
+             *      6) - UpdateExpression[?yield]
+             *      7) ~ UpdateExpression[?yield]
+             *      8) ! UpdateExpression[?yield]
+             */
             const unaryOperator = token();
             const simpleUnaryExpression = parseSimpleUnaryExpression();
             if (token() === SyntaxKind.AsteriskAsteriskToken) {
@@ -3408,8 +3425,8 @@ namespace ts {
         /**
          * Parse ES7 simple-unary expression or higher:
          *
-         * ES7 SimpleUnaryExpression:
-         *      1) IncrementExpression[?yield]
+         * ES7 UnaryExpression:
+         *      1) UpdateExpression[?yield]
          *      2) delete UnaryExpression[?yield]
          *      3) void UnaryExpression[?yield]
          *      4) typeof UnaryExpression[?yield]
@@ -3432,13 +3449,15 @@ namespace ts {
                     return parseTypeOfExpression();
                 case SyntaxKind.VoidKeyword:
                     return parseVoidExpression();
-                case SyntaxKind.AwaitKeyword:
-                    return parseAwaitExpression();
                 case SyntaxKind.LessThanToken:
                     // This is modified UnaryExpression grammar in TypeScript
                     //  UnaryExpression (modified):
                     //      < type > UnaryExpression
                     return parseTypeAssertion();
+                case SyntaxKind.AwaitKeyword:
+                    if (isAwaitExpression()) {
+                        return parseAwaitExpression();
+                    }
                 default:
                     return parseIncrementExpression();
             }
@@ -3447,14 +3466,14 @@ namespace ts {
         /**
          * Check if the current token can possibly be an ES7 increment expression.
          *
-         * ES7 IncrementExpression:
+         * ES7 UpdateExpression:
          *      LeftHandSideExpression[?Yield]
          *      LeftHandSideExpression[?Yield][no LineTerminator here]++
          *      LeftHandSideExpression[?Yield][no LineTerminator here]--
          *      ++LeftHandSideExpression[?Yield]
          *      --LeftHandSideExpression[?Yield]
          */
-        function isIncrementExpression(): boolean {
+        function isUpdateExpression(): boolean {
             // This function is called inside parseUnaryExpression to decide
             // whether to call parseSimpleUnaryExpression or call parseIncrementExpression directly
             switch (token()) {
@@ -3465,6 +3484,7 @@ namespace ts {
                 case SyntaxKind.DeleteKeyword:
                 case SyntaxKind.TypeOfKeyword:
                 case SyntaxKind.VoidKeyword:
+                case SyntaxKind.AwaitKeyword:
                     return false;
                 case SyntaxKind.LessThanToken:
                     // If we are not in JSX context, we are parsing TypeAssertion which is an UnaryExpression
@@ -5893,6 +5913,9 @@ namespace ts {
                     case SyntaxKind.BooleanKeyword:
                     case SyntaxKind.SymbolKeyword:
                     case SyntaxKind.VoidKeyword:
+                    case SyntaxKind.NullKeyword:
+                    case SyntaxKind.UndefinedKeyword:
+                    case SyntaxKind.NeverKeyword:
                         return parseTokenNode<JSDocType>();
                     case SyntaxKind.StringLiteral:
                     case SyntaxKind.NumericLiteral:

src/compiler/program.ts

@@ -717,8 +717,9 @@ namespace ts {
             const typesFile = tryReadTypesSection(packageJsonPath, candidate, state);
             if (typesFile) {
                 const onlyRecordFailures = !directoryProbablyExists(getDirectoryPath(typesFile), state.host);
-                // The package.json "typings" property must specify the file with extension, so just try that exact filename.
-                const result = tryFile(typesFile, failedLookupLocation, onlyRecordFailures, state);
+                // A package.json "typings" may specify an exact filename, or may choose to omit an extension.
+                const result = tryFile(typesFile, failedLookupLocation, onlyRecordFailures, state) ||
+                    tryAddingExtensions(typesFile, extensions, failedLookupLocation, onlyRecordFailures, state);
                 if (result) {
                     return result;
                 }
@@ -1097,7 +1098,7 @@ namespace ts {
         // - This calls resolveModuleNames, and then calls findSourceFile for each resolved module.
         // As all these operations happen - and are nested - within the createProgram call, they close over the below variables.
         // The current resolution depth is tracked by incrementing/decrementing as the depth first search progresses.
-        const maxNodeModulesJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 2;
+        const maxNodeModulesJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 0;
         let currentNodeModulesDepth = 0;
 
         // If a module has some of its imports skipped due to being at the depth limit under node_modules, then track

src/compiler/types.ts

@@ -351,6 +351,9 @@ namespace ts {
         JSDocPropertyTag,
         JSDocTypeLiteral,
         JSDocLiteralType,
+        JSDocNullKeyword,
+        JSDocUndefinedKeyword,
+        JSDocNeverKeyword,
 
         // Synthesized list
         SyntaxList,
@@ -383,7 +386,7 @@ namespace ts {
         FirstJSDocNode = JSDocTypeExpression,
         LastJSDocNode = JSDocLiteralType,
         FirstJSDocTagNode = JSDocComment,
-        LastJSDocTagNode = JSDocLiteralType
+        LastJSDocTagNode = JSDocNeverKeyword
     }
 
     export const enum NodeFlags {
@@ -2264,7 +2267,7 @@ namespace ts {
         Class                   = 1 << 15,  // Class
         Interface               = 1 << 16,  // Interface
         Reference               = 1 << 17,  // Generic type reference
-        Tuple                   = 1 << 18,  // Tuple
+        Tuple                   = 1 << 18,  // Synthesized generic tuple type
         Union                   = 1 << 19,  // Union (T | U)
         Intersection            = 1 << 20,  // Intersection (T & U)
         Anonymous               = 1 << 21,  // Anonymous
@@ -2386,11 +2389,6 @@ namespace ts {
         instantiations: Map<TypeReference>;   // Generic instantiation cache
     }
 
-    export interface TupleType extends ObjectType {
-        elementTypes: Type[];  // Element types
-        thisType?: Type;       // This-type of tuple (only needed for tuples that are constraints of type parameters)
-    }
-
     export interface UnionOrIntersectionType extends Type {
         types: Type[];                    // Constituent types
         /* @internal */

src/compiler/utilities.ts

@@ -301,6 +301,10 @@ namespace ts {
         return node.kind >= SyntaxKind.FirstJSDocNode && node.kind <= SyntaxKind.LastJSDocNode;
     }
 
+    export function isJSDocTag(node: Node) {
+        return node.kind >= SyntaxKind.FirstJSDocTagNode && node.kind <= SyntaxKind.LastJSDocTagNode;
+    }
+
     export function getNonDecoratorTokenPosOfNode(node: Node, sourceFile?: SourceFile): number {
         if (nodeIsMissing(node) || !node.decorators) {
             return getTokenPosOfNode(node, sourceFile);

src/harness/fourslash.ts

@@ -206,6 +206,24 @@ namespace FourSlash {
 
         private inputFiles = ts.createMap<string>();  // Map between inputFile's fileName and its content for easily looking up when resolving references
 
+        private static getDisplayPartsJson(displayParts: ts.SymbolDisplayPart[]) {
+            let result = "";
+            ts.forEach(displayParts, part => {
+                if (result) {
+                    result += ",\n    ";
+                }
+                else {
+                    result = "[\n    ";
+                }
+                result += JSON.stringify(part);
+            });
+            if (result) {
+                result += "\n]";
+            }
+
+            return result;
+        }
+
         // Add input file which has matched file name with the given reference-file path.
         // This is necessary when resolveReference flag is specified
         private addMatchedInputFile(referenceFilePath: string, extensions: string[]) {
@@ -806,6 +824,20 @@ namespace FourSlash {
             ts.forEachProperty(this.rangesByText(), ranges => this.verifyRangesReferenceEachOther(ranges));
         }
 
+        public verifyDisplayPartsOfReferencedSymbol(expected: ts.SymbolDisplayPart[]) {
+            const referencedSymbols = this.findReferencesAtCaret();
+
+            if (referencedSymbols.length === 0) {
+                this.raiseError("No referenced symbols found at current caret position");
+            }
+            else if (referencedSymbols.length > 1) {
+                this.raiseError("More than one referenced symbol found");
+            }
+
+            assert.equal(TestState.getDisplayPartsJson(referencedSymbols[0].definition.displayParts),
+                TestState.getDisplayPartsJson(expected), this.messageAtLastKnownMarker("referenced symbol definition display parts"));
+        }
+
         private verifyReferencesWorker(references: ts.ReferenceEntry[], fileName: string, start: number, end: number, isWriteAccess?: boolean, isDefinition?: boolean) {
             for (let i = 0; i < references.length; i++) {
                 const reference = references[i];
@@ -840,6 +872,10 @@ namespace FourSlash {
             return this.languageService.getReferencesAtPosition(this.activeFile.fileName, this.currentCaretPosition);
         }
 
+        private findReferencesAtCaret() {
+            return this.languageService.findReferences(this.activeFile.fileName, this.currentCaretPosition);
+        }
+
         public getSyntacticDiagnostics(expected: string) {
             const diagnostics = this.languageService.getSyntacticDiagnostics(this.activeFile.fileName);
             this.testDiagnostics(expected, diagnostics);
@@ -885,30 +921,12 @@ namespace FourSlash {
             displayParts: ts.SymbolDisplayPart[],
             documentation: ts.SymbolDisplayPart[]) {
 
-            function getDisplayPartsJson(displayParts: ts.SymbolDisplayPart[]) {
-                let result = "";
-                ts.forEach(displayParts, part => {
-                    if (result) {
-                        result += ",\n    ";
-                    }
-                    else {
-                        result = "[\n    ";
-                    }
-                    result += JSON.stringify(part);
-                });
-                if (result) {
-                    result += "\n]";
-                }
-
-                return result;
-            }
-
             const actualQuickInfo = this.languageService.getQuickInfoAtPosition(this.activeFile.fileName, this.currentCaretPosition);
             assert.equal(actualQuickInfo.kind, kind, this.messageAtLastKnownMarker("QuickInfo kind"));
             assert.equal(actualQuickInfo.kindModifiers, kindModifiers, this.messageAtLastKnownMarker("QuickInfo kindModifiers"));
             assert.equal(JSON.stringify(actualQuickInfo.textSpan), JSON.stringify(textSpan), this.messageAtLastKnownMarker("QuickInfo textSpan"));
-            assert.equal(getDisplayPartsJson(actualQuickInfo.displayParts), getDisplayPartsJson(displayParts), this.messageAtLastKnownMarker("QuickInfo displayParts"));
-            assert.equal(getDisplayPartsJson(actualQuickInfo.documentation), getDisplayPartsJson(documentation), this.messageAtLastKnownMarker("QuickInfo documentation"));
+            assert.equal(TestState.getDisplayPartsJson(actualQuickInfo.displayParts), TestState.getDisplayPartsJson(displayParts), this.messageAtLastKnownMarker("QuickInfo displayParts"));
+            assert.equal(TestState.getDisplayPartsJson(actualQuickInfo.documentation), TestState.getDisplayPartsJson(documentation), this.messageAtLastKnownMarker("QuickInfo documentation"));
         }
 
         public verifyRenameLocations(findInStrings: boolean, findInComments: boolean, ranges?: Range[]) {
@@ -3000,6 +3018,10 @@ namespace FourSlashInterface {
             this.state.verifyRangesReferenceEachOther(ranges);
         }
 
+        public findReferencesDefinitionDisplayPartsAtCaretAre(expected: ts.SymbolDisplayPart[]) {
+            this.state.verifyDisplayPartsOfReferencedSymbol(expected);
+        }
+
         public rangesWithSameTextReferenceEachOther() {
             this.state.verifyRangesWithSameTextReferenceEachOther();
         }

src/harness/harness.ts

@@ -1342,7 +1342,7 @@ namespace Harness {
             });
         }
 
-        export function doTypeAndSymbolBaseline(baselinePath: string, result: CompilerResult, allFiles: {unitName: string, content: string}[]) {
+        export function doTypeAndSymbolBaseline(baselinePath: string, result: CompilerResult, allFiles: {unitName: string, content: string}[], opts?: Harness.Baseline.BaselineOptions) {
             if (result.errors.length !== 0) {
                 return;
             }
@@ -1373,23 +1373,31 @@ namespace Harness {
 
             // Produce baselines.  The first gives the types for all expressions.
             // The second gives symbols for all identifiers.
-            let e1: Error, e2: Error;
+            let typesError: Error, symbolsError: Error;
             try {
                 checkBaseLines(/*isSymbolBaseLine*/ false);
             }
             catch (e) {
-                e1 = e;
+                typesError = e;
             }
 
             try {
                 checkBaseLines(/*isSymbolBaseLine*/ true);
             }
             catch (e) {
-                e2 = e;
+                symbolsError = e;
             }
 
-            if (e1 || e2) {
-                throw e1 || e2;
+            if (typesError && symbolsError) {
+                throw new Error(typesError.message + ts.sys.newLine + symbolsError.message);
+            }
+
+            if (typesError) {
+                throw typesError;
+            }
+
+            if (symbolsError) {
+                throw symbolsError;
             }
 
             return;
@@ -1399,7 +1407,12 @@ namespace Harness {
 
                 const fullExtension = isSymbolBaseLine ? ".symbols" : ".types";
 
-                Harness.Baseline.runBaseline(baselinePath.replace(/\.tsx?/, fullExtension), () => fullBaseLine);
+                // When calling this function from rwc-runner, the baselinePath will have no extension.
+                // As rwc test- file is stored in json which ".json" will get stripped off.
+                // When calling this function from compiler-runner, the baselinePath will then has either ".ts" or ".tsx" extension
+                const outputFileName = ts.endsWith(baselinePath, ".ts") || ts.endsWith(baselinePath, ".tsx") ?
+                    baselinePath.replace(/\.tsx?/, fullExtension) : baselinePath.concat(fullExtension);
+                Harness.Baseline.runBaseline(outputFileName, () => fullBaseLine, opts);
             }
 
             function generateBaseLine(typeWriterResults: ts.Map<TypeWriterResult[]>, isSymbolBaseline: boolean): string {

src/harness/rwcRunner.ts

@@ -158,13 +158,13 @@ namespace RWC {
 
 
             it("has the expected emitted code", () => {
-                Harness.Baseline.runBaseline(baseName + ".output.js", () => {
+                Harness.Baseline.runBaseline(`${baseName}.output.js`, () => {
                     return Harness.Compiler.collateOutputs(compilerResult.files);
                 }, baselineOpts);
             });
 
             it("has the expected declaration file content", () => {
-                Harness.Baseline.runBaseline(baseName + ".d.ts", () => {
+                Harness.Baseline.runBaseline(`${baseName}.d.ts`, () => {
                     if (!compilerResult.declFilesCode.length) {
                         return null;
                     }
@@ -174,7 +174,7 @@ namespace RWC {
             });
 
             it("has the expected source maps", () => {
-                Harness.Baseline.runBaseline(baseName + ".map", () => {
+                Harness.Baseline.runBaseline(`${baseName}.map`, () => {
                     if (!compilerResult.sourceMaps.length) {
                         return null;
                     }
@@ -192,7 +192,7 @@ namespace RWC {
             });*/
 
             it("has the expected errors", () => {
-                Harness.Baseline.runBaseline(baseName + ".errors.txt", () => {
+                Harness.Baseline.runBaseline(`${baseName}.errors.txt`, () => {
                     if (compilerResult.errors.length === 0) {
                         return null;
                     }
@@ -207,7 +207,7 @@ namespace RWC {
             // declaration file errors as part of the baseline.
             it("has the expected errors in generated declaration files", () => {
                 if (compilerOptions.declaration && !compilerResult.errors.length) {
-                    Harness.Baseline.runBaseline(baseName + ".dts.errors.txt", () => {
+                    Harness.Baseline.runBaseline(`${baseName}.dts.errors.txt`, () => {
                         const declFileCompilationResult = Harness.Compiler.compileDeclarationFiles(
                             inputFiles, otherFiles, compilerResult, /*harnessSettings*/ undefined, compilerOptions, currentDirectory);
 
@@ -223,10 +223,11 @@ namespace RWC {
             });
 
             it("has the expected types", () => {
+                // We don't need to pass the extension here because "doTypeAndSymbolBaseline" will append appropriate extension of ".types" or ".symbols"
                 Harness.Compiler.doTypeAndSymbolBaseline(baseName, compilerResult, inputFiles
                     .concat(otherFiles)
                     .filter(file => !!compilerResult.program.getSourceFile(file.unitName))
-                    .filter(e => !Harness.isDefaultLibraryFile(e.unitName)));
+                    .filter(e => !Harness.isDefaultLibraryFile(e.unitName)), baselineOpts);
             });
         });
     }

src/harness/unittests/convertCompilerOptionsFromJson.ts

@@ -403,6 +403,7 @@ namespace ts {
                 {
                     compilerOptions: <CompilerOptions>{
                         allowJs: true,
+                        maxNodeModuleJsDepth: 2,
                         module: ModuleKind.CommonJS,
                         target: ScriptTarget.ES5,
                         noImplicitAny: false,
@@ -429,6 +430,7 @@ namespace ts {
                 {
                     compilerOptions: <CompilerOptions>{
                         allowJs: false,
+                        maxNodeModuleJsDepth: 2,
                         module: ModuleKind.CommonJS,
                         target: ScriptTarget.ES5,
                         noImplicitAny: false,
@@ -450,7 +452,8 @@ namespace ts {
                 {
                     compilerOptions:
                     {
-                        allowJs: true
+                        allowJs: true,
+                        maxNodeModuleJsDepth: 2
                     },
                     errors: [{
                         file: undefined,
@@ -469,7 +472,8 @@ namespace ts {
                 {
                     compilerOptions:
                     {
-                        allowJs: true
+                        allowJs: true,
+                        maxNodeModuleJsDepth: 2
                     },
                     errors: <Diagnostic[]>[]
                 }

src/harness/unittests/jsDocParsing.ts

@@ -767,16 +767,9 @@ namespace ts {
                     parsesCorrectly(
                         "{null}",
                         `{
-    "kind": "JSDocTypeReference",
+    "kind": "NullKeyword",
     "pos": 1,
-    "end": 5,
-    "name": {
-        "kind": "Identifier",
-        "pos": 1,
-        "end": 5,
-        "originalKeywordKind": "NullKeyword",
-        "text": "null"
-    }
+    "end": 5
 }`);
                 });
 
@@ -784,16 +777,9 @@ namespace ts {
                     parsesCorrectly(
                         "{undefined}",
                         `{
-    "kind": "JSDocTypeReference",
+    "kind": "UndefinedKeyword",
     "pos": 1,
-    "end": 10,
-    "name": {
-        "kind": "Identifier",
-        "pos": 1,
-        "end": 10,
-        "originalKeywordKind": "UndefinedKeyword",
-        "text": "undefined"
-    }
+    "end": 10
 }`);
                 });
 
@@ -2379,4 +2365,4 @@ namespace ts {
             });
         });
     });
-}
+}

src/harness/unittests/services/formatting/testCode/testCode/formatting/classes.ts

@@ -1,79 +0,0 @@
-         class                    a                  {    
-                                                        constructor       (       n   :                 number    )             ;
-                                                        constructor       (       s   :                 string    )             ;
-                                                        constructor       (       ns   :                 any    )                            {    
-
-                                                        }
-
-                                                            public                 pgF       (           )                            {                  }   ;
-
-                                                            public                 pv   ;
-                                                            public                 get              d       (           )                            {    
-                                                                                                                return              30   ;
-                                                        }
-                                                            public                 set              d       (           )                            {    
-                                                        }
-
-                                                            public                 static                    get              p2       (           )                            {    
-                                                                                                                return                  {                  x   :                 30   ,                  y   :                 40              }   ;
-                                                        }
-
-                                                                         private                static                    d2       (           )                            {    
-                                                        }
-                                                                         private                static                    get              p3       (           )                            {    
-                                                                                                                return              "string"   ;
-                                                        }
-                                                                         private                pv3   ;
-
-                                                                         private                foo       (       n   :                 number    )             :                 string   ;
-                                                                         private                foo       (       s   :                 string    )             :                 string   ;
-                                                                         private                foo       (       ns   :                 any    )                            {    
-                                                                                                                return              ns.toString       (           )             ;
-                                                        }
-}
-
-         class                    b              extends              a                  {    
-}
-
-         class   m1b      { 
-
-}
-
-                                                interface   m1ib                               { 
-                                                        
-  }
-         class                    c              extends              m1b                  {    
-}
-
-         class                    ib2              implements              m1ib                  {    
-}
-
-    declare                            class                    aAmbient                  {    
-                                                        constructor                     (       n   :                 number    )             ;
-                                                        constructor                     (       s   :                 string    )             ;
-                                                            public                 pgF       (           )             :                 void   ;
-                                                            public                 pv   ;
-                                                            public                 d                 :                 number   ;
-                                                        static                    p2                 :                     {                  x   :                 number   ;              y   :                 number   ;              }   ;
-                                                        static                    d2       (           )             ;
-                                                        static                    p3   ;
-                                                                         private                pv3   ;
-                                                                         private                foo       (       s    )             ;
-}
-
-         class                    d                  {    
-                                                                         private                foo       (       n   :                 number    )             :                 string   ;
-                                                                         private                foo       (       ns   :                 any    )                            {    
-                                                                                                                return              ns.toString       (           )             ;
-                                                        }
-                                                                         private                foo       (       s   :                 string    )             :                 string   ;
-}
-
-         class                    e                  {    
-                                                                         private                foo       (       ns   :                 any    )                            {    
-                                                                                                                return              ns.toString       (           )             ;
-                                                        }
-                                                                         private                foo       (       s   :                 string    )             :                 string   ;
-                                                                         private                foo       (       n   :                 number    )             :                 string   ;
-}
-

src/harness/unittests/services/formatting/testCode/testCode/formatting/classesBaseline.ts

@@ -1,79 +0,0 @@
-class a {
-    constructor(n: number);
-    constructor(s: string);
-    constructor(ns: any) {
-
-    }
-
-    public pgF() { };
-
-    public pv;
-    public get d() {
-        return 30;
-    }
-    public set d() {
-    }
-
-    public static get p2() {
-        return { x: 30, y: 40 };
-    }
-
-    private static d2() {
-    }
-    private static get p3() {
-        return "string";
-    }
-    private pv3;
-
-    private foo(n: number): string;
-    private foo(s: string): string;
-    private foo(ns: any) {
-        return ns.toString();
-    }
-}
-
-class b extends a {
-}
-
-class m1b {
-
-}
-
-interface m1ib {
-
-}
-class c extends m1b {
-}
-
-class ib2 implements m1ib {
-}
-
-declare class aAmbient {
-    constructor(n: number);
-    constructor(s: string);
-    public pgF(): void;
-    public pv;
-    public d: number;
-    static p2: { x: number; y: number; };
-    static d2();
-    static p3;
-    private pv3;
-    private foo(s);
-}
-
-class d {
-    private foo(n: number): string;
-    private foo(ns: any) {
-        return ns.toString();
-    }
-    private foo(s: string): string;
-}
-
-class e {
-    private foo(ns: any) {
-        return ns.toString();
-    }
-    private foo(s: string): string;
-    private foo(n: number): string;
-}
-

src/harness/unittests/services/formatting/testCode/testCode/formatting/colonAndQMark.ts

@@ -1,4 +0,0 @@
-class foo {
-    constructor (n?: number, m? = 5, o?: string = "") { }
-    x:number = 1?2:3;
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/colonAndQMarkBaseline.ts

@@ -1,4 +0,0 @@
-class foo {
-    constructor(n?: number, m? = 5, o?: string = "") { }
-    x: number = 1 ? 2 : 3;
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/documentReadyFunction.ts

@@ -1,3 +0,0 @@
-$    (   document   )   .  ready  (   function   (   )   {   
-    alert    (           'i am ready'  )   ;
-           }                 );

src/harness/unittests/services/formatting/testCode/testCode/formatting/documentReadyFunctionBaseLine.ts

@@ -1,3 +0,0 @@
-$(document).ready(function() {
-    alert('i am ready');
-});

src/harness/unittests/services/formatting/testCode/testCode/formatting/emptyBlock.ts

@@ -1 +0,0 @@
-{}

src/harness/unittests/services/formatting/testCode/testCode/formatting/emptyBlockBaseline.ts

@@ -1 +0,0 @@
-{ }

src/harness/unittests/services/formatting/testCode/testCode/formatting/emptyInterfaceLiteral.ts

@@ -1,10 +0,0 @@
-    function    foo  (  x  :    {    }    )    {    }
-
-foo    (  {     }   )    ;
-
-
-    
-            interface    bar    {
-                x   :    {     }   ;
-       y  :       (         )    =>    {     }   ;   
-                                                    }

src/harness/unittests/services/formatting/testCode/testCode/formatting/emptyInterfaceLiteralBaseLine.ts

@@ -1,10 +0,0 @@
-function foo(x: {}) { }
-
-foo({});
-
-
-
-interface bar {
-    x: {};
-    y: () => {};
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/fatArrowFunctions.ts

@@ -1,112 +0,0 @@
-// valid    
-    (         )           =>    1  ;   
-    (        arg )           =>    2  ;   
-        arg       =>    2  ;   
-      (        arg     = 1 )           =>    3  ;   
-    (        arg    ?        )           =>    4  ;   
-    (        arg    :    number )           =>    5  ;   
-      (        arg    :    number     = 0 )           =>    6  ;   
-    (        arg        ?                  :    number )           =>    7  ;   
-    (                 ...     arg    :    number   [      ]    )           =>    8  ;   
-      (        arg1   ,    arg2 )           =>    12  ;   
-    (        arg1     = 1   ,    arg2     =3 )           =>    13  ;   
-      (        arg1    ?          ,    arg2    ?        )           =>    14  ;   
-    (        arg1    :    number   ,    arg2    :    number )           =>    15  ;   
-    (        arg1    :    number     = 0   ,    arg2    :    number     = 1 )           =>    16  ;   
-      (        arg1    ?           :    number   ,    arg2    ?           :    number )           =>    17  ;   
-    (        arg1   ,             ...     arg2    :    number   [      ]    )           =>    18  ;   
-      (        arg1   ,    arg2    ?           :    number )           =>    19  ;   
-
-// in paren
-    (            (         )           =>    21 )      ;   
-    (            (        arg )           =>    22 )      ;   
-    (            (        arg     = 1 )           =>    23 )      ;   
-    (            (        arg    ?        )           =>    24 )      ;   
-    (            (        arg    :    number )           =>    25 )      ;   
-    (            (        arg    :    number     = 0 )           =>    26 )      ;   
-    (            (        arg    ?           :    number )           =>    27 )      ;   
-    (            (                 ...     arg    :    number   [      ]    )           =>    28 )      ;   
-
-// in multiple paren
-    (            (            (            (            (        arg )           =>    { return 32  ;    } )     )     )     )      ;   
-
-// in ternary exression
-      false        ?            (         )           =>    41     :    null  ;   
-   false        ?            (        arg )           =>    42     :    null  ;   
-    false        ?            (        arg     = 1 )           =>    43     :    null  ;   
-      false        ?            (        arg    ?        )           =>    44     :    null  ;   
-    false        ?            (        arg    :    number )           =>    45     :    null  ;   
-   false        ?            (        arg    ?           :    number )           =>    46     :    null  ;   
-      false        ?            (        arg    ?           :    number     = 0 )           =>    47     :    null  ;   
-   false        ?            (                 ...     arg    :    number   [      ]    )           =>    48     :    null  ;   
-
-// in ternary exression within paren
-   false        ?            (            (         )           =>    51 )         :    null  ;   
-    false        ?            (            (        arg )           =>    52 )         :    null  ;   
-    false        ?            (            (        arg     = 1 )           =>    53 )         :    null  ;   
-      false        ?            (            (        arg    ?        )           =>    54 )         :    null  ;   
-    false        ?            (            (        arg    :    number )           =>    55 )         :    null  ;   
-      false        ?            (            (        arg    ?           :    number )           =>    56 )         :    null  ;   
-    false        ?            (            (        arg    ?           :    number     = 0 )           =>    57 )         :    null  ;   
-   false        ?            (            (                 ...     arg    :    number   [      ]    )           =>    58 )         :    null  ;   
-
-// ternary exression's else clause
-   false        ?        null     :        (         )           =>    61  ;   
-        false        ?        null     :        (        arg )           =>    62  ;   
-   false        ?        null     :        (        arg     = 1 )           =>    63  ;   
-      false        ?        null     :        (        arg    ?        )           =>    64  ;   
-   false        ?        null     :        (        arg    :    number )           =>    65  ;   
-    false        ?        null     :        (        arg    ?           :    number )           =>    66  ;   
-        false        ?        null     :        (        arg    ?           :    number     = 0 )           =>    67  ;   
-    false        ?        null     :        (                 ...     arg    :    number   [      ]    )           =>    68  ;   
-
-
-// nested ternary expressions
-    (        a    ?        )           =>    { return a  ;    }     ?            (        b    ?         )           =>    { return b  ;    }     :        (        c    ?         )           =>    { return c  ;    }  ;   
-
-//multiple levels
-    (        a    ?        )           =>    { return a  ;    }     ?            (        b )          =>       (        c )          =>   81     :        (        c )          =>       (        d )          =>   82  ;   
-
-
-// In Expressions
-    (            (        arg )           =>    90 )     instanceof Function  ;   
-      (            (        arg     = 1 )           =>    91 )     instanceof Function  ;   
-        (            (        arg    ?         )           =>    92 )     instanceof Function  ;   
-      (            (        arg    :    number )           =>    93 )     instanceof Function  ;   
-    (            (        arg    :    number     = 1 )           =>    94 )     instanceof Function  ;   
-        (            (        arg    ?           :    number )           =>    95 )     instanceof Function  ;   
-      (            (                 ...     arg    :    number   [      ]    )           =>    96 )     instanceof Function  ;   
-
-''    +        (        arg )           =>    100  ;   
-        (            (        arg )           =>    0 )        +    ''    +        (        arg )           =>    101  ;   
-          (            (        arg     = 1 )           =>    0 )        +    ''    +        (        arg     = 2 )           =>    102  ;   
-    (            (        arg    ?        )           =>    0 )        +    ''    +        (        arg    ?        )           =>    103  ;   
-      (            (        arg    :   number )           =>    0 )        +    ''    +        (        arg    :   number )           =>    104  ;   
-        (            (        arg    :   number     = 1 )           =>    0 )        +    ''    +        (        arg    :   number     = 2 )           =>    105  ;   
-    (            (        arg    ?           :   number     = 1 )           =>    0 )        +    ''    +        (        arg    ?           :   number     = 2 )           =>    106  ;   
-      (            (                 ...     arg    :   number   [      ]    )           =>    0 )        +    ''    +        (                 ...     arg    :   number   [      ]    )           =>    107  ;   
-    (            (        arg1   ,    arg2    ?        )           =>    0 )        +    ''    +        (        arg1   ,   arg2    ?        )           =>    108  ;   
-      (            (        arg1   ,             ...     arg2    :   number   [      ]    )           =>    0 )        +    ''    +        (        arg1   ,             ...     arg2    :   number   [      ]    )           =>    108  ;   
-
-
-// Function Parameters
-function foo    (                 ...     arg    :    any   [      ]    )     { }
-
-foo    (        
-        (        a )           =>    110   ,    
-        (            (        a )           =>    111 )       ,    
-        (        a )           =>    {
-        return 112  ;   
-    }   ,   
-        (        a    ?         )           =>    113   ,    
-        (        a   ,    b    ?         )           =>    114   ,    
-        (        a    :    number )           =>    115   ,    
-        (        a    :    number     = 0 )           =>    116   ,    
-        (        a     = 0 )           =>    117   ,    
-        (        a    ?           :    number     = 0 )           =>    118   ,    
-        (        a    ?    ,   b   ?          :    number     = 0 )           =>    118   ,    
-        (                 ...     a    :    number   [      ]    )           =>    119   ,    
-        (        a   ,    b    ?            = 0   ,             ...     c    :    number   [      ]    )           =>    120   ,   
-        (        a )           =>        (        b )           =>        (        c )           =>    121   ,   
-        false       ?            (        a )           =>    0     :        (        b )           =>    122
- )      ;   

src/harness/unittests/services/formatting/testCode/testCode/formatting/fatArrowFunctionsBaseline.ts

@@ -1,112 +0,0 @@
-// valid    
-() => 1;
-(arg) => 2;
-arg => 2;
-(arg = 1) => 3;
-(arg?) => 4;
-(arg: number) => 5;
-(arg: number = 0) => 6;
-(arg?: number) => 7;
-(...arg: number[]) => 8;
-(arg1, arg2) => 12;
-(arg1 = 1, arg2 = 3) => 13;
-(arg1?, arg2?) => 14;
-(arg1: number, arg2: number) => 15;
-(arg1: number = 0, arg2: number = 1) => 16;
-(arg1?: number, arg2?: number) => 17;
-(arg1, ...arg2: number[]) => 18;
-(arg1, arg2?: number) => 19;
-
-// in paren
-(() => 21);
-((arg) => 22);
-((arg = 1) => 23);
-((arg?) => 24);
-((arg: number) => 25);
-((arg: number = 0) => 26);
-((arg?: number) => 27);
-((...arg: number[]) => 28);
-
-// in multiple paren
-(((((arg) => { return 32; }))));
-
-// in ternary exression
-false ? () => 41 : null;
-false ? (arg) => 42 : null;
-false ? (arg = 1) => 43 : null;
-false ? (arg?) => 44 : null;
-false ? (arg: number) => 45 : null;
-false ? (arg?: number) => 46 : null;
-false ? (arg?: number = 0) => 47 : null;
-false ? (...arg: number[]) => 48 : null;
-
-// in ternary exression within paren
-false ? (() => 51) : null;
-false ? ((arg) => 52) : null;
-false ? ((arg = 1) => 53) : null;
-false ? ((arg?) => 54) : null;
-false ? ((arg: number) => 55) : null;
-false ? ((arg?: number) => 56) : null;
-false ? ((arg?: number = 0) => 57) : null;
-false ? ((...arg: number[]) => 58) : null;
-
-// ternary exression's else clause
-false ? null : () => 61;
-false ? null : (arg) => 62;
-false ? null : (arg = 1) => 63;
-false ? null : (arg?) => 64;
-false ? null : (arg: number) => 65;
-false ? null : (arg?: number) => 66;
-false ? null : (arg?: number = 0) => 67;
-false ? null : (...arg: number[]) => 68;
-
-
-// nested ternary expressions
-(a?) => { return a; } ? (b?) => { return b; } : (c?) => { return c; };
-
-//multiple levels
-(a?) => { return a; } ? (b) => (c) => 81 : (c) => (d) => 82;
-
-
-// In Expressions
-((arg) => 90) instanceof Function;
-((arg = 1) => 91) instanceof Function;
-((arg?) => 92) instanceof Function;
-((arg: number) => 93) instanceof Function;
-((arg: number = 1) => 94) instanceof Function;
-((arg?: number) => 95) instanceof Function;
-((...arg: number[]) => 96) instanceof Function;
-
-'' + (arg) => 100;
-((arg) => 0) + '' + (arg) => 101;
-((arg = 1) => 0) + '' + (arg = 2) => 102;
-((arg?) => 0) + '' + (arg?) => 103;
-((arg: number) => 0) + '' + (arg: number) => 104;
-((arg: number = 1) => 0) + '' + (arg: number = 2) => 105;
-((arg?: number = 1) => 0) + '' + (arg?: number = 2) => 106;
-((...arg: number[]) => 0) + '' + (...arg: number[]) => 107;
-((arg1, arg2?) => 0) + '' + (arg1, arg2?) => 108;
-((arg1, ...arg2: number[]) => 0) + '' + (arg1, ...arg2: number[]) => 108;
-
-
-// Function Parameters
-function foo(...arg: any[]) { }
-
-foo(
-        (a) => 110,
-        ((a) => 111),
-        (a) => {
-            return 112;
-        },
-        (a?) => 113,
-        (a, b?) => 114,
-        (a: number) => 115,
-        (a: number = 0) => 116,
-        (a = 0) => 117,
-        (a?: number = 0) => 118,
-        (a?, b?: number = 0) => 118,
-        (...a: number[]) => 119,
-        (a, b? = 0, ...c: number[]) => 120,
-        (a) => (b) => (c) => 121,
-        false ? (a) => 0 : (b) => 122
- );

src/harness/unittests/services/formatting/testCode/testCode/formatting/formatDebuggerStatement.ts

@@ -1,2 +0,0 @@
-if(false){debugger;}
-  if    (   false   )   {    debugger  ;   }

src/harness/unittests/services/formatting/testCode/testCode/formatting/formatDebuggerStatementBaseline.ts

@@ -1,2 +0,0 @@
-if (false) { debugger; }
-if (false) { debugger; }

src/harness/unittests/services/formatting/testCode/testCode/formatting/formatvariableDeclarationList.ts

@@ -1,13 +0,0 @@
-var   fun1   =   function   (     )     {   
-            var               x   =   'foo'             ,
-                z   =   'bar'           ;
-                return  x            ;
-},
-
-fun2   =   (                function        (   f               )   {
-            var   fun   =   function   (        )       {
-                        console         .  log             (           f     (  )  )       ;
-            },
-            x   =   'Foo'           ;
-                return   fun            ;
-}   (           fun1            )   )       ;

src/harness/unittests/services/formatting/testCode/testCode/formatting/formatvariableDeclarationListBaseline.ts

@@ -1,13 +0,0 @@
-var fun1 = function() {
-    var x = 'foo',
-        z = 'bar';
-    return x;
-},
-
-fun2 = (function(f) {
-    var fun = function() {
-        console.log(f());
-    },
-    x = 'Foo';
-    return fun;
-} (fun1));

src/harness/unittests/services/formatting/testCode/testCode/formatting/implicitModule.ts

@@ -1,3 +0,0 @@
-        export class A {
-
-        }

src/harness/unittests/services/formatting/testCode/testCode/formatting/implicitModuleBaseline.ts

@@ -1,3 +0,0 @@
-export class A {
-
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/importDeclaration.ts

@@ -1,6 +0,0 @@
-module Foo {
-}
-
-import bar  =    Foo;
-
-import bar2=Foo;

src/harness/unittests/services/formatting/testCode/testCode/formatting/importDeclarationBaseline.ts

@@ -1,6 +0,0 @@
-module Foo {
-}
-
-import bar = Foo;
-
-import bar2 = Foo;

src/harness/unittests/services/formatting/testCode/testCode/formatting/main.ts

@@ -1,95 +0,0 @@
-
-var a;var c          , b;var  $d
-var $e 
-var f
-a++;b++;
-
-function        f     (     )        {
-    for (i = 0; i < 10; i++) {
-        k = abc + 123 ^ d;
-        a = XYZ[m  (a[b[c][d]])];
-        break;
-
-        switch ( variable){
-       case  1: abc += 425;
-break;
-case 404 : a [x--/2]%=3 ;
-                    break ;
-                case vari : v[--x ] *=++y*( m + n / k[z]);
-                for (a in b){
-             for (a = 0; a < 10; ++a) {
-              a++;--a;
-                   if (a == b) {
-                          a++;b--;
-                     }
-else
-if (a == c){
-++a;
-(--c)+=d;
-$c = $a + --$b;
-}
-if (a == b)
-if (a != b) {
- if (a !== b)
- if (a === b)
- --a;
- else
-  --a;
-  else {
-  a--;++b;
-a++
-                    }
-                    }
-                    }
-                    for (x in y) {
-m-=m;
-k=1+2+3+4;
-}
-}
-    break;
-                
-    }
-    }
-    var a  ={b:function(){}};
-    return {a:1,b:2}
-}
-
-var z = 1;
-            for (i = 0; i < 10; i++)
-     for (j = 0; j < 10; j++)
-for (k = 0; k < 10; ++k) { 
-z++;
-}
-
-for (k = 0; k < 10; k += 2) { 
-z++;
-}
-
-    $(document).ready ();
-
-
- function  pageLoad() {
- $('#TextBox1' ) .     unbind   (  ) ;
-$('#TextBox1' ) . datepicker ( ) ; 
-}
-
-        function pageLoad    (     )    {
-    var webclass=[
-                { 'student'     :
-                { 'id': '1', 'name': 'Linda Jones', 'legacySkill': 'Access, VB 5.0' }
-        }   ,
-{    'student':
-{'id':'2','name':'Adam Davidson','legacySkill':'Cobol,MainFrame'}
-}      ,
-    { 'student':
-{   'id':'3','name':'Charles Boyer' ,'legacySkill':'HTML, XML'}
-}
-    ];
-
-$create(Sys.UI.DataView,{data:webclass},null,null,$get('SList'));
-
-} 
-
-$( document ).ready(function(){
-alert('hello');
-    } ) ;

src/harness/unittests/services/formatting/testCode/testCode/formatting/mainBaseline.ts

@@ -1,98 +0,0 @@
-
-var a; var c, b; var $d
-var $e
-var f
-a++; b++;
-
-function f() {
-    for (i = 0; i < 10; i++) {
-        k = abc + 123 ^ d;
-        a = XYZ[m(a[b[c][d]])];
-        break;
-
-        switch (variable) {
-            case 1: abc += 425;
-                break;
-            case 404: a[x-- / 2] %= 3;
-                break;
-            case vari: v[--x] *= ++y * (m + n / k[z]);
-                for (a in b) {
-                    for (a = 0; a < 10; ++a) {
-                        a++; --a;
-                        if (a == b) {
-                            a++; b--;
-                        }
-                        else
-                            if (a == c) {
-                                ++a;
-                                (--c) += d;
-                                $c = $a + --$b;
-                            }
-                        if (a == b)
-                            if (a != b) {
-                                if (a !== b)
-                                    if (a === b)
-                                        --a;
-                                    else
-                                        --a;
-                                else {
-                                    a--; ++b;
-                                    a++
-                                }
-                            }
-                    }
-                    for (x in y) {
-                        m -= m;
-                        k = 1 + 2 + 3 + 4;
-                    }
-                }
-                break;
-
-        }
-    }
-    var a = { b: function() { } };
-    return { a: 1, b: 2 }
-}
-
-var z = 1;
-for (i = 0; i < 10; i++)
-    for (j = 0; j < 10; j++)
-        for (k = 0; k < 10; ++k) {
-            z++;
-        }
-
-for (k = 0; k < 10; k += 2) {
-    z++;
-}
-
-$(document).ready();
-
-
-function pageLoad() {
-    $('#TextBox1').unbind();
-    $('#TextBox1').datepicker();
-}
-
-function pageLoad() {
-    var webclass = [
-                {
-                    'student':
-                    { 'id': '1', 'name': 'Linda Jones', 'legacySkill': 'Access, VB 5.0' }
-                },
-{
-    'student':
-    { 'id': '2', 'name': 'Adam Davidson', 'legacySkill': 'Cobol,MainFrame' }
-},
-    {
-        'student':
-    { 'id': '3', 'name': 'Charles Boyer', 'legacySkill': 'HTML, XML' }
-    }
-    ];
-
-    $create(Sys.UI.DataView, { data: webclass }, null, null, $get('SList'));
-
-}
-
-$(document).ready(function() {
-    alert('hello');
-});

src/harness/unittests/services/formatting/testCode/testCode/formatting/moduleIndentation.ts

@@ -1,3 +0,0 @@
-   module     Foo    {
-     export    module    A  .   B  .   C     {      }
-                }

src/harness/unittests/services/formatting/testCode/testCode/formatting/moduleIndentationBaseline.ts

@@ -1,3 +0,0 @@
-module Foo {
-    export module A.B.C { }
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/modules.ts

@@ -1,76 +0,0 @@
-                     module                mod1                  {    
-                                                            export                                class                    b                  {    
-                                                        }
-                                                                 class                    d                  {    
-                                                        }
-
-
-                                                            export                       interface              ib                  {    
-                                                        }
-}
-
-                     module                m2                  {    
-
-                                                            export                                            module                m3                  {    
-                                                                                                                    export                                class                    c              extends              mod1.b                  {    
-                                                                                                                }
-                                                                                                                    export                                class                    ib2              implements              mod1.ib                  {    
-                                                                                                                }
-                                                        }
-}
-
-         class                    c              extends              mod1.b                  {    
-}
-
-         class                    ib2              implements              mod1.ib                  {    
-}
-
-                    declare               export           module         "m4"         {
-                                          export           class         d         {
-                                    }   ;     
-                                    var         x         :         d   ;     
-                                          export           function         foo      (           )     :         d   ;     
-}
-
-                 import         m4         =         module      (       "m4"    )        ;     
-      export           var         x4         =         m4.x   ;     
-      export           var         d4         =         m4.d   ;     
-      export           var         f4         =         m4.foo      (           )        ;     
-
-      export           module         m1         {
-                                                        declare               export           module         "m2"         {
-                                                                              export           class         d         {
-                                                                        }   ;     
-                                                                        var         x:         d   ;     
-                                                                              export           function         foo      (           )     :         d   ;     
-                                    }
-                                                     import         m2         =         module      (       "m2"    )        ;     
-                                                     import         m3         =         module      (       "m4"    )        ;     
-
-                                          export           var         x2         =         m2.x   ;     
-                                          export           var         d2         =         m2.d   ;     
-                                          export           var         f2         =         m2.foo      (           )        ;     
-
-                                          export           var         x3         =         m3.x   ;     
-                                          export           var         d3         =         m3.d   ;     
-                                          export           var         f3         =         m3.foo      (           )        ;     
-}
-
-      export           var         x2         =         m1.m2.x   ;     
-      export           var         d2         =         m1.m2.d   ;     
-      export           var         f2         =         m1.m2.foo      (           )        ;     
-
-      export           var         x3         =         m1.m3.x   ;     
-      export           var         d3         =         m1.m3.d   ;     
-      export           var         f3         =         m1.m3.foo      (           )        ;     
-
-      export           module         m5         {
-                                          export           var         x2         =         m1.m2.x   ;     
-                                          export           var         d2         =         m1.m2.d   ;     
-                                          export           var         f2         =         m1.m2.foo      (           )        ;     
-
-                                          export           var         x3         =         m1.m3.x   ;     
-                                          export           var         d3         =         m1.m3.d   ;     
-                                          export           var         f3         =         m1.m3.foo      (           )        ;     
-}
-

src/harness/unittests/services/formatting/testCode/testCode/formatting/modulesBaseline.ts

@@ -1,76 +0,0 @@
-module mod1 {
-    export class b {
-    }
-    class d {
-    }
-
-
-    export interface ib {
-    }
-}
-
-module m2 {
-
-    export module m3 {
-        export class c extends mod1.b {
-        }
-        export class ib2 implements mod1.ib {
-        }
-    }
-}
-
-class c extends mod1.b {
-}
-
-class ib2 implements mod1.ib {
-}
-
-declare export module "m4" {
-    export class d {
-    };
-    var x: d;
-    export function foo(): d;
-}
-
-import m4 = module("m4");
-export var x4 = m4.x;
-export var d4 = m4.d;
-export var f4 = m4.foo();
-
-export module m1 {
-    declare export module "m2" {
-        export class d {
-        };
-        var x: d;
-        export function foo(): d;
-    }
-    import m2 = module("m2");
-    import m3 = module("m4");
-
-    export var x2 = m2.x;
-    export var d2 = m2.d;
-    export var f2 = m2.foo();
-
-    export var x3 = m3.x;
-    export var d3 = m3.d;
-    export var f3 = m3.foo();
-}
-
-export var x2 = m1.m2.x;
-export var d2 = m1.m2.d;
-export var f2 = m1.m2.foo();
-
-export var x3 = m1.m3.x;
-export var d3 = m1.m3.d;
-export var f3 = m1.m3.foo();
-
-export module m5 {
-    export var x2 = m1.m2.x;
-    export var d2 = m1.m2.d;
-    export var f2 = m1.m2.foo();
-
-    export var x3 = m1.m3.x;
-    export var d3 = m1.m3.d;
-    export var f3 = m1.m3.foo();
-}
-

src/harness/unittests/services/formatting/testCode/testCode/formatting/objectLiteral.ts

@@ -1,27 +0,0 @@
-var x = {foo: 1,
-bar: "tt",
-boo: 1 + 5};
-
-var x2 = {foo: 1,
-bar: "tt",boo:1+5};
-
-function Foo() {
-var typeICalc = {
-clear: {
-"()": [1, 2, 3]
-}
-}
-}
-
-// Rule for object literal members for the "value" of the memebr to follow the indent
-// of the member, i.e. the relative position of the value is maintained when the member
-// is indented.
-var x2 = {
-  foo:
-3,
-          'bar':
-                    { a: 1, b : 2}
-};
-
-var x={    };
-var y = {};

src/harness/unittests/services/formatting/testCode/testCode/formatting/objectLiteralBaseline.ts

@@ -1,31 +0,0 @@
-var x = {
-    foo: 1,
-    bar: "tt",
-    boo: 1 + 5
-};
-
-var x2 = {
-    foo: 1,
-    bar: "tt", boo: 1 + 5
-};
-
-function Foo() {
-    var typeICalc = {
-        clear: {
-            "()": [1, 2, 3]
-        }
-    }
-}
-
-// Rule for object literal members for the "value" of the memebr to follow the indent
-// of the member, i.e. the relative position of the value is maintained when the member
-// is indented.
-var x2 = {
-    foo:
-  3,
-    'bar':
-              { a: 1, b: 2 }
-};
-
-var x = {};
-var y = {};

src/harness/unittests/services/formatting/testCode/testCode/formatting/onClosingBracket.ts

@@ -1,32 +0,0 @@
-function f( ) {
-var     x = 3;
-    var z = 2   ;
-    a  = z  ++ - 2 *  x ;
-        for ( ; ; ) {
-    a+=(g +g)*a%t;
-        b --                          ;
-}
-
-    switch ( a  )
-    {
-        case 1  :     {
-    a ++  ;
-        b--;
-    if(a===a)
-                return;
-    else
-        {
-            for(a in b)
-                if(a!=a)
-    {
-    for(a in b)
-            {
-a++;
-        }
-                }
-    }
-        }
-    default:
-        break;
-    }
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/onClosingBracketBaseLine.ts

@@ -1,28 +0,0 @@
-function f() {
-    var x = 3;
-    var z = 2;
-    a = z++ - 2 * x;
-    for (; ;) {
-        a += (g + g) * a % t;
-        b--;
-    }
-
-    switch (a) {
-        case 1: {
-            a++;
-            b--;
-            if (a === a)
-                return;
-            else {
-                for (a in b)
-                    if (a != a) {
-                        for (a in b) {
-                            a++;
-                        }
-                    }
-            }
-        }
-        default:
-            break;
-    }
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/onSemiColon.ts

@@ -1 +0,0 @@
-var  a=b+c^d-e*++f;

src/harness/unittests/services/formatting/testCode/testCode/formatting/onSemiColonBaseline.ts

@@ -1 +0,0 @@
-var a = b + c ^ d - e * ++f;

src/harness/unittests/services/formatting/testCode/testCode/formatting/spaceAfterConstructor.ts

@@ -1 +0,0 @@
-class test { constructor                   () { } }

src/harness/unittests/services/formatting/testCode/testCode/formatting/spaceAfterConstructorBaseline.ts

@@ -1 +0,0 @@
-class test { constructor() { } }

src/harness/unittests/services/formatting/testCode/testCode/formatting/tabAfterCloseCurly.ts

@@ -1,10 +0,0 @@
-module Tools {
-    export enum NodeType {
-        Error,
-        Comment,
-    }	
-    export enum foob
-    {
-        Blah=1, Bleah=2
-    }
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/tabAfterCloseCurlyBaseline.ts

@@ -1,9 +0,0 @@
-module Tools {
-    export enum NodeType {
-        Error,
-        Comment,
-    }
-    export enum foob {
-        Blah = 1, Bleah = 2
-    }
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/typescriptConstructs.ts

@@ -1,65 +0,0 @@
-     module MyModule 
-     {
-                module A.B.C {
-module F {
-}
-                   }
-interface Blah 
-{
-boo: string;
-}
-    
- class Foo 
- {
-      
-}
-      
-class Foo2 {
-public foo():number {
-return 5 * 6;
-}
-public foo2() {
-if (1 === 2)
-                          
-
-{
-var y     :   number= 76;
-return y;
-}
-
-                            while (2 == 3)               {              
-  if (    y      ==       null     )       {     
-                    
-}
- }
-}
-
-public foo3() {
-if (1 === 2)
-                          
-//comment preventing line merging
-{
-var y = 76;
-return y;
-}
-
-}
- }
-     }
-
-function foo(a:number, b:number):number
-{
-return 0;
-}
-
-function bar(a:number, b:number) :number[]       {
-return [];
-}
-
-module BugFix3 {
-declare var f: { 
- (): any;
-   (x: number): string;
-       foo: number;
-};
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/typescriptConstructsBaseline.ts

@@ -1,58 +0,0 @@
-module MyModule {
-    module A.B.C {
-        module F {
-        }
-    }
-    interface Blah {
-        boo: string;
-    }
-
-    class Foo {
-
-    }
-
-    class Foo2 {
-        public foo(): number {
-            return 5 * 6;
-        }
-        public foo2() {
-            if (1 === 2) {
-                var y: number = 76;
-                return y;
-            }
-
-            while (2 == 3) {
-                if (y == null) {
-
-                }
-            }
-        }
-
-        public foo3() {
-            if (1 === 2)
-
-                //comment preventing line merging
-            {
-                var y = 76;
-                return y;
-            }
-
-        }
-    }
-}
-
-function foo(a: number, b: number): number {
-    return 0;
-}
-
-function bar(a: number, b: number): number[] {
-    return [];
-}
-
-module BugFix3 {
-    declare var f: {
-        (): any;
-        (x: number): string;
-        foo: number;
-    };
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/various.ts

@@ -1,17 +0,0 @@
-function f(a,b,c,d){
-for(var i=0;i<10;i++){
-var a=0;
-var b=a+a+a*a%a/2-1;
-b+=a;
-++b;
-f(a,b,c,d);
-if(1===1){
-var m=function(e,f){
-return e^f;
-}
-}
-}
-}
-
-for (var i = 0   ; i < this.foo(); i++) {
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/variousBaseline.ts

@@ -1,17 +0,0 @@
-function f(a, b, c, d) {
-    for (var i = 0; i < 10; i++) {
-        var a = 0;
-        var b = a + a + a * a % a / 2 - 1;
-        b += a;
-        ++b;
-        f(a, b, c, d);
-        if (1 === 1) {
-            var m = function(e, f) {
-                return e ^ f;
-            }
-        }
-    }
-}
-
-for (var i = 0   ; i < this.foo(); i++) {
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/withStatement.ts

@@ -1,9 +0,0 @@
-with (foo.bar) 
-
-   {
-
-     }
-
-with (bar.blah)
-{
-}

src/harness/unittests/services/formatting/testCode/testCode/formatting/withStatementBaseline.ts

@@ -1,6 +0,0 @@
-with (foo.bar) {
-
-}
-
-with (bar.blah) {
-}

src/harness/unittests/tsconfigParsing.ts

@@ -181,5 +181,26 @@ namespace ts {
                 ["/d.ts", "/folder/e.ts"]
             );
         });
+
+        it("parse and re-emit tsconfig.json file with diagnostics", () => {
+            const content = `{
+                "compilerOptions": {
+                    "allowJs": true
+                    // Some comments
+                    "outDir": "bin"
+                }
+                "files": ["file1.ts"]
+            }`;
+            const { configJsonObject, diagnostics } = parseAndReEmitConfigJSONFile(content);
+            const expectedResult = {
+                compilerOptions: {
+                    allowJs: true,
+                    outDir: "bin"
+                },
+                files: ["file1.ts"]
+            };
+            assert.isTrue(diagnostics.length === 2);
+            assert.equal(JSON.stringify(configJsonObject), JSON.stringify(expectedResult));
+        });
     });
 }

src/harness/unittests/tsserverProjectSystem.ts

@@ -623,5 +623,23 @@ namespace ts {
             checkNumberOfConfiguredProjects(projectService, 1);
             checkNumberOfInferredProjects(projectService, 0);
         });
+
+        it("should tolerate config file errors and still try to build a project", () => {
+            const configFile: FileOrFolder = {
+                path: "/a/b/tsconfig.json",
+                content: `{
+                    "compilerOptions": {
+                        "target": "es6",
+                        "allowAnything": true
+                    },
+                    "someOtherProperty": {}
+                }`
+            };
+            const host = new TestServerHost(/*useCaseSensitiveFileNames*/ false, getExecutingFilePathFromLibFile(libFile), "/", [commonFile1, commonFile2, libFile, configFile]);
+            const projectService = new server.ProjectService(host, nullLogger);
+            projectService.openClientFile(commonFile1.path);
+            checkNumberOfConfiguredProjects(projectService, 1);
+            checkConfiguredProjectRootFiles(projectService.configuredProjects[0], [commonFile1.path, commonFile2.path]);
+        });
     });
 }

src/lib/dom.generated.d.ts

@@ -126,6 +126,7 @@ interface KeyAlgorithm {
 }
 
 interface KeyboardEventInit extends EventModifierInit {
+    code?: string;
     key?: string;
     location?: number;
     repeat?: boolean;
@@ -2288,7 +2289,7 @@ declare var DeviceRotationRate: {
     new(): DeviceRotationRate;
 }
 
-interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEvent {
+interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEvent, ParentNode {
     /**
       * Sets or gets the URL for the current document. 
       */
@@ -3351,7 +3352,7 @@ declare var Document: {
     new(): Document;
 }
 
-interface DocumentFragment extends Node, NodeSelector {
+interface DocumentFragment extends Node, NodeSelector, ParentNode {
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
 
@@ -3420,7 +3421,7 @@ declare var EXT_texture_filter_anisotropic: {
     readonly TEXTURE_MAX_ANISOTROPY_EXT: number;
 }
 
-interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelector, ChildNode {
+interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelector, ChildNode, ParentNode {
     readonly classList: DOMTokenList;
     className: string;
     readonly clientHeight: number;
@@ -3675,6 +3676,16 @@ interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelec
     getElementsByClassName(classNames: string): NodeListOf<Element>;
     matches(selector: string): boolean;
     closest(selector: string): Element | null;
+    scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
+    scroll(options?: ScrollToOptions): void;
+    scroll(x: number, y: number): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollTo(x: number, y: number): void;
+    scrollBy(options?: ScrollToOptions): void;
+    scrollBy(x: number, y: number): void;
+    insertAdjacentElement(position: string, insertedElement: Element): Element | null;
+    insertAdjacentHTML(where: string, html: string): void;
+    insertAdjacentText(where: string, text: string): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureDoubleTap", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureEnd", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -4446,7 +4457,7 @@ interface HTMLCanvasElement extends HTMLElement {
       * @param type The standard MIME type for the image format to return. If you do not specify this parameter, the default value is a PNG format image.
       */
     toDataURL(type?: string, ...args: any[]): string;
-    toBlob(callback: (result: Blob | null) => void, ... arguments: any[]): void;
+    toBlob(callback: (result: Blob | null) => void, type?: string, ...arguments: any[]): void;
 }
 
 declare var HTMLCanvasElement: {
@@ -4621,11 +4632,7 @@ interface HTMLElement extends Element {
     click(): void;
     dragDrop(): boolean;
     focus(): void;
-    insertAdjacentElement(position: string, insertedElement: Element): Element;
-    insertAdjacentHTML(where: string, html: string): void;
-    insertAdjacentText(where: string, text: string): void;
     msGetInputContext(): MSInputMethodContext;
-    scrollIntoView(top?: boolean): void;
     setActive(): void;
     addEventListener(type: "MSContentZoom", listener: (this: this, ev: UIEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -5890,6 +5897,7 @@ interface HTMLLinkElement extends HTMLElement, LinkStyle {
       */
     type: string;
     import?: Document;
+    integrity: string;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 }
 
@@ -6178,7 +6186,7 @@ interface HTMLMediaElement extends HTMLElement {
       */
     canPlayType(type: string): string;
     /**
-      * Fires immediately after the client loads the object.
+      * Resets the audio or video object and loads a new media resource.
       */
     load(): void;
     /**
@@ -6751,6 +6759,7 @@ interface HTMLScriptElement extends HTMLElement {
       * Sets or retrieves the MIME type for the associated scripting engine.
       */
     type: string;
+    integrity: string;
 }
 
 declare var HTMLScriptElement: {
@@ -7756,6 +7765,7 @@ interface KeyboardEvent extends UIEvent {
     readonly repeat: boolean;
     readonly shiftKey: boolean;
     readonly which: number;
+    readonly code: string;
     getModifierState(keyArg: string): boolean;
     initKeyboardEvent(typeArg: string, canBubbleArg: boolean, cancelableArg: boolean, viewArg: Window, keyArg: string, locationArg: number, modifiersListArg: string, repeat: boolean, locale: string): void;
     readonly DOM_KEY_LOCATION_JOYSTICK: number;
@@ -9128,6 +9138,7 @@ interface PerformanceTiming {
     readonly responseStart: number;
     readonly unloadEventEnd: number;
     readonly unloadEventStart: number;
+    readonly secureConnectionStart: number;
     toJSON(): any;
 }
 
@@ -11405,8 +11416,8 @@ declare var StereoPannerNode: {
 interface Storage {
     readonly length: number;
     clear(): void;
-    getItem(key: string): string;
-    key(index: number): string;
+    getItem(key: string): string | null;
+    key(index: number): string | null;
     removeItem(key: string): void;
     setItem(key: string, data: string): void;
     [key: string]: any;
@@ -12947,7 +12958,7 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     onunload: (this: this, ev: Event) => any;
     onvolumechange: (this: this, ev: Event) => any;
     onwaiting: (this: this, ev: Event) => any;
-    readonly opener: Window;
+    opener: any;
     orientation: string | number;
     readonly outerHeight: number;
     readonly outerWidth: number;
@@ -13002,6 +13013,9 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window
     webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
     webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
     webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
+    scroll(options?: ScrollToOptions): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollBy(options?: ScrollToOptions): void;
     addEventListener(type: "MSGestureChange", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureDoubleTap", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
     addEventListener(type: "MSGestureEnd", listener: (this: this, ev: MSGestureEvent) => any, useCapture?: boolean): void;
@@ -14029,6 +14043,20 @@ interface ProgressEventInit extends EventInit {
     total?: number;
 }
 
+interface ScrollOptions {
+    behavior?: ScrollBehavior;
+}
+
+interface ScrollToOptions extends ScrollOptions {
+    left?: number;
+    top?: number;
+}
+
+interface ScrollIntoViewOptions extends ScrollOptions {
+    block?: ScrollLogicalPosition;
+    inline?: ScrollLogicalPosition;
+}
+
 interface ClipboardEventInit extends EventInit {
     data?: string;
     dataType?: string;
@@ -14072,7 +14100,7 @@ interface EcdsaParams extends Algorithm {
 }
 
 interface EcKeyGenParams extends Algorithm {
-    typedCurve: string;
+    namedCurve: string;
 }
 
 interface EcKeyAlgorithm extends KeyAlgorithm {
@@ -14208,6 +14236,13 @@ interface JsonWebKey {
     k?: string;
 }
 
+interface ParentNode {
+    readonly children: HTMLCollection;
+    readonly firstElementChild: Element;
+    readonly lastElementChild: Element;
+    readonly childElementCount: number;
+}
+
 declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
 
 interface ErrorEventHandler {
@@ -14278,7 +14313,7 @@ declare var location: Location;
 declare var locationbar: BarProp;
 declare var menubar: BarProp;
 declare var msCredentials: MSCredentials;
-declare var name: string;
+declare const name: never;
 declare var navigator: Navigator;
 declare var offscreenBuffering: string | boolean;
 declare var onabort: (this: Window, ev: UIEvent) => any;
@@ -14372,7 +14407,7 @@ declare var ontouchstart: (ev: TouchEvent) => any;
 declare var onunload: (this: Window, ev: Event) => any;
 declare var onvolumechange: (this: Window, ev: Event) => any;
 declare var onwaiting: (this: Window, ev: Event) => any;
-declare var opener: Window;
+declare var opener: any;
 declare var orientation: string | number;
 declare var outerHeight: number;
 declare var outerWidth: number;
@@ -14425,6 +14460,9 @@ declare function webkitCancelAnimationFrame(handle: number): void;
 declare function webkitConvertPointFromNodeToPage(node: Node, pt: WebKitPoint): WebKitPoint;
 declare function webkitConvertPointFromPageToNode(node: Node, pt: WebKitPoint): WebKitPoint;
 declare function webkitRequestAnimationFrame(callback: FrameRequestCallback): number;
+declare function scroll(options?: ScrollToOptions): void;
+declare function scrollTo(options?: ScrollToOptions): void;
+declare function scrollBy(options?: ScrollToOptions): void;
 declare function toString(): string;
 declare function addEventListener(type: string, listener?: EventListenerOrEventListenerObject, useCapture?: boolean): void;
 declare function dispatchEvent(evt: Event): boolean;
@@ -14580,6 +14618,8 @@ type MSOutboundPayload = MSVideoSendPayload | MSAudioSendPayload;
 type RTCIceGatherCandidate = RTCIceCandidate | RTCIceCandidateComplete;
 type RTCTransport = RTCDtlsTransport | RTCSrtpSdesTransport;
 type payloadtype = number;
+type ScrollBehavior = "auto" | "instant" | "smooth";
+type ScrollLogicalPosition = "start" | "center" | "end" | "nearest";
 type IDBValidKey = number | string | Date | IDBArrayKey;
 type BufferSource = ArrayBuffer | ArrayBufferView;
 type MouseWheelEvent = WheelEvent;

src/lib/webworker.generated.d.ts

@@ -1000,7 +1000,7 @@ interface EcdsaParams extends Algorithm {
 }
 
 interface EcKeyGenParams extends Algorithm {
-    typedCurve: string;
+    namedCurve: string;
 }
 
 interface EcKeyAlgorithm extends KeyAlgorithm {

src/server/editorServices.ts

@@ -606,8 +606,11 @@ namespace ts.server {
         return projects.length > 1 ? deduplicate(result, areEqual) : result;
     }
 
+    export type ProjectServiceEvent =
+        { eventName: "context", data: { project: Project, fileName: string } } | { eventName: "configFileDiag", data: { triggerFile?: string, configFileName: string, diagnostics: Diagnostic[] } }
+
     export interface ProjectServiceEventHandler {
-        (eventName: string, project: Project, fileName: string): void;
+        (event: ProjectServiceEvent): void;
     }
 
     export interface HostConfiguration {
@@ -702,7 +705,8 @@ namespace ts.server {
         }
 
         handleProjectFileListChanges(project: Project) {
-            const { projectOptions } = this.configFileToProjectOptions(project.projectFilename);
+            const { projectOptions, errors } = this.configFileToProjectOptions(project.projectFilename);
+            this.reportConfigFileDiagnostics(project.projectFilename, errors);
 
             const newRootFiles = projectOptions.files.map((f => this.getCanonicalFileName(f)));
             const currentRootFiles = project.getRootFiles().map((f => this.getCanonicalFileName(f)));
@@ -720,18 +724,32 @@ namespace ts.server {
             }
         }
 
+        reportConfigFileDiagnostics(configFileName: string, diagnostics: Diagnostic[], triggerFile?: string) {
+            if (diagnostics && diagnostics.length > 0) {
+                this.eventHandler({
+                    eventName: "configFileDiag",
+                    data: { configFileName, diagnostics, triggerFile }
+                });
+            }
+        }
+
         /**
          * This is the callback function when a watched directory has an added tsconfig file.
          */
         directoryWatchedForTsconfigChanged(fileName: string) {
-            if (ts.getBaseFileName(fileName) != "tsconfig.json") {
+            if (ts.getBaseFileName(fileName) !== "tsconfig.json") {
                 this.log(fileName + " is not tsconfig.json");
                 return;
             }
 
             this.log("Detected newly added tsconfig file: " + fileName);
 
-            const { projectOptions } = this.configFileToProjectOptions(fileName);
+            const { projectOptions, errors } = this.configFileToProjectOptions(fileName);
+            this.reportConfigFileDiagnostics(fileName, errors);
+
+            if (!projectOptions) {
+                return;
+            }
 
             const rootFilesInTsconfig = projectOptions.files.map(f => this.getCanonicalFileName(f));
             const openFileRoots = this.openFileRoots.map(s => this.getCanonicalFileName(s.fileName));
@@ -751,10 +769,13 @@ namespace ts.server {
             return ts.normalizePath(name);
         }
 
-        watchedProjectConfigFileChanged(project: Project) {
+        watchedProjectConfigFileChanged(project: Project): void {
             this.log("Config file changed: " + project.projectFilename);
-            this.updateConfiguredProject(project);
+            const configFileErrors = this.updateConfiguredProject(project);
             this.updateProjectStructure();
+            if (configFileErrors && configFileErrors.length > 0) {
+                this.eventHandler({ eventName: "configFileDiag", data: { triggerFile: project.projectFilename, configFileName: project.projectFilename, diagnostics: configFileErrors } });
+            }
         }
 
         log(msg: string, type = "Err") {
@@ -831,13 +852,13 @@ namespace ts.server {
                 for (let j = 0, flen = this.openFileRoots.length; j < flen; j++) {
                     const openFile = this.openFileRoots[j];
                     if (this.eventHandler) {
-                        this.eventHandler("context", openFile.defaultProject, openFile.fileName);
+                        this.eventHandler({ eventName: "context", data: { project: openFile.defaultProject, fileName: openFile.fileName } });
                     }
                 }
                 for (let j = 0, flen = this.openFilesReferenced.length; j < flen; j++) {
                     const openFile = this.openFilesReferenced[j];
                     if (this.eventHandler) {
-                        this.eventHandler("context", openFile.defaultProject, openFile.fileName);
+                        this.eventHandler({ eventName: "context", data: { project: openFile.defaultProject, fileName: openFile.fileName } });
                     }
                 }
             }
@@ -1221,7 +1242,7 @@ namespace ts.server {
                 const project = this.findConfiguredProjectByConfigFile(configFileName);
                 if (!project) {
                     const configResult = this.openConfigFile(configFileName, fileName);
-                    if (!configResult.success) {
+                    if (!configResult.project) {
                         return { configFileName, configFileErrors: configResult.errors };
                     }
                     else {
@@ -1237,11 +1258,12 @@ namespace ts.server {
                 else {
                     this.updateConfiguredProject(project);
                 }
+                return { configFileName };
             }
             else {
                 this.log("No config files found.");
             }
-            return configFileName ? { configFileName } : {};
+            return {};
         }
 
         /**
@@ -1331,34 +1353,31 @@ namespace ts.server {
             return undefined;
         }
 
-        configFileToProjectOptions(configFilename: string): { succeeded: boolean, projectOptions?: ProjectOptions, errors?: Diagnostic[] } {
+        configFileToProjectOptions(configFilename: string): { projectOptions?: ProjectOptions, errors: Diagnostic[] } {
             configFilename = ts.normalizePath(configFilename);
+            let errors: Diagnostic[] = [];
             // file references will be relative to dirPath (or absolute)
             const dirPath = ts.getDirectoryPath(configFilename);
             const contents = this.host.readFile(configFilename);
-            const rawConfig: { config?: ProjectOptions; error?: Diagnostic; } = ts.parseConfigFileTextToJson(configFilename, contents);
-            if (rawConfig.error) {
-                return { succeeded: false, errors: [rawConfig.error] };
+            const { configJsonObject, diagnostics } = ts.parseAndReEmitConfigJSONFile(contents);
+            errors = concatenate(errors, diagnostics);
+            const parsedCommandLine = ts.parseJsonConfigFileContent(configJsonObject, this.host, dirPath, /*existingOptions*/ {}, configFilename);
+            errors = concatenate(errors, parsedCommandLine.errors);
+            Debug.assert(!!parsedCommandLine.fileNames);
+
+            if (parsedCommandLine.fileNames.length === 0) {
+                errors.push(createCompilerDiagnostic(Diagnostics.The_config_file_0_found_doesn_t_contain_any_source_files, configFilename));
+                return { errors };
             }
             else {
-                const parsedCommandLine = ts.parseJsonConfigFileContent(rawConfig.config, this.host, dirPath, /*existingOptions*/ {}, configFilename);
-                Debug.assert(!!parsedCommandLine.fileNames);
-
-                if (parsedCommandLine.errors && (parsedCommandLine.errors.length > 0)) {
-                    return { succeeded: false, errors: parsedCommandLine.errors };
-                }
-                else if (parsedCommandLine.fileNames.length === 0) {
-                    const error = createCompilerDiagnostic(Diagnostics.The_config_file_0_found_doesn_t_contain_any_source_files, configFilename);
-                    return { succeeded: false, errors: [error] };
-                }
-                else {
-                    const projectOptions: ProjectOptions = {
-                        files: parsedCommandLine.fileNames,
-                        wildcardDirectories: parsedCommandLine.wildcardDirectories,
-                        compilerOptions: parsedCommandLine.options,
-                    };
-                    return { succeeded: true, projectOptions };
-                }
+                // if the project has some files, we can continue with the parsed options and tolerate
+                // errors in the parsedCommandLine
+                const projectOptions: ProjectOptions = {
+                    files: parsedCommandLine.fileNames,
+                    wildcardDirectories: parsedCommandLine.wildcardDirectories,
+                    compilerOptions: parsedCommandLine.options,
+                };
+                return { projectOptions, errors };
             }
         }
 
@@ -1380,64 +1399,63 @@ namespace ts.server {
             return false;
         }
 
-        openConfigFile(configFilename: string, clientFileName?: string): { success: boolean, project?: Project, errors?: Diagnostic[] } {
-            const { succeeded, projectOptions, errors } = this.configFileToProjectOptions(configFilename);
-            if (!succeeded) {
-                return { success: false, errors };
+        openConfigFile(configFilename: string, clientFileName?: string): { project?: Project, errors: Diagnostic[] } {
+            const parseConfigFileResult = this.configFileToProjectOptions(configFilename);
+            let errors = parseConfigFileResult.errors;
+            if (!parseConfigFileResult.projectOptions) {
+                return { errors };
             }
-            else {
-                if (!projectOptions.compilerOptions.disableSizeLimit && projectOptions.compilerOptions.allowJs) {
-                    if (this.exceedTotalNonTsFileSizeLimit(projectOptions.files)) {
-                        const project = this.createProject(configFilename, projectOptions, /*languageServiceDisabled*/ true);
+            const projectOptions = parseConfigFileResult.projectOptions;
+            if (!projectOptions.compilerOptions.disableSizeLimit && projectOptions.compilerOptions.allowJs) {
+                if (this.exceedTotalNonTsFileSizeLimit(projectOptions.files)) {
+                    const project = this.createProject(configFilename, projectOptions, /*languageServiceDisabled*/ true);
 
-                        // for configured projects with languageService disabled, we only watch its config file,
-                        // do not care about the directory changes in the folder.
-                        project.projectFileWatcher = this.host.watchFile(
-                            toPath(configFilename, configFilename, createGetCanonicalFileName(sys.useCaseSensitiveFileNames)),
-                            _ => this.watchedProjectConfigFileChanged(project));
-                        return { success: true, project };
-                    }
+                    // for configured projects with languageService disabled, we only watch its config file,
+                    // do not care about the directory changes in the folder.
+                    project.projectFileWatcher = this.host.watchFile(
+                        toPath(configFilename, configFilename, createGetCanonicalFileName(sys.useCaseSensitiveFileNames)),
+                        _ => this.watchedProjectConfigFileChanged(project));
+                    return { project, errors };
+                }
+            }
+
+            const project = this.createProject(configFilename, projectOptions);
+            for (const rootFilename of projectOptions.files) {
+                if (this.host.fileExists(rootFilename)) {
+                    const info = this.openFile(rootFilename, /*openedByClient*/ clientFileName == rootFilename);
+                    project.addRoot(info);
+                }
+                else {
+                    (errors || (errors = [])).push(createCompilerDiagnostic(Diagnostics.File_0_not_found, rootFilename));
+                }
+            }
+            project.finishGraph();
+            project.projectFileWatcher = this.host.watchFile(configFilename, _ => this.watchedProjectConfigFileChanged(project));
+
+            const configDirectoryPath = ts.getDirectoryPath(configFilename);
+
+            this.log("Add recursive watcher for: " + configDirectoryPath);
+            project.directoryWatcher = this.host.watchDirectory(
+                configDirectoryPath,
+                path => this.directoryWatchedForSourceFilesChanged(project, path),
+                /*recursive*/ true
+            );
+
+            project.directoriesWatchedForWildcards = reduceProperties(createMap(projectOptions.wildcardDirectories), (watchers, flag, directory) => {
+                if (comparePaths(configDirectoryPath, directory, ".", !this.host.useCaseSensitiveFileNames) !== Comparison.EqualTo) {
+                    const recursive = (flag & WatchDirectoryFlags.Recursive) !== 0;
+                    this.log(`Add ${ recursive ? "recursive " : ""}watcher for: ${directory}`);
+                    watchers[directory] = this.host.watchDirectory(
+                        directory,
+                        path => this.directoryWatchedForSourceFilesChanged(project, path),
+                        recursive
+                    );
                 }
 
-                const project = this.createProject(configFilename, projectOptions);
-                let errors: Diagnostic[];
-                for (const rootFilename of projectOptions.files) {
-                    if (this.host.fileExists(rootFilename)) {
-                        const info = this.openFile(rootFilename, /*openedByClient*/ clientFileName == rootFilename);
-                        project.addRoot(info);
-                    }
-                    else {
-                        (errors || (errors = [])).push(createCompilerDiagnostic(Diagnostics.File_0_not_found, rootFilename));
-                    }
-                }
-                project.finishGraph();
-                project.projectFileWatcher = this.host.watchFile(configFilename, _ => this.watchedProjectConfigFileChanged(project));
+                return watchers;
+            }, <Map<FileWatcher>>{});
 
-                const configDirectoryPath = ts.getDirectoryPath(configFilename);
-
-                this.log("Add recursive watcher for: " + configDirectoryPath);
-                project.directoryWatcher = this.host.watchDirectory(
-                    configDirectoryPath,
-                    path => this.directoryWatchedForSourceFilesChanged(project, path),
-                    /*recursive*/ true
-                );
-
-                project.directoriesWatchedForWildcards = reduceProperties(createMap(projectOptions.wildcardDirectories), (watchers, flag, directory) => {
-                    if (comparePaths(configDirectoryPath, directory, ".", !this.host.useCaseSensitiveFileNames) !== Comparison.EqualTo) {
-                        const recursive = (flag & WatchDirectoryFlags.Recursive) !== 0;
-                        this.log(`Add ${ recursive ? "recursive " : ""}watcher for: ${directory}`);
-                        watchers[directory] = this.host.watchDirectory(
-                            directory,
-                            path => this.directoryWatchedForSourceFilesChanged(project, path),
-                            recursive
-                        );
-                    }
-
-                    return watchers;
-                }, <Map<FileWatcher>>{});
-
-                return { success: true, project: project, errors };
-            }
+            return { project: project, errors };
         }
 
         updateConfiguredProject(project: Project): Diagnostic[] {
@@ -1446,15 +1464,15 @@ namespace ts.server {
                 this.removeProject(project);
             }
             else {
-                const { succeeded, projectOptions, errors } = this.configFileToProjectOptions(project.projectFilename);
-                if (!succeeded) {
+                const { projectOptions, errors } = this.configFileToProjectOptions(project.projectFilename);
+                if (!projectOptions) {
                     return errors;
                 }
                 else {
                     if (projectOptions.compilerOptions && !projectOptions.compilerOptions.disableSizeLimit && this.exceedTotalNonTsFileSizeLimit(projectOptions.files)) {
                         project.setProjectOptions(projectOptions);
                         if (project.languageServiceDiabled) {
-                            return;
+                            return errors;
                         }
 
                         project.disableLanguageService();
@@ -1462,7 +1480,7 @@ namespace ts.server {
                             project.directoryWatcher.close();
                             project.directoryWatcher = undefined;
                         }
-                        return;
+                        return errors;
                     }
 
                     if (project.languageServiceDiabled) {
@@ -1481,7 +1499,7 @@ namespace ts.server {
                             }
                         }
                         project.finishGraph();
-                        return;
+                        return errors;
                     }
 
                     // if the project is too large, the root files might not have been all loaded if the total
@@ -1527,6 +1545,7 @@ namespace ts.server {
                     project.setProjectOptions(projectOptions);
                     project.finishGraph();
                 }
+                return errors;
             }
         }
 

src/server/session.ts

@@ -153,16 +153,22 @@ namespace ts.server {
             private logger: Logger
         ) {
             this.projectService =
-                new ProjectService(host, logger, (eventName, project, fileName) => {
-                    this.handleEvent(eventName, project, fileName);
+                new ProjectService(host, logger, event => {
+                    this.handleEvent(event);
                 });
         }
 
-        private handleEvent(eventName: string, project: Project, fileName: string) {
-            if (eventName == "context") {
-                this.projectService.log("got context event, updating diagnostics for" + fileName, "Info");
-                this.updateErrorCheck([{ fileName, project }], this.changeSeq,
-                    (n) => n === this.changeSeq, 100);
+        private handleEvent(event: ProjectServiceEvent) {
+            switch (event.eventName) {
+                case "context":
+                    const { project, fileName } = event.data;
+                    this.projectService.log("got context event, updating diagnostics for" + fileName, "Info");
+                    this.updateErrorCheck([{ fileName, project }], this.changeSeq,
+                        (n) => n === this.changeSeq, 100);
+                    break;
+                case "configFileDiag":
+                    const { triggerFile, configFileName, diagnostics } = event.data;
+                    this.configFileDiagnosticEvent(triggerFile, configFileName, diagnostics);
             }
         }
 

src/services/services.ts

@@ -280,11 +280,14 @@ namespace ts {
                 let pos = this.pos;
                 const useJSDocScanner = this.kind >= SyntaxKind.FirstJSDocTagNode && this.kind <= SyntaxKind.LastJSDocTagNode;
                 const processNode = (node: Node) => {
-                    if (pos < node.pos) {
+                    const isJSDocTagNode = isJSDocTag(node);
+                    if (!isJSDocTagNode && pos < node.pos) {
                         pos = this.addSyntheticNodes(children, pos, node.pos, useJSDocScanner);
                     }
                     children.push(node);
-                    pos = node.end;
+                    if (!isJSDocTagNode) {
+                        pos = node.end;
+                    }
                 };
                 const processNodes = (nodes: NodeArray<Node>) => {
                     if (pos < nodes.pos) {
@@ -1383,8 +1386,12 @@ namespace ts {
         containerName: string;
     }
 
+    export interface ReferencedSymbolDefinitionInfo extends DefinitionInfo {
+        displayParts: SymbolDisplayPart[];
+    }
+
     export interface ReferencedSymbol {
-        definition: DefinitionInfo;
+        definition: ReferencedSymbolDefinitionInfo;
         references: ReferenceEntry[];
     }
 
@@ -5403,6 +5410,28 @@ namespace ts {
 
             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 = program.getTypeChecker().getSymbolAtLocation((<BinaryExpression>declaration.parent).right);
+                            if (!rhsSymbol) {
+                                continue;
+                            }
+
+                            documentation = rhsSymbol.getDocumentationComment();
+                            if (documentation.length > 0) {
+                                break;
+                            }
+                        }
+                    }
+                }
             }
 
             return { displayParts, documentation, symbolKind };
@@ -6568,7 +6597,7 @@ namespace ts {
 
             return result;
 
-            function getDefinition(symbol: Symbol): DefinitionInfo {
+            function getDefinition(symbol: Symbol): ReferencedSymbolDefinitionInfo {
                 const info = getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, node.getSourceFile(), getContainerNode(node), node);
                 const name = map(info.displayParts, p => p.text).join("");
                 const declarations = symbol.declarations;
@@ -6582,7 +6611,8 @@ namespace ts {
                     name,
                     kind: info.symbolKind,
                     fileName: declarations[0].getSourceFile().fileName,
-                    textSpan: createTextSpan(declarations[0].getStart(), 0)
+                    textSpan: createTextSpan(declarations[0].getStart(), 0),
+                    displayParts: info.displayParts
                 };
             }
 
@@ -6777,13 +6807,14 @@ namespace ts {
                     }
                 });
 
-                const definition: DefinitionInfo = {
+                const definition: ReferencedSymbolDefinitionInfo = {
                     containerKind: "",
                     containerName: "",
                     fileName: targetLabel.getSourceFile().fileName,
                     kind: ScriptElementKind.label,
                     name: labelName,
-                    textSpan: createTextSpanFromBounds(targetLabel.getStart(), targetLabel.getEnd())
+                    textSpan: createTextSpanFromBounds(targetLabel.getStart(), targetLabel.getEnd()),
+                    displayParts: [displayPart(labelName, SymbolDisplayPartKind.text)]
                 };
 
                 return [{ definition, references }];
@@ -7013,6 +7044,11 @@ namespace ts {
                     getThisReferencesInFile(sourceFile, searchSpaceNode, possiblePositions, references);
                 }
 
+                const thisOrSuperSymbol = typeChecker.getSymbolAtLocation(thisOrSuperKeyword);
+
+                const displayParts = thisOrSuperSymbol && getSymbolDisplayPartsDocumentationAndSymbolKind(
+                    thisOrSuperSymbol, thisOrSuperKeyword.getSourceFile(), getContainerNode(thisOrSuperKeyword), thisOrSuperKeyword).displayParts;
+
                 return [{
                     definition: {
                         containerKind: "",
@@ -7020,7 +7056,8 @@ namespace ts {
                         fileName: node.getSourceFile().fileName,
                         kind: ScriptElementKind.variableElement,
                         name: "this",
-                        textSpan: createTextSpanFromBounds(node.getStart(), node.getEnd())
+                        textSpan: createTextSpanFromBounds(node.getStart(), node.getEnd()),
+                        displayParts
                     },
                     references: references
                 }];
@@ -7091,7 +7128,8 @@ namespace ts {
                         fileName: node.getSourceFile().fileName,
                         kind: ScriptElementKind.variableElement,
                         name: type.text,
-                        textSpan: createTextSpanFromBounds(node.getStart(), node.getEnd())
+                        textSpan: createTextSpanFromBounds(node.getStart(), node.getEnd()),
+                        displayParts: [displayPart(getTextOfNode(node), SymbolDisplayPartKind.stringLiteral)]
                     },
                     references: references
                 }];
@@ -8050,6 +8088,10 @@ namespace ts {
              * 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;
                 }

src/services/utilities.ts

@@ -951,4 +951,25 @@ namespace ts {
         }
         return ensureScriptKind(fileName, scriptKind);
     }
+
+    export function parseAndReEmitConfigJSONFile(content: string) {
+        const options: TranspileOptions = {
+            fileName: "config.js",
+            compilerOptions: {
+                target: ScriptTarget.ES6,
+                removeComments: true
+            },
+            reportDiagnostics: true
+        };
+        const { outputText, diagnostics } = ts.transpileModule("(" + content + ")", options);
+        // Becasue the content was wrapped in "()", the start position of diagnostics needs to be subtract by 1
+        // also, the emitted result will have "(" in the beginning and ");" in the end. We need to strip these
+        // as well
+        const trimmedOutput = outputText.trim();
+        const configJsonObject = JSON.parse(trimmedOutput.substring(1, trimmedOutput.length - 2));
+        for (const diagnostic of diagnostics) {
+            diagnostic.start = diagnostic.start - 1;
+        }
+        return { configJsonObject, diagnostics };
+    }
 }

tests/baselines/reference/apparentTypeSubtyping.errors.txt

@@ -1,6 +1,7 @@
 tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSubtyping.ts(9,7): error TS2415: Class 'Derived<U>' incorrectly extends base class 'Base<string>'.
   Types of property 'x' are incompatible.
     Type 'String' is not assignable to type 'string'.
+      'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
 
 
 ==== tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSubtyping.ts (1 errors) ====
@@ -17,6 +18,7 @@ tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSubtypi
 !!! error TS2415: Class 'Derived<U>' incorrectly extends base class 'Base<string>'.
 !!! error TS2415:   Types of property 'x' are incompatible.
 !!! error TS2415:     Type 'String' is not assignable to type 'string'.
+!!! error TS2415:       'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
         x: String;
     }
     

tests/baselines/reference/apparentTypeSupertype.errors.txt

@@ -2,6 +2,7 @@ tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSuperty
   Types of property 'x' are incompatible.
     Type 'U' is not assignable to type 'string'.
       Type 'String' is not assignable to type 'string'.
+        'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
 
 
 ==== tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSupertype.ts (1 errors) ====
@@ -19,5 +20,6 @@ tests/cases/conformance/types/typeRelationships/apparentType/apparentTypeSuperty
 !!! error TS2415:   Types of property 'x' are incompatible.
 !!! error TS2415:     Type 'U' is not assignable to type 'string'.
 !!! error TS2415:       Type 'String' is not assignable to type 'string'.
+!!! error TS2415:         'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
         x: U;
     }

tests/baselines/reference/arityAndOrderCompatibility01.errors.txt

@@ -39,8 +39,7 @@ tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(26,5): error
 tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(27,5): error TS2322: Type '{ 0: string; 1: number; }' is not assignable to type '[string]'.
   Property 'length' is missing in type '{ 0: string; 1: number; }'.
 tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(28,5): error TS2322: Type '[string, number]' is not assignable to type '[number, string]'.
-  Types of property '0' are incompatible.
-    Type 'string' is not assignable to type 'number'.
+  Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(29,5): error TS2322: Type 'StrNum' is not assignable to type '[number, string]'.
   Types of property '0' are incompatible.
     Type 'string' is not assignable to type 'number'.
@@ -136,8 +135,7 @@ tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(30,5): error
     var n1: [number, string] = x;
         ~~
 !!! error TS2322: Type '[string, number]' is not assignable to type '[number, string]'.
-!!! error TS2322:   Types of property '0' are incompatible.
-!!! error TS2322:     Type 'string' is not assignable to type 'number'.
+!!! error TS2322:   Type 'string' is not assignable to type 'number'.
     var n2: [number, string] = y;
         ~~
 !!! error TS2322: Type 'StrNum' is not assignable to type '[number, string]'.

tests/baselines/reference/arrayLiterals3.errors.txt

@@ -1,8 +1,7 @@
 tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(10,5): error TS2322: Type 'undefined[]' is not assignable to type '[any, any, any]'.
   Property '0' is missing in type 'undefined[]'.
 tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(11,5): error TS2322: Type '[string, number, boolean]' is not assignable to type '[boolean, string, number]'.
-  Types of property '0' are incompatible.
-    Type 'string' is not assignable to type 'boolean'.
+  Type 'string' is not assignable to type 'boolean'.
 tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(17,5): error TS2322: Type '[number, number, string, boolean]' is not assignable to type '[number, number]'.
   Types of property 'pop' are incompatible.
     Type '() => string | number | boolean' is not assignable to type '() => number'.
@@ -18,6 +17,7 @@ tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(34,5): error
       Types of parameters 'items' and 'items' are incompatible.
         Type 'Number' is not assignable to type 'string | number'.
           Type 'Number' is not assignable to type 'number'.
+            'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
 
 
 ==== tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts (6 errors) ====
@@ -37,8 +37,7 @@ tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(34,5): error
     var a1: [boolean, string, number] = ["string", 1, true];  // Error
         ~~
 !!! error TS2322: Type '[string, number, boolean]' is not assignable to type '[boolean, string, number]'.
-!!! error TS2322:   Types of property '0' are incompatible.
-!!! error TS2322:     Type 'string' is not assignable to type 'boolean'.
+!!! error TS2322:   Type 'string' is not assignable to type 'boolean'.
     
     // The resulting type an array literal expression is determined as follows:
     //     - If the array literal contains no spread elements and is an array assignment pattern in a destructuring assignment (section 4.17.1),
@@ -81,4 +80,5 @@ tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(34,5): error
 !!! error TS2322:       Types of parameters 'items' and 'items' are incompatible.
 !!! error TS2322:         Type 'Number' is not assignable to type 'string | number'.
 !!! error TS2322:           Type 'Number' is not assignable to type 'number'.
+!!! error TS2322:             'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
     

tests/baselines/reference/assignFromBooleanInterface.errors.txt

@@ -1,4 +1,5 @@
 tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface.ts(3,1): error TS2322: Type 'Boolean' is not assignable to type 'boolean'.
+  'boolean' is a primitive, but 'Boolean' is a wrapper object. Prefer using 'boolean' when possible.
 
 
 ==== tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface.ts (1 errors) ====
@@ -7,4 +8,5 @@ tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface.ts(3
     x = a;
     ~
 !!! error TS2322: Type 'Boolean' is not assignable to type 'boolean'.
+!!! error TS2322:   'boolean' is a primitive, but 'Boolean' is a wrapper object. Prefer using 'boolean' when possible.
     a = x;

tests/baselines/reference/assignFromBooleanInterface2.errors.txt

@@ -3,6 +3,7 @@ tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface2.ts(
     Type '() => Object' is not assignable to type '() => boolean'.
       Type 'Object' is not assignable to type 'boolean'.
 tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface2.ts(19,1): error TS2322: Type 'Boolean' is not assignable to type 'boolean'.
+  'boolean' is a primitive, but 'Boolean' is a wrapper object. Prefer using 'boolean' when possible.
 tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface2.ts(20,1): error TS2322: Type 'NotBoolean' is not assignable to type 'boolean'.
 
 
@@ -33,6 +34,7 @@ tests/cases/conformance/types/primitives/boolean/assignFromBooleanInterface2.ts(
     x = a; // expected error
     ~
 !!! error TS2322: Type 'Boolean' is not assignable to type 'boolean'.
+!!! error TS2322:   'boolean' is a primitive, but 'Boolean' is a wrapper object. Prefer using 'boolean' when possible.
     x = b; // expected error
     ~
 !!! error TS2322: Type 'NotBoolean' is not assignable to type 'boolean'.

tests/baselines/reference/assignFromNumberInterface.errors.txt

@@ -1,4 +1,5 @@
 tests/cases/conformance/types/primitives/number/assignFromNumberInterface.ts(3,1): error TS2322: Type 'Number' is not assignable to type 'number'.
+  'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
 
 
 ==== tests/cases/conformance/types/primitives/number/assignFromNumberInterface.ts (1 errors) ====
@@ -7,4 +8,5 @@ tests/cases/conformance/types/primitives/number/assignFromNumberInterface.ts(3,1
     x = a;
     ~
 !!! error TS2322: Type 'Number' is not assignable to type 'number'.
+!!! error TS2322:   'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
     a = x;

tests/baselines/reference/assignFromNumberInterface2.errors.txt

@@ -1,4 +1,5 @@
 tests/cases/conformance/types/primitives/number/assignFromNumberInterface2.ts(24,1): error TS2322: Type 'Number' is not assignable to type 'number'.
+  'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
 tests/cases/conformance/types/primitives/number/assignFromNumberInterface2.ts(25,1): error TS2322: Type 'NotNumber' is not assignable to type 'number'.
 
 
@@ -29,6 +30,7 @@ tests/cases/conformance/types/primitives/number/assignFromNumberInterface2.ts(25
     x = a; // expected error
     ~
 !!! error TS2322: Type 'Number' is not assignable to type 'number'.
+!!! error TS2322:   'number' is a primitive, but 'Number' is a wrapper object. Prefer using 'number' when possible.
     x = b; // expected error
     ~
 !!! error TS2322: Type 'NotNumber' is not assignable to type 'number'.

tests/baselines/reference/assignFromStringInterface.errors.txt

@@ -1,4 +1,5 @@
 tests/cases/conformance/types/primitives/string/assignFromStringInterface.ts(3,1): error TS2322: Type 'String' is not assignable to type 'string'.
+  'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
 
 
 ==== tests/cases/conformance/types/primitives/string/assignFromStringInterface.ts (1 errors) ====
@@ -7,4 +8,5 @@ tests/cases/conformance/types/primitives/string/assignFromStringInterface.ts(3,1
     x = a;
     ~
 !!! error TS2322: Type 'String' is not assignable to type 'string'.
+!!! error TS2322:   'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
     a = x;

tests/baselines/reference/assignFromStringInterface2.errors.txt

@@ -1,4 +1,5 @@
 tests/cases/conformance/types/primitives/string/assignFromStringInterface2.ts(47,1): error TS2322: Type 'String' is not assignable to type 'string'.
+  'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
 tests/cases/conformance/types/primitives/string/assignFromStringInterface2.ts(48,1): error TS2322: Type 'NotString' is not assignable to type 'string'.
 
 
@@ -52,6 +53,7 @@ tests/cases/conformance/types/primitives/string/assignFromStringInterface2.ts(48
     x = a; // expected error
     ~
 !!! error TS2322: Type 'String' is not assignable to type 'string'.
+!!! error TS2322:   'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.
     x = b; // expected error
     ~
 !!! error TS2322: Type 'NotString' is not assignable to type 'string'.

tests/baselines/reference/await_unaryExpression_es6.js

@@ -0,0 +1,47 @@
+//// [await_unaryExpression_es6.ts]
+
+async function bar() {
+    !await 42; // OK
+}
+
+async function bar1() {
+    +await 42; // OK
+}
+
+async function bar3() {
+    -await 42; // OK
+}
+
+async function bar4() {
+    ~await 42; // OK
+}
+
+//// [await_unaryExpression_es6.js]
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments)).next());
+    });
+};
+function bar() {
+    return __awaiter(this, void 0, void 0, function* () {
+        !(yield 42); // OK
+    });
+}
+function bar1() {
+    return __awaiter(this, void 0, void 0, function* () {
+        +(yield 42); // OK
+    });
+}
+function bar3() {
+    return __awaiter(this, void 0, void 0, function* () {
+        -(yield 42); // OK
+    });
+}
+function bar4() {
+    return __awaiter(this, void 0, void 0, function* () {
+        ~(yield 42); // OK
+    });
+}

tests/baselines/reference/await_unaryExpression_es6.symbols

@@ -0,0 +1,25 @@
+=== tests/cases/conformance/async/es6/await_unaryExpression_es6.ts ===
+
+async function bar() {
+>bar : Symbol(bar, Decl(await_unaryExpression_es6.ts, 0, 0))
+
+    !await 42; // OK
+}
+
+async function bar1() {
+>bar1 : Symbol(bar1, Decl(await_unaryExpression_es6.ts, 3, 1))
+
+    +await 42; // OK
+}
+
+async function bar3() {
+>bar3 : Symbol(bar3, Decl(await_unaryExpression_es6.ts, 7, 1))
+
+    -await 42; // OK
+}
+
+async function bar4() {
+>bar4 : Symbol(bar4, Decl(await_unaryExpression_es6.ts, 11, 1))
+
+    ~await 42; // OK
+}

tests/baselines/reference/await_unaryExpression_es6.types

@@ -0,0 +1,37 @@
+=== tests/cases/conformance/async/es6/await_unaryExpression_es6.ts ===
+
+async function bar() {
+>bar : () => Promise<void>
+
+    !await 42; // OK
+>!await 42 : boolean
+>await 42 : number
+>42 : number
+}
+
+async function bar1() {
+>bar1 : () => Promise<void>
+
+    +await 42; // OK
+>+await 42 : number
+>await 42 : number
+>42 : number
+}
+
+async function bar3() {
+>bar3 : () => Promise<void>
+
+    -await 42; // OK
+>-await 42 : number
+>await 42 : number
+>42 : number
+}
+
+async function bar4() {
+>bar4 : () => Promise<void>
+
+    ~await 42; // OK
+>~await 42 : number
+>await 42 : number
+>42 : number
+}

tests/baselines/reference/await_unaryExpression_es6_1.js

@@ -0,0 +1,56 @@
+//// [await_unaryExpression_es6_1.ts]
+
+async function bar() {
+    !await 42; // OK
+}
+
+async function bar1() {
+    delete await 42; // OK
+}
+
+async function bar2() {
+    delete await 42; // OK
+}
+
+async function bar3() {
+    void await 42;
+}
+
+async function bar4() {
+    +await 42;
+}
+
+//// [await_unaryExpression_es6_1.js]
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments)).next());
+    });
+};
+function bar() {
+    return __awaiter(this, void 0, void 0, function* () {
+        !(yield 42); // OK
+    });
+}
+function bar1() {
+    return __awaiter(this, void 0, void 0, function* () {
+        delete (yield 42); // OK
+    });
+}
+function bar2() {
+    return __awaiter(this, void 0, void 0, function* () {
+        delete (yield 42); // OK
+    });
+}
+function bar3() {
+    return __awaiter(this, void 0, void 0, function* () {
+        void (yield 42);
+    });
+}
+function bar4() {
+    return __awaiter(this, void 0, void 0, function* () {
+        +(yield 42);
+    });
+}

tests/baselines/reference/await_unaryExpression_es6_1.symbols

@@ -0,0 +1,31 @@
+=== tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts ===
+
+async function bar() {
+>bar : Symbol(bar, Decl(await_unaryExpression_es6_1.ts, 0, 0))
+
+    !await 42; // OK
+}
+
+async function bar1() {
+>bar1 : Symbol(bar1, Decl(await_unaryExpression_es6_1.ts, 3, 1))
+
+    delete await 42; // OK
+}
+
+async function bar2() {
+>bar2 : Symbol(bar2, Decl(await_unaryExpression_es6_1.ts, 7, 1))
+
+    delete await 42; // OK
+}
+
+async function bar3() {
+>bar3 : Symbol(bar3, Decl(await_unaryExpression_es6_1.ts, 11, 1))
+
+    void await 42;
+}
+
+async function bar4() {
+>bar4 : Symbol(bar4, Decl(await_unaryExpression_es6_1.ts, 15, 1))
+
+    +await 42;
+}

tests/baselines/reference/await_unaryExpression_es6_1.types

@@ -0,0 +1,46 @@
+=== tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts ===
+
+async function bar() {
+>bar : () => Promise<void>
+
+    !await 42; // OK
+>!await 42 : boolean
+>await 42 : number
+>42 : number
+}
+
+async function bar1() {
+>bar1 : () => Promise<void>
+
+    delete await 42; // OK
+>delete await 42 : boolean
+>await 42 : number
+>42 : number
+}
+
+async function bar2() {
+>bar2 : () => Promise<void>
+
+    delete await 42; // OK
+>delete await 42 : boolean
+>await 42 : number
+>42 : number
+}
+
+async function bar3() {
+>bar3 : () => Promise<void>
+
+    void await 42;
+>void await 42 : undefined
+>await 42 : number
+>42 : number
+}
+
+async function bar4() {
+>bar4 : () => Promise<void>
+
+    +await 42;
+>+await 42 : number
+>await 42 : number
+>42 : number
+}

tests/baselines/reference/await_unaryExpression_es6_2.js

@@ -0,0 +1,38 @@
+//// [await_unaryExpression_es6_2.ts]
+
+async function bar1() {
+    delete await 42;
+}
+
+async function bar2() {
+    delete await 42;
+}
+
+async function bar3() {
+    void await 42;
+}
+
+//// [await_unaryExpression_es6_2.js]
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments)).next());
+    });
+};
+function bar1() {
+    return __awaiter(this, void 0, void 0, function* () {
+        delete (yield 42);
+    });
+}
+function bar2() {
+    return __awaiter(this, void 0, void 0, function* () {
+        delete (yield 42);
+    });
+}
+function bar3() {
+    return __awaiter(this, void 0, void 0, function* () {
+        void (yield 42);
+    });
+}

tests/baselines/reference/await_unaryExpression_es6_2.symbols

@@ -0,0 +1,19 @@
+=== tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts ===
+
+async function bar1() {
+>bar1 : Symbol(bar1, Decl(await_unaryExpression_es6_2.ts, 0, 0))
+
+    delete await 42;
+}
+
+async function bar2() {
+>bar2 : Symbol(bar2, Decl(await_unaryExpression_es6_2.ts, 3, 1))
+
+    delete await 42;
+}
+
+async function bar3() {
+>bar3 : Symbol(bar3, Decl(await_unaryExpression_es6_2.ts, 7, 1))
+
+    void await 42;
+}

tests/baselines/reference/await_unaryExpression_es6_2.types

@@ -0,0 +1,28 @@
+=== tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts ===
+
+async function bar1() {
+>bar1 : () => Promise<void>
+
+    delete await 42;
+>delete await 42 : boolean
+>await 42 : number
+>42 : number
+}
+
+async function bar2() {
+>bar2 : () => Promise<void>
+
+    delete await 42;
+>delete await 42 : boolean
+>await 42 : number
+>42 : number
+}
+
+async function bar3() {
+>bar3 : () => Promise<void>
+
+    void await 42;
+>void await 42 : undefined
+>await 42 : number
+>42 : number
+}

tests/baselines/reference/await_unaryExpression_es6_3.errors.txt

@@ -0,0 +1,27 @@
+tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts(3,7): error TS1109: Expression expected.
+tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts(7,7): error TS1109: Expression expected.
+
+
+==== tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts (2 errors) ====
+    
+    async function bar1() {
+        ++await 42; // Error
+          ~~~~~
+!!! error TS1109: Expression expected.
+    }
+    
+    async function bar2() {
+        --await 42; // Error
+          ~~~~~
+!!! error TS1109: Expression expected.
+    }
+    
+    async function bar3() {
+        var x = 42;
+        await x++; // OK but shouldn't need parenthesis
+    }
+    
+    async function bar4() {
+        var x = 42;
+        await x--; // OK but shouldn't need parenthesis
+    }

tests/baselines/reference/await_unaryExpression_es6_3.js

@@ -0,0 +1,53 @@
+//// [await_unaryExpression_es6_3.ts]
+
+async function bar1() {
+    ++await 42; // Error
+}
+
+async function bar2() {
+    --await 42; // Error
+}
+
+async function bar3() {
+    var x = 42;
+    await x++; // OK but shouldn't need parenthesis
+}
+
+async function bar4() {
+    var x = 42;
+    await x--; // OK but shouldn't need parenthesis
+}
+
+//// [await_unaryExpression_es6_3.js]
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments)).next());
+    });
+};
+function bar1() {
+    return __awaiter(this, void 0, void 0, function* () {
+        ++;
+        yield 42; // Error
+    });
+}
+function bar2() {
+    return __awaiter(this, void 0, void 0, function* () {
+        --;
+        yield 42; // Error
+    });
+}
+function bar3() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var x = 42;
+        yield x++; // OK but shouldn't need parenthesis
+    });
+}
+function bar4() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var x = 42;
+        yield x--; // OK but shouldn't need parenthesis
+    });
+}

tests/baselines/reference/castOfAwait.js

@@ -20,9 +20,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 function f() {
     return __awaiter(this, void 0, void 0, function* () {
         yield 0;
-        typeof yield 0;
-        void yield 0;
-        yield void typeof void yield 0;
+        typeof (yield 0);
+        void (yield 0);
+        yield void typeof void (yield 0);
         yield yield 0;
     });
 }

tests/baselines/reference/castingTuple.errors.txt

@@ -1,10 +1,8 @@
 tests/cases/conformance/types/tuple/castingTuple.ts(28,10): error TS2352: Type '[number, string]' cannot be converted to type '[number, number]'.
-  Types of property '1' are incompatible.
-    Type 'string' is not comparable to type 'number'.
+  Type 'string' is not comparable to type 'number'.
 tests/cases/conformance/types/tuple/castingTuple.ts(29,10): error TS2352: Type '[C, D]' cannot be converted to type '[A, I]'.
-  Types of property '0' are incompatible.
-    Type 'C' is not comparable to type 'A'.
-      Property 'a' is missing in type 'C'.
+  Type 'C' is not comparable to type 'A'.
+    Property 'a' is missing in type 'C'.
 tests/cases/conformance/types/tuple/castingTuple.ts(30,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'array1' must be of type '{}[]', but here has type 'number[]'.
 tests/cases/conformance/types/tuple/castingTuple.ts(31,1): error TS2304: Cannot find name 't4'.
 
@@ -40,14 +38,12 @@ tests/cases/conformance/types/tuple/castingTuple.ts(31,1): error TS2304: Cannot
     var t3 = <[number, number]>numStrTuple;
              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2352: Type '[number, string]' cannot be converted to type '[number, number]'.
-!!! error TS2352:   Types of property '1' are incompatible.
-!!! error TS2352:     Type 'string' is not comparable to type 'number'.
+!!! error TS2352:   Type 'string' is not comparable to type 'number'.
     var t9 = <[A, I]>classCDTuple;
              ~~~~~~~~~~~~~~~~~~~~
 !!! error TS2352: Type '[C, D]' cannot be converted to type '[A, I]'.
-!!! error TS2352:   Types of property '0' are incompatible.
-!!! error TS2352:     Type 'C' is not comparable to type 'A'.
-!!! error TS2352:       Property 'a' is missing in type 'C'.
+!!! error TS2352:   Type 'C' is not comparable to type 'A'.
+!!! error TS2352:     Property 'a' is missing in type 'C'.
     var array1 = <number[]>numStrTuple;
         ~~~~~~
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'array1' must be of type '{}[]', but here has type 'number[]'.

tests/baselines/reference/constructableDecoratorOnClass01.errors.txt

@@ -0,0 +1,16 @@
+tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts(4,1): error TS1238: Unable to resolve signature of class decorator when called as an expression.
+  Cannot invoke an expression whose type lacks a call signature.
+
+
+==== tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts (1 errors) ====
+    
+    class CtorDtor {}
+    
+    @CtorDtor
+    ~~~~~~~~~
+!!! error TS1238: Unable to resolve signature of class decorator when called as an expression.
+!!! error TS1238:   Cannot invoke an expression whose type lacks a call signature.
+    class C {
+    
+    }
+    

tests/baselines/reference/constructableDecoratorOnClass01.js

@@ -0,0 +1,30 @@
+//// [constructableDecoratorOnClass01.ts]
+
+class CtorDtor {}
+
+@CtorDtor
+class C {
+
+}
+
+
+//// [constructableDecoratorOnClass01.js]
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var CtorDtor = (function () {
+    function CtorDtor() {
+    }
+    return CtorDtor;
+}());
+var C = (function () {
+    function C() {
+    }
+    C = __decorate([
+        CtorDtor
+    ], C);
+    return C;
+}());

tests/baselines/reference/constructableDecoratorOnClass01.symbols

@@ -0,0 +1,13 @@
+=== tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts ===
+
+class CtorDtor {}
+>CtorDtor : Symbol(CtorDtor, Decl(constructableDecoratorOnClass01.ts, 0, 0))
+
+@CtorDtor
+>CtorDtor : Symbol(CtorDtor, Decl(constructableDecoratorOnClass01.ts, 0, 0))
+
+class C {
+>C : Symbol(C, Decl(constructableDecoratorOnClass01.ts, 1, 17))
+
+}
+

tests/baselines/reference/constructableDecoratorOnClass01.types

@@ -0,0 +1,13 @@
+=== tests/cases/conformance/decorators/class/constructableDecoratorOnClass01.ts ===
+
+class CtorDtor {}
+>CtorDtor : CtorDtor
+
+@CtorDtor
+>CtorDtor : typeof CtorDtor
+
+class C {
+>C : C
+
+}
+

tests/baselines/reference/contextualTypeWithTuple.errors.txt

@@ -5,9 +5,8 @@ tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(3,5): error TS232
         Type 'true' is not assignable to type 'string | number'.
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(15,1): error TS2322: Type '[number, string, boolean]' is not assignable to type '[number, string]'.
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(18,1): error TS2322: Type '[{}, number]' is not assignable to type '[{ a: string; }, number]'.
-  Types of property '0' are incompatible.
-    Type '{}' is not assignable to type '{ a: string; }'.
-      Property 'a' is missing in type '{}'.
+  Type '{}' is not assignable to type '{ a: string; }'.
+    Property 'a' is missing in type '{}'.
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(19,1): error TS2322: Type '[number, string]' is not assignable to type '[number, string, boolean]'.
   Property '2' is missing in type '[number, string]'.
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(20,5): error TS2322: Type '[string, string, number]' is not assignable to type '[string, string]'.
@@ -18,9 +17,8 @@ tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(20,5): error TS23
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(24,1): error TS2322: Type '[C, string | number]' is not assignable to type '[C, string | number, D]'.
   Property '2' is missing in type '[C, string | number]'.
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(25,1): error TS2322: Type '[number, string | number]' is not assignable to type '[number, string]'.
-  Types of property '1' are incompatible.
-    Type 'string | number' is not assignable to type 'string'.
-      Type 'number' is not assignable to type 'string'.
+  Type 'string | number' is not assignable to type 'string'.
+    Type 'number' is not assignable to type 'string'.
 
 
 ==== tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts (7 errors) ====
@@ -52,9 +50,8 @@ tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(25,1): error TS23
     objNumTuple = [ {}, 5];
     ~~~~~~~~~~~
 !!! error TS2322: Type '[{}, number]' is not assignable to type '[{ a: string; }, number]'.
-!!! error TS2322:   Types of property '0' are incompatible.
-!!! error TS2322:     Type '{}' is not assignable to type '{ a: string; }'.
-!!! error TS2322:       Property 'a' is missing in type '{}'.
+!!! error TS2322:   Type '{}' is not assignable to type '{ a: string; }'.
+!!! error TS2322:     Property 'a' is missing in type '{}'.
     numStrBoolTuple = numStrTuple;
     ~~~~~~~~~~~~~~~
 !!! error TS2322: Type '[number, string]' is not assignable to type '[number, string, boolean]'.
@@ -76,6 +73,5 @@ tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(25,1): error TS23
     numStrTuple = unionTuple3;
     ~~~~~~~~~~~
 !!! error TS2322: Type '[number, string | number]' is not assignable to type '[number, string]'.
-!!! error TS2322:   Types of property '1' are incompatible.
-!!! error TS2322:     Type 'string | number' is not assignable to type 'string'.
-!!! error TS2322:       Type 'number' is not assignable to type 'string'.
+!!! error TS2322:   Type 'string | number' is not assignable to type 'string'.
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.

tests/baselines/reference/contextuallyTypedBindingInitializerNegative.errors.txt

@@ -11,8 +11,7 @@ tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTyp
 tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedBindingInitializerNegative.ts(16,23): error TS2322: Type '(arg: string) => number' is not assignable to type '(s: string) => string'.
   Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedBindingInitializerNegative.ts(21,14): error TS2322: Type '[number, number]' is not assignable to type '[string, number]'.
-  Types of property '0' are incompatible.
-    Type 'number' is not assignable to type 'string'.
+  Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTypedBindingInitializerNegative.ts(26,14): error TS2322: Type '"baz"' is not assignable to type '"foo" | "bar"'.
 
 
@@ -57,8 +56,7 @@ tests/cases/conformance/types/contextualTypes/methodDeclarations/contextuallyTyp
     function g({ prop = [101, 1234] }: Tuples) {}
                  ~~~~
 !!! error TS2322: Type '[number, number]' is not assignable to type '[string, number]'.
-!!! error TS2322:   Types of property '0' are incompatible.
-!!! error TS2322:     Type 'number' is not assignable to type 'string'.
+!!! error TS2322:   Type 'number' is not assignable to type 'string'.
     
     interface StringUnion {
         prop: "foo" | "bar";

tests/baselines/reference/declFileConstructors.js

@@ -247,7 +247,7 @@ export declare class ConstructorWithPrivateParameterProperty {
     constructor(x: string);
 }
 export declare class ConstructorWithOptionalParameterProperty {
-    x?: string;
+    x: string;
     constructor(x?: string);
 }
 export declare class ConstructorWithParameterInitializer {
@@ -281,7 +281,7 @@ declare class GlobalConstructorWithPrivateParameterProperty {
     constructor(x: string);
 }
 declare class GlobalConstructorWithOptionalParameterProperty {
-    x?: string;
+    x: string;
     constructor(x?: string);
 }
 declare class GlobalConstructorWithParameterInitializer {

tests/baselines/reference/declarationsAndAssignments.errors.txt

@@ -18,11 +18,9 @@ tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(73,14):
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(74,11): error TS2459: Type 'undefined[]' has no property 'a' and no string index signature.
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(74,14): error TS2459: Type 'undefined[]' has no property 'b' and no string index signature.
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(106,5): error TS2345: Argument of type '[number, [string, { y: boolean; }]]' is not assignable to parameter of type '[number, [string, { x: any; y?: boolean; }]]'.
-  Types of property '1' are incompatible.
-    Type '[string, { y: boolean; }]' is not assignable to type '[string, { x: any; y?: boolean; }]'.
-      Types of property '1' are incompatible.
-        Type '{ y: boolean; }' is not assignable to type '{ x: any; y?: boolean; }'.
-          Property 'x' is missing in type '{ y: boolean; }'.
+  Type '[string, { y: boolean; }]' is not assignable to type '[string, { x: any; y?: boolean; }]'.
+    Type '{ y: boolean; }' is not assignable to type '{ x: any; y?: boolean; }'.
+      Property 'x' is missing in type '{ y: boolean; }'.
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(138,6): error TS2322: Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(138,9): error TS2322: Type 'number' is not assignable to type 'string'.
 
@@ -174,11 +172,9 @@ tests/cases/conformance/es6/destructuring/declarationsAndAssignments.ts(138,9):
     f14([2, ["abc", { y: false }]]);  // Error, no x
         ~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '[number, [string, { y: boolean; }]]' is not assignable to parameter of type '[number, [string, { x: any; y?: boolean; }]]'.
-!!! error TS2345:   Types of property '1' are incompatible.
-!!! error TS2345:     Type '[string, { y: boolean; }]' is not assignable to type '[string, { x: any; y?: boolean; }]'.
-!!! error TS2345:       Types of property '1' are incompatible.
-!!! error TS2345:         Type '{ y: boolean; }' is not assignable to type '{ x: any; y?: boolean; }'.
-!!! error TS2345:           Property 'x' is missing in type '{ y: boolean; }'.
+!!! error TS2345:   Type '[string, { y: boolean; }]' is not assignable to type '[string, { x: any; y?: boolean; }]'.
+!!! error TS2345:     Type '{ y: boolean; }' is not assignable to type '{ x: any; y?: boolean; }'.
+!!! error TS2345:       Property 'x' is missing in type '{ y: boolean; }'.
     
     module M {
         export var [a, b] = [1, 2];

tests/baselines/reference/destructuringArrayBindingPatternAndAssignment2.errors.txt

@@ -2,8 +2,7 @@ tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAss
 tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment2.ts(3,12): error TS2525: Initializer provides no value for this binding element and the binding element has no default value.
 tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment2.ts(4,5): error TS2461: Type 'undefined' is not an array type.
 tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment2.ts(9,5): error TS2322: Type '[number, number, string]' is not assignable to type '[number, boolean, string]'.
-  Types of property '1' are incompatible.
-    Type 'number' is not assignable to type 'boolean'.
+  Type 'number' is not assignable to type 'boolean'.
 tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment2.ts(17,6): error TS2322: Type 'string' is not assignable to type 'Number'.
 tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment2.ts(22,5): error TS2322: Type 'number[]' is not assignable to type '[number, number]'.
   Property '0' is missing in type 'number[]'.
@@ -30,8 +29,7 @@ tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAss
     var [b0, b1, b2]: [number, boolean, string] = [1, 2, "string"];  // Error
         ~~~~~~~~~~~~
 !!! error TS2322: Type '[number, number, string]' is not assignable to type '[number, boolean, string]'.
-!!! error TS2322:   Types of property '1' are incompatible.
-!!! error TS2322:     Type 'number' is not assignable to type 'boolean'.
+!!! error TS2322:   Type 'number' is not assignable to type 'boolean'.
     interface J extends Array<Number> {
         2: number;
     }

tests/baselines/reference/destructuringParameterDeclaration2.errors.txt

@@ -1,6 +1,5 @@
 tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(7,4): error TS2345: Argument of type '[number, string, string[][]]' is not assignable to parameter of type '[number, number, string[][]]'.
-  Types of property '1' are incompatible.
-    Type 'string' is not assignable to type 'number'.
+  Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(7,29): error TS1005: ',' expected.
 tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(8,4): error TS2345: Argument of type '[number, number, string[][], string]' is not assignable to parameter of type '[number, number, string[][]]'.
   Types of property 'pop' are incompatible.
@@ -32,12 +31,9 @@ tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(
   Types of property '2' are incompatible.
     Type 'boolean' is not assignable to type '[[any]]'.
 tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(40,4): error TS2345: Argument of type '[number, number, [[string]]]' is not assignable to parameter of type '[any, any, [[number]]]'.
-  Types of property '2' are incompatible.
-    Type '[[string]]' is not assignable to type '[[number]]'.
-      Types of property '0' are incompatible.
-        Type '[string]' is not assignable to type '[number]'.
-          Types of property '0' are incompatible.
-            Type 'string' is not assignable to type 'number'.
+  Type '[[string]]' is not assignable to type '[[number]]'.
+    Type '[string]' is not assignable to type '[number]'.
+      Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(46,13): error TS2463: A binding pattern parameter cannot be optional in an implementation signature.
 tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(47,13): error TS2463: A binding pattern parameter cannot be optional in an implementation signature.
 tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(55,7): error TS2420: Class 'C4' incorrectly implements interface 'F2'.
@@ -62,8 +58,7 @@ tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(
     a0([1, "string", [["world"]]);      // Error
        ~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '[number, string, string[][]]' is not assignable to parameter of type '[number, number, string[][]]'.
-!!! error TS2345:   Types of property '1' are incompatible.
-!!! error TS2345:     Type 'string' is not assignable to type 'number'.
+!!! error TS2345:   Type 'string' is not assignable to type 'number'.
                                 ~
 !!! error TS1005: ',' expected.
     a0([1, 2, [["world"]], "string"]);  // Error
@@ -142,12 +137,9 @@ tests/cases/conformance/es6/destructuring/destructuringParameterDeclaration2.ts(
     c6([1, 2, [["string"]]]);  // Error, implied type is [any, any, [[number]]]  // Use initializer
        ~~~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '[number, number, [[string]]]' is not assignable to parameter of type '[any, any, [[number]]]'.
-!!! error TS2345:   Types of property '2' are incompatible.
-!!! error TS2345:     Type '[[string]]' is not assignable to type '[[number]]'.
-!!! error TS2345:       Types of property '0' are incompatible.
-!!! error TS2345:         Type '[string]' is not assignable to type '[number]'.
-!!! error TS2345:           Types of property '0' are incompatible.
-!!! error TS2345:             Type 'string' is not assignable to type 'number'.
+!!! error TS2345:   Type '[[string]]' is not assignable to type '[[number]]'.
+!!! error TS2345:     Type '[string]' is not assignable to type '[number]'.
+!!! error TS2345:       Type 'string' is not assignable to type 'number'.
     
     // A parameter can be marked optional by following its name or binding pattern with a question mark (?)
     // or by including an initializer.  Initializers (including binding property or element initializers) are

tests/baselines/reference/destructuringParameterProperties2.errors.txt

@@ -6,8 +6,7 @@ tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(9
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(13,21): error TS2339: Property 'b' does not exist on type 'C1'.
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(17,21): error TS2339: Property 'c' does not exist on type 'C1'.
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(21,27): error TS2345: Argument of type '[number, undefined, string]' is not assignable to parameter of type '[number, string, boolean]'.
-  Types of property '2' are incompatible.
-    Type 'string' is not assignable to type 'boolean'.
+  Type 'string' is not assignable to type 'boolean'.
 
 
 ==== tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts (8 errors) ====
@@ -48,8 +47,7 @@ tests/cases/conformance/es6/destructuring/destructuringParameterProperties2.ts(2
     var x = new C1(undefined, [0, undefined, ""]);
                               ~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '[number, undefined, string]' is not assignable to parameter of type '[number, string, boolean]'.
-!!! error TS2345:   Types of property '2' are incompatible.
-!!! error TS2345:     Type 'string' is not assignable to type 'boolean'.
+!!! error TS2345:   Type 'string' is not assignable to type 'boolean'.
     var [x_a, x_b, x_c] = [x.getA(), x.getB(), x.getC()];
     
     var y = new C1(10, [0, "", true]);

tests/baselines/reference/destructuringParameterProperties5.errors.txt

@@ -8,9 +8,8 @@ tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7,62): error TS2339: Property 'y' does not exist on type 'C1'.
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(7,72): error TS2339: Property 'z' does not exist on type 'C1'.
 tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(11,19): error TS2345: Argument of type '[{ x1: number; x2: string; x3: boolean; }, string, boolean]' is not assignable to parameter of type '[{ x: number; y: string; z: boolean; }, number, string]'.
-  Types of property '0' are incompatible.
-    Type '{ x1: number; x2: string; x3: boolean; }' is not assignable to type '{ x: number; y: string; z: boolean; }'.
-      Object literal may only specify known properties, and 'x1' does not exist in type '{ x: number; y: string; z: boolean; }'.
+  Type '{ x1: number; x2: string; x3: boolean; }' is not assignable to type '{ x: number; y: string; z: boolean; }'.
+    Object literal may only specify known properties, and 'x1' does not exist in type '{ x: number; y: string; z: boolean; }'.
 
 
 ==== tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts (10 errors) ====
@@ -45,7 +44,6 @@ tests/cases/conformance/es6/destructuring/destructuringParameterProperties5.ts(1
     var a = new C1([{ x1: 10, x2: "", x3: true }, "", false]);
                       ~~~~~~
 !!! error TS2345: Argument of type '[{ x1: number; x2: string; x3: boolean; }, string, boolean]' is not assignable to parameter of type '[{ x: number; y: string; z: boolean; }, number, string]'.
-!!! error TS2345:   Types of property '0' are incompatible.
-!!! error TS2345:     Type '{ x1: number; x2: string; x3: boolean; }' is not assignable to type '{ x: number; y: string; z: boolean; }'.
-!!! error TS2345:       Object literal may only specify known properties, and 'x1' does not exist in type '{ x: number; y: string; z: boolean; }'.
+!!! error TS2345:   Type '{ x1: number; x2: string; x3: boolean; }' is not assignable to type '{ x: number; y: string; z: boolean; }'.
+!!! error TS2345:     Object literal may only specify known properties, and 'x1' does not exist in type '{ x: number; y: string; z: boolean; }'.
     var [a_x1, a_x2, a_x3, a_y, a_z] = [a.x1, a.x2, a.x3, a.y, a.z];