diff --git a/Gulpfile.ts b/Gulpfile.ts
index 1b90256283264..295a7ce03d9d7 100644
--- a/Gulpfile.ts
+++ b/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) => {
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 8568cd5feed2f..3fdc3630b4d50 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -106,7 +106,7 @@ namespace ts {
             isOptionalParameter
         };
 
-        const tupleTypes = createMap<TupleType>();
+        const tupleTypes: GenericType[] = [];
         const unionTypes = createMap<UnionType>();
         const intersectionTypes = createMap<IntersectionType>();
         const stringLiteralTypes = createMap<LiteralType>();
@@ -1126,13 +1126,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;
@@ -2145,9 +2145,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);
@@ -2214,6 +2211,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
@@ -2242,12 +2244,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);
@@ -2958,7 +2954,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);
@@ -3070,9 +3066,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);
                 }
@@ -3150,12 +3151,13 @@ 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
@@ -3564,17 +3566,20 @@ 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) {
-                    Debug.fail("type must be class or interface");
+                if (type.flags & TypeFlags.Tuple) {
+                    type.resolvedBaseTypes = [createArrayType(getUnionType(type.typeParameters))];
                 }
-                if (isClass) {
-                    resolveBaseTypesOfClass(type);
+                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);
+                    }
                 }
-                if (isInterface) {
-                    resolveBaseTypesOfInterface(type);
+                else {
+                    Debug.fail("type must be class or interface");
                 }
             }
             return type.resolvedBaseTypes;
@@ -4001,20 +4006,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);
@@ -4024,7 +4034,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);
@@ -4094,26 +4104,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)) {
@@ -4292,9 +4282,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);
                 }
@@ -4694,6 +4681,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))
@@ -4992,6 +4982,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));
@@ -5234,17 +5235,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 {
@@ -5552,6 +5583,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);
@@ -5845,9 +5882,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);
                 }
@@ -7168,8 +7202,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 {
@@ -7301,11 +7335,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;
@@ -7331,11 +7362,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;
                     }
@@ -7445,7 +7473,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));
         }
@@ -7548,14 +7575,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;
@@ -9100,10 +9119,6 @@ namespace ts {
                         return getInferredClassType(classSymbol);
                     }
                 }
-                const type = getContextuallyTypedThisType(container);
-                if (type) {
-                    return type;
-                }
 
                 const thisType = getThisTypeOfDeclaration(container);
                 if (thisType) {
@@ -9344,11 +9359,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;
                 }
             }
 
@@ -9913,7 +9928,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;
                 }
@@ -9927,7 +9942,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) {
@@ -12291,6 +12306,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);
@@ -13038,7 +13059,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);
@@ -18515,7 +18536,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)) {
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 357a15507a457..d0f7918dc8900 100644
--- a/src/compiler/emitter.ts
+++ b/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;
             }
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 035b74230f172..b5ba89887a26c 100644
--- a/src/compiler/parser.ts
+++ b/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.
@@ -2765,7 +2765,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 +3373,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 +3424,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 +3448,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 +3465,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 +3483,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 +5912,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:
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 1b0e0efd640c1..64ef04cd67df5 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -721,8 +721,10 @@ 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;
                 }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 7594d2c3fb8af..50beef52bf812 100644
--- a/src/compiler/types.ts
+++ b/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 {
@@ -2263,7 +2266,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
@@ -2385,11 +2388,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 */
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 870df4a54af56..0c026fc6b6d45 100644
--- a/src/compiler/utilities.ts
+++ b/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);
diff --git a/src/harness/rwcRunner.ts b/src/harness/rwcRunner.ts
index d56e8d6d35f63..ba1ab71ec19d3 100644
--- a/src/harness/rwcRunner.ts
+++ b/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,7 +223,7 @@ namespace RWC {
             });
 
             it("has the expected types", () => {
-                Harness.Compiler.doTypeAndSymbolBaseline(baseName, compilerResult, inputFiles
+                Harness.Compiler.doTypeAndSymbolBaseline(`${baseName}.types`, compilerResult, inputFiles
                     .concat(otherFiles)
                     .filter(file => !!compilerResult.program.getSourceFile(file.unitName))
                     .filter(e => !Harness.isDefaultLibraryFile(e.unitName)), baselineOpts);
diff --git a/src/harness/unittests/jsDocParsing.ts b/src/harness/unittests/jsDocParsing.ts
index d1ca42f38612e..a9987ef3176e6 100644
--- a/src/harness/unittests/jsDocParsing.ts
+++ b/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 {
             });
         });
     });
-}
\ No newline at end of file
+}
diff --git a/src/harness/unittests/tsconfigParsing.ts b/src/harness/unittests/tsconfigParsing.ts
index 557379dff3b7d..2c9bcdb84233e 100644
--- a/src/harness/unittests/tsconfigParsing.ts
+++ b/src/harness/unittests/tsconfigParsing.ts
@@ -181,5 +181,25 @@ namespace ts {
                 ["/d.ts", "/folder/e.ts"]
             );
         });
+
+        it("parse and re-emit tsconfig.json file with diagnostics", () => {
+            const content = `{
+                "compilerOptions": {
+                    "allowJs": true
+                    "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));
+        });
     });
 }
diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts
index 49f033b9defcb..d4ed84191b41f 100644
--- a/src/harness/unittests/tsserverProjectSystem.ts
+++ b/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]);
+        });
     });
 }
\ No newline at end of file
diff --git a/src/lib/dom.generated.d.ts b/src/lib/dom.generated.d.ts
index d2938f6e983dc..ee657f64a65c3 100644
--- a/src/lib/dom.generated.d.ts
+++ b/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;
\ No newline at end of file
diff --git a/src/lib/webworker.generated.d.ts b/src/lib/webworker.generated.d.ts
index c61a1a8b8a600..483348f3f750e 100644
--- a/src/lib/webworker.generated.d.ts
+++ b/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 {
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index db9bdd5043bf6..255ad8547ea48 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -603,8 +603,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 {
@@ -699,7 +702,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)));
@@ -717,18 +721,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));
@@ -748,10 +766,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") {
@@ -828,13 +849,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 } });
                     }
                 }
             }
@@ -1218,7 +1239,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 {
@@ -1234,11 +1255,12 @@ namespace ts.server {
                 else {
                     this.updateConfiguredProject(project);
                 }
+                return { configFileName };
             }
             else {
                 this.log("No config files found.");
             }
-            return configFileName ? { configFileName } : {};
+            return {};
         }
 
         /**
@@ -1328,34 +1350,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 };
             }
         }
 
@@ -1377,64 +1396,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);
-
-                        // 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 };
-                    }
+            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 { project, errors };
                 }
+            }
 
-                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));
-                    }
+            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));
+            }
+            project.finishGraph();
+            project.projectFileWatcher = this.host.watchFile(configFilename, _ => this.watchedProjectConfigFileChanged(project));
 
-                const configDirectoryPath = ts.getDirectoryPath(configFilename);
+            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
-                );
+            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
-                        );
-                    }
+            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 watchers;
+            }, <Map<FileWatcher>>{});
 
-                return { success: true, project: project, errors };
-            }
+            return { project: project, errors };
         }
 
         updateConfiguredProject(project: Project): Diagnostic[] {
@@ -1443,15 +1461,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();
@@ -1459,7 +1477,7 @@ namespace ts.server {
                             project.directoryWatcher.close();
                             project.directoryWatcher = undefined;
                         }
-                        return;
+                        return errors;
                     }
 
                     if (project.languageServiceDiabled) {
@@ -1478,7 +1496,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
@@ -1524,6 +1542,7 @@ namespace ts.server {
                     project.setProjectOptions(projectOptions);
                     project.finishGraph();
                 }
+                return errors;
             }
         }
 
diff --git a/src/server/session.ts b/src/server/session.ts
index 9383a54bd48f7..00468330ffbcb 100644
--- a/src/server/session.ts
+++ b/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);
             }
         }
 
diff --git a/src/services/services.ts b/src/services/services.ts
index d200e081c5aa0..babb5cf45741f 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -299,6 +299,10 @@ namespace ts {
                         processNode(jsDocComment);
                     }
                 }
+                // For syntactic classifications, all trivia are classcified together, including jsdoc comments.
+                // For that to work, the jsdoc comments should still be the leading trivia of the first child. 
+                // Restoring the scanner position ensures that. 
+                pos = this.pos;
                 forEachChild(this, processNode, processNodes);
                 if (pos < this.end) {
                     this.addSyntheticNodes(children, pos, this.end);
@@ -7596,6 +7600,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;
                 }
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index 7f41cdbb3a42e..858f889bc6c91 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -925,4 +925,24 @@ namespace ts {
         }
         return ensureScriptKind(fileName, scriptKind);
     }
+
+    export function parseAndReEmitConfigJSONFile(content: string) {
+        const options: TranspileOptions = {
+            fileName: "config.js",
+            compilerOptions: {
+                target: ScriptTarget.ES6
+            },
+            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 };
+    }
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt b/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt
index d60f0b7d03c47..a6a685069d6b0 100644
--- a/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt
+++ b/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]'.
diff --git a/tests/baselines/reference/arrayLiterals3.errors.txt b/tests/baselines/reference/arrayLiterals3.errors.txt
index 8e6c7eccf81f8..f221fd96fab63 100644
--- a/tests/baselines/reference/arrayLiterals3.errors.txt
+++ b/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'.
@@ -37,8 +36,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),
diff --git a/tests/baselines/reference/await_unaryExpression_es6.js b/tests/baselines/reference/await_unaryExpression_es6.js
new file mode 100644
index 0000000000000..46065bdada925
--- /dev/null
+++ b/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
+    });
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6.symbols b/tests/baselines/reference/await_unaryExpression_es6.symbols
new file mode 100644
index 0000000000000..81edd4b981b1b
--- /dev/null
+++ b/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
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6.types b/tests/baselines/reference/await_unaryExpression_es6.types
new file mode 100644
index 0000000000000..2a4b7354d3ebf
--- /dev/null
+++ b/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
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6_1.js b/tests/baselines/reference/await_unaryExpression_es6_1.js
new file mode 100644
index 0000000000000..c6f5f1142c085
--- /dev/null
+++ b/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);
+    });
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6_1.symbols b/tests/baselines/reference/await_unaryExpression_es6_1.symbols
new file mode 100644
index 0000000000000..ed7d7e4ed02e9
--- /dev/null
+++ b/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;
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6_1.types b/tests/baselines/reference/await_unaryExpression_es6_1.types
new file mode 100644
index 0000000000000..a5c3740b677f1
--- /dev/null
+++ b/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
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6_2.js b/tests/baselines/reference/await_unaryExpression_es6_2.js
new file mode 100644
index 0000000000000..3c341018ed16c
--- /dev/null
+++ b/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);
+    });
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6_2.symbols b/tests/baselines/reference/await_unaryExpression_es6_2.symbols
new file mode 100644
index 0000000000000..574ea4d433a7a
--- /dev/null
+++ b/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;
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6_2.types b/tests/baselines/reference/await_unaryExpression_es6_2.types
new file mode 100644
index 0000000000000..b438f063add31
--- /dev/null
+++ b/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
+}
diff --git a/tests/baselines/reference/await_unaryExpression_es6_3.errors.txt b/tests/baselines/reference/await_unaryExpression_es6_3.errors.txt
new file mode 100644
index 0000000000000..5518f84983f78
--- /dev/null
+++ b/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
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/await_unaryExpression_es6_3.js b/tests/baselines/reference/await_unaryExpression_es6_3.js
new file mode 100644
index 0000000000000..077e264c450e4
--- /dev/null
+++ b/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
+    });
+}
diff --git a/tests/baselines/reference/castOfAwait.js b/tests/baselines/reference/castOfAwait.js
index 95817b7f0e604..26e9812bf431e 100644
--- a/tests/baselines/reference/castOfAwait.js
+++ b/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;
     });
 }
diff --git a/tests/baselines/reference/castingTuple.errors.txt b/tests/baselines/reference/castingTuple.errors.txt
index 6d5549c6bf2ae..2f9eeedf9efd5 100644
--- a/tests/baselines/reference/castingTuple.errors.txt
+++ b/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[]'.
diff --git a/tests/baselines/reference/contextualTypeWithTuple.errors.txt b/tests/baselines/reference/contextualTypeWithTuple.errors.txt
index e0580ca237961..a488d8c764829 100644
--- a/tests/baselines/reference/contextualTypeWithTuple.errors.txt
+++ b/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'.
\ No newline at end of file
+!!! error TS2322:   Type 'string | number' is not assignable to type 'string'.
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.
\ No newline at end of file
diff --git a/tests/baselines/reference/contextuallyTypedBindingInitializerNegative.errors.txt b/tests/baselines/reference/contextuallyTypedBindingInitializerNegative.errors.txt
index 42d617887e015..447ccec5ddf91 100644
--- a/tests/baselines/reference/contextuallyTypedBindingInitializerNegative.errors.txt
+++ b/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";
diff --git a/tests/baselines/reference/declarationsAndAssignments.errors.txt b/tests/baselines/reference/declarationsAndAssignments.errors.txt
index 517eaafe4abbe..3ed9e241c3992 100644
--- a/tests/baselines/reference/declarationsAndAssignments.errors.txt
+++ b/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];
diff --git a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment2.errors.txt b/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment2.errors.txt
index 3348effe8225d..e22b23122d34d 100644
--- a/tests/baselines/reference/destructuringArrayBindingPatternAndAssignment2.errors.txt
+++ b/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;
     }
diff --git a/tests/baselines/reference/destructuringParameterDeclaration2.errors.txt b/tests/baselines/reference/destructuringParameterDeclaration2.errors.txt
index 878bb38abf0fc..d76a4efe5f15a 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration2.errors.txt
+++ b/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
diff --git a/tests/baselines/reference/destructuringParameterProperties2.errors.txt b/tests/baselines/reference/destructuringParameterProperties2.errors.txt
index ec0f400631fe4..deb039aa67db5 100644
--- a/tests/baselines/reference/destructuringParameterProperties2.errors.txt
+++ b/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]);
diff --git a/tests/baselines/reference/destructuringParameterProperties5.errors.txt b/tests/baselines/reference/destructuringParameterProperties5.errors.txt
index 6f5801b7898c8..8eff6ad0febee 100644
--- a/tests/baselines/reference/destructuringParameterProperties5.errors.txt
+++ b/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];
\ No newline at end of file
diff --git a/tests/baselines/reference/destructuringVariableDeclaration2.errors.txt b/tests/baselines/reference/destructuringVariableDeclaration2.errors.txt
index 1a6558377434e..bdbda6f9a96eb 100644
--- a/tests/baselines/reference/destructuringVariableDeclaration2.errors.txt
+++ b/tests/baselines/reference/destructuringVariableDeclaration2.errors.txt
@@ -2,12 +2,9 @@ tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration2.ts(3
   Types of property 'a1' are incompatible.
     Type 'boolean' is not assignable to type 'number'.
 tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration2.ts(4,5): error TS2322: Type '[number, [[boolean]], boolean]' is not assignable to type '[number, [[string]], boolean]'.
-  Types of property '1' are incompatible.
-    Type '[[boolean]]' is not assignable to type '[[string]]'.
-      Types of property '0' are incompatible.
-        Type '[boolean]' is not assignable to type '[string]'.
-          Types of property '0' are incompatible.
-            Type 'boolean' is not assignable to type 'string'.
+  Type '[[boolean]]' is not assignable to type '[[string]]'.
+    Type '[boolean]' is not assignable to type '[string]'.
+      Type 'boolean' is not assignable to type 'string'.
 tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration2.ts(9,25): error TS2322: Type '{ t1: boolean; t2: string; }' is not assignable to type '{ t1: boolean; t2: number; }'.
   Types of property 't2' are incompatible.
     Type 'string' is not assignable to type 'number'.
@@ -28,12 +25,9 @@ tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration2.ts(1
     var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [[false]], true];  // Error
         ~~~~~~~~~~~~~~~~
 !!! error TS2322: Type '[number, [[boolean]], boolean]' is not assignable to type '[number, [[string]], boolean]'.
-!!! error TS2322:   Types of property '1' are incompatible.
-!!! error TS2322:     Type '[[boolean]]' is not assignable to type '[[string]]'.
-!!! error TS2322:       Types of property '0' are incompatible.
-!!! error TS2322:         Type '[boolean]' is not assignable to type '[string]'.
-!!! error TS2322:           Types of property '0' are incompatible.
-!!! error TS2322:             Type 'boolean' is not assignable to type 'string'.
+!!! error TS2322:   Type '[[boolean]]' is not assignable to type '[[string]]'.
+!!! error TS2322:     Type '[boolean]' is not assignable to type '[string]'.
+!!! error TS2322:       Type 'boolean' is not assignable to type 'string'.
     
     // The type T associated with a destructuring variable declaration is determined as follows:
     //      Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression.
diff --git a/tests/baselines/reference/genericCallWithTupleType.errors.txt b/tests/baselines/reference/genericCallWithTupleType.errors.txt
index 0194dc61311ee..617c4f7159b54 100644
--- a/tests/baselines/reference/genericCallWithTupleType.errors.txt
+++ b/tests/baselines/reference/genericCallWithTupleType.errors.txt
@@ -6,11 +6,9 @@ tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTup
 tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTupleType.ts(14,1): error TS2322: Type '{ a: string; }' is not assignable to type 'string | number'.
   Type '{ a: string; }' is not assignable to type 'number'.
 tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTupleType.ts(22,1): error TS2322: Type '[number, string]' 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/typeRelationships/typeInference/genericCallWithTupleType.ts(23,1): error TS2322: Type '[{}, {}]' is not assignable to type '[string, number]'.
-  Types of property '0' are incompatible.
-    Type '{}' is not assignable to type 'string'.
+  Type '{}' is not assignable to type 'string'.
 tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTupleType.ts(24,1): error TS2322: Type '[{}]' is not assignable to type '[{}, {}]'.
   Property '1' is missing in type '[{}]'.
 
@@ -49,13 +47,11 @@ tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTup
     i1.tuple1 = [5, "foo"];
     ~~~~~~~~~
 !!! error TS2322: Type '[number, string]' 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'.
     i1.tuple1 = [{}, {}];
     ~~~~~~~~~
 !!! error TS2322: Type '[{}, {}]' is not assignable to type '[string, number]'.
-!!! error TS2322:   Types of property '0' are incompatible.
-!!! error TS2322:     Type '{}' is not assignable to type 'string'.
+!!! error TS2322:   Type '{}' is not assignable to type 'string'.
     i2.tuple1 = [{}];
     ~~~~~~~~~
 !!! error TS2322: Type '[{}]' is not assignable to type '[{}, {}]'.
diff --git a/tests/baselines/reference/instantiateContextuallyTypedGenericThis.js b/tests/baselines/reference/instantiateContextuallyTypedGenericThis.js
new file mode 100644
index 0000000000000..176df15985f3a
--- /dev/null
+++ b/tests/baselines/reference/instantiateContextuallyTypedGenericThis.js
@@ -0,0 +1,20 @@
+//// [instantiateContextuallyTypedGenericThis.ts]
+interface JQuery {
+    each<T>(
+        collection: T[], callback: (this: T, dit: T) => T
+    ): T[];
+}
+
+let $: JQuery;
+let lines: string[];
+$.each(lines, function(dit) {
+    return dit.charAt(0) + this.charAt(1);
+});
+
+
+//// [instantiateContextuallyTypedGenericThis.js]
+var $;
+var lines;
+$.each(lines, function (dit) {
+    return dit.charAt(0) + this.charAt(1);
+});
diff --git a/tests/baselines/reference/instantiateContextuallyTypedGenericThis.symbols b/tests/baselines/reference/instantiateContextuallyTypedGenericThis.symbols
new file mode 100644
index 0000000000000..1db5b30dd0b30
--- /dev/null
+++ b/tests/baselines/reference/instantiateContextuallyTypedGenericThis.symbols
@@ -0,0 +1,46 @@
+=== tests/cases/compiler/instantiateContextuallyTypedGenericThis.ts ===
+interface JQuery {
+>JQuery : Symbol(JQuery, Decl(instantiateContextuallyTypedGenericThis.ts, 0, 0))
+
+    each<T>(
+>each : Symbol(JQuery.each, Decl(instantiateContextuallyTypedGenericThis.ts, 0, 18))
+>T : Symbol(T, Decl(instantiateContextuallyTypedGenericThis.ts, 1, 9))
+
+        collection: T[], callback: (this: T, dit: T) => T
+>collection : Symbol(collection, Decl(instantiateContextuallyTypedGenericThis.ts, 1, 12))
+>T : Symbol(T, Decl(instantiateContextuallyTypedGenericThis.ts, 1, 9))
+>callback : Symbol(callback, Decl(instantiateContextuallyTypedGenericThis.ts, 2, 24))
+>this : Symbol(this, Decl(instantiateContextuallyTypedGenericThis.ts, 2, 36))
+>T : Symbol(T, Decl(instantiateContextuallyTypedGenericThis.ts, 1, 9))
+>dit : Symbol(dit, Decl(instantiateContextuallyTypedGenericThis.ts, 2, 44))
+>T : Symbol(T, Decl(instantiateContextuallyTypedGenericThis.ts, 1, 9))
+>T : Symbol(T, Decl(instantiateContextuallyTypedGenericThis.ts, 1, 9))
+
+    ): T[];
+>T : Symbol(T, Decl(instantiateContextuallyTypedGenericThis.ts, 1, 9))
+}
+
+let $: JQuery;
+>$ : Symbol($, Decl(instantiateContextuallyTypedGenericThis.ts, 6, 3))
+>JQuery : Symbol(JQuery, Decl(instantiateContextuallyTypedGenericThis.ts, 0, 0))
+
+let lines: string[];
+>lines : Symbol(lines, Decl(instantiateContextuallyTypedGenericThis.ts, 7, 3))
+
+$.each(lines, function(dit) {
+>$.each : Symbol(JQuery.each, Decl(instantiateContextuallyTypedGenericThis.ts, 0, 18))
+>$ : Symbol($, Decl(instantiateContextuallyTypedGenericThis.ts, 6, 3))
+>each : Symbol(JQuery.each, Decl(instantiateContextuallyTypedGenericThis.ts, 0, 18))
+>lines : Symbol(lines, Decl(instantiateContextuallyTypedGenericThis.ts, 7, 3))
+>dit : Symbol(dit, Decl(instantiateContextuallyTypedGenericThis.ts, 8, 23))
+
+    return dit.charAt(0) + this.charAt(1);
+>dit.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
+>dit : Symbol(dit, Decl(instantiateContextuallyTypedGenericThis.ts, 8, 23))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
+>this.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
+>this : Symbol(this, Decl(instantiateContextuallyTypedGenericThis.ts, 2, 36))
+>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --))
+
+});
+
diff --git a/tests/baselines/reference/instantiateContextuallyTypedGenericThis.types b/tests/baselines/reference/instantiateContextuallyTypedGenericThis.types
new file mode 100644
index 0000000000000..5cdce6b99fe18
--- /dev/null
+++ b/tests/baselines/reference/instantiateContextuallyTypedGenericThis.types
@@ -0,0 +1,53 @@
+=== tests/cases/compiler/instantiateContextuallyTypedGenericThis.ts ===
+interface JQuery {
+>JQuery : JQuery
+
+    each<T>(
+>each : <T>(collection: T[], callback: (this: T, dit: T) => T) => T[]
+>T : T
+
+        collection: T[], callback: (this: T, dit: T) => T
+>collection : T[]
+>T : T
+>callback : (this: T, dit: T) => T
+>this : T
+>T : T
+>dit : T
+>T : T
+>T : T
+
+    ): T[];
+>T : T
+}
+
+let $: JQuery;
+>$ : JQuery
+>JQuery : JQuery
+
+let lines: string[];
+>lines : string[]
+
+$.each(lines, function(dit) {
+>$.each(lines, function(dit) {    return dit.charAt(0) + this.charAt(1);}) : string[]
+>$.each : <T>(collection: T[], callback: (this: T, dit: T) => T) => T[]
+>$ : JQuery
+>each : <T>(collection: T[], callback: (this: T, dit: T) => T) => T[]
+>lines : string[]
+>function(dit) {    return dit.charAt(0) + this.charAt(1);} : (this: string, dit: string) => string
+>dit : string
+
+    return dit.charAt(0) + this.charAt(1);
+>dit.charAt(0) + this.charAt(1) : string
+>dit.charAt(0) : string
+>dit.charAt : (pos: number) => string
+>dit : string
+>charAt : (pos: number) => string
+>0 : number
+>this.charAt(1) : string
+>this.charAt : (pos: number) => string
+>this : string
+>charAt : (pos: number) => string
+>1 : number
+
+});
+
diff --git a/tests/baselines/reference/iterableArrayPattern29.errors.txt b/tests/baselines/reference/iterableArrayPattern29.errors.txt
index b34d0317d5768..29e5d0d2a3f98 100644
--- a/tests/baselines/reference/iterableArrayPattern29.errors.txt
+++ b/tests/baselines/reference/iterableArrayPattern29.errors.txt
@@ -1,7 +1,6 @@
 tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts(1,33): error TS2501: A rest element cannot contain a binding pattern.
 tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts(2,21): error TS2345: Argument of type '[string, boolean]' is not assignable to parameter of type '[string, number]'.
-  Types of property '1' are incompatible.
-    Type 'boolean' is not assignable to type 'number'.
+  Type 'boolean' is not assignable to type 'number'.
 
 
 ==== tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts (2 errors) ====
@@ -11,5 +10,4 @@ tests/cases/conformance/es6/destructuring/iterableArrayPattern29.ts(2,21): error
     takeFirstTwoEntries(...new Map([["", true], ["hello", true]]));
                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '[string, boolean]' is not assignable to parameter of type '[string, number]'.
-!!! error TS2345:   Types of property '1' are incompatible.
-!!! error TS2345:     Type 'boolean' is not assignable to type 'number'.
\ No newline at end of file
+!!! error TS2345:   Type 'boolean' is not assignable to type 'number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/jsdocNeverUndefinedNull.js b/tests/baselines/reference/jsdocNeverUndefinedNull.js
new file mode 100644
index 0000000000000..e57b7091a3bea
--- /dev/null
+++ b/tests/baselines/reference/jsdocNeverUndefinedNull.js
@@ -0,0 +1,20 @@
+//// [in.js]
+/**
+ * @param {never} p1
+ * @param {undefined} p2
+ * @param {null} p3
+ * @returns {void} nothing
+ */
+function f(p1, p2, p3) {
+}
+
+
+//// [out.js]
+/**
+ * @param {never} p1
+ * @param {undefined} p2
+ * @param {null} p3
+ * @returns {void} nothing
+ */
+function f(p1, p2, p3) {
+}
diff --git a/tests/baselines/reference/jsdocNeverUndefinedNull.symbols b/tests/baselines/reference/jsdocNeverUndefinedNull.symbols
new file mode 100644
index 0000000000000..a57636ed34402
--- /dev/null
+++ b/tests/baselines/reference/jsdocNeverUndefinedNull.symbols
@@ -0,0 +1,14 @@
+=== tests/cases/conformance/jsdoc/in.js ===
+/**
+ * @param {never} p1
+ * @param {undefined} p2
+ * @param {null} p3
+ * @returns {void} nothing
+ */
+function f(p1, p2, p3) {
+>f : Symbol(f, Decl(in.js, 0, 0))
+>p1 : Symbol(p1, Decl(in.js, 6, 11))
+>p2 : Symbol(p2, Decl(in.js, 6, 14))
+>p3 : Symbol(p3, Decl(in.js, 6, 18))
+}
+
diff --git a/tests/baselines/reference/jsdocNeverUndefinedNull.types b/tests/baselines/reference/jsdocNeverUndefinedNull.types
new file mode 100644
index 0000000000000..fe57cc298e2cb
--- /dev/null
+++ b/tests/baselines/reference/jsdocNeverUndefinedNull.types
@@ -0,0 +1,14 @@
+=== tests/cases/conformance/jsdoc/in.js ===
+/**
+ * @param {never} p1
+ * @param {undefined} p2
+ * @param {null} p3
+ * @returns {void} nothing
+ */
+function f(p1, p2, p3) {
+>f : (p1: never, p2: undefined, p3: null) => void
+>p1 : never
+>p2 : undefined
+>p3 : null
+}
+
diff --git a/tests/baselines/reference/optionalBindingParameters1.errors.txt b/tests/baselines/reference/optionalBindingParameters1.errors.txt
index 78fc1cbddf1f7..0780c626baf8b 100644
--- a/tests/baselines/reference/optionalBindingParameters1.errors.txt
+++ b/tests/baselines/reference/optionalBindingParameters1.errors.txt
@@ -1,7 +1,6 @@
 tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(2,14): error TS2463: A binding pattern parameter cannot be optional in an implementation signature.
 tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(8,5): error TS2345: Argument of type '[boolean, number, string]' is not assignable to parameter of type '[string, number, boolean]'.
-  Types of property '0' are incompatible.
-    Type 'boolean' is not assignable to type 'string'.
+  Type 'boolean' is not assignable to type 'string'.
 
 
 ==== tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts (2 errors) ====
@@ -17,5 +16,4 @@ tests/cases/conformance/es6/destructuring/optionalBindingParameters1.ts(8,5): er
     foo([false, 0, ""]);
         ~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '[boolean, number, string]' is not assignable to parameter of type '[string, number, boolean]'.
-!!! error TS2345:   Types of property '0' are incompatible.
-!!! error TS2345:     Type 'boolean' is not assignable to type 'string'.
\ No newline at end of file
+!!! error TS2345:   Type 'boolean' is not assignable to type 'string'.
\ No newline at end of file
diff --git a/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt b/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt
index 312603d2c2e62..30ec4037c88b6 100644
--- a/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt
+++ b/tests/baselines/reference/optionalBindingParametersInOverloads1.errors.txt
@@ -1,6 +1,5 @@
 tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts(9,5): error TS2345: Argument of type '[boolean, number, string]' is not assignable to parameter of type '[string, number, boolean]'.
-  Types of property '0' are incompatible.
-    Type 'boolean' is not assignable to type 'string'.
+  Type 'boolean' is not assignable to type 'string'.
 
 
 ==== tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.ts (1 errors) ====
@@ -15,5 +14,4 @@ tests/cases/conformance/es6/destructuring/optionalBindingParametersInOverloads1.
     foo([false, 0, ""]);
         ~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '[boolean, number, string]' is not assignable to parameter of type '[string, number, boolean]'.
-!!! error TS2345:   Types of property '0' are incompatible.
-!!! error TS2345:     Type 'boolean' is not assignable to type 'string'.
\ No newline at end of file
+!!! error TS2345:   Type 'boolean' is not assignable to type 'string'.
\ No newline at end of file
diff --git a/tests/baselines/reference/thisTypeInFunctions.symbols b/tests/baselines/reference/thisTypeInFunctions.symbols
index 8a0be7427ed4c..ad16785f28830 100644
--- a/tests/baselines/reference/thisTypeInFunctions.symbols
+++ b/tests/baselines/reference/thisTypeInFunctions.symbols
@@ -135,7 +135,7 @@ let impl: I = {
 
         return this.a;
 >this.a : Symbol(a, Decl(thisTypeInFunctions.ts, 24, 30))
->this : Symbol(, Decl(thisTypeInFunctions.ts, 24, 28))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 24, 23))
 >a : Symbol(a, Decl(thisTypeInFunctions.ts, 24, 30))
 
     },
@@ -144,7 +144,7 @@ let impl: I = {
 
         return this.a;
 >this.a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
->this : Symbol(I, Decl(thisTypeInFunctions.ts, 19, 21))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 25, 22))
 >a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
 
     },
@@ -153,7 +153,7 @@ let impl: I = {
 
         return this.a;
 >this.a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
->this : Symbol(I, Decl(thisTypeInFunctions.ts, 19, 21))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 26, 17))
 >a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
 
     },
@@ -173,7 +173,7 @@ impl.explicitStructural = function() { return this.a; };
 >impl : Symbol(impl, Decl(thisTypeInFunctions.ts, 37, 3))
 >explicitStructural : Symbol(I.explicitStructural, Decl(thisTypeInFunctions.ts, 23, 38))
 >this.a : Symbol(a, Decl(thisTypeInFunctions.ts, 24, 30))
->this : Symbol(, Decl(thisTypeInFunctions.ts, 24, 28))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 24, 23))
 >a : Symbol(a, Decl(thisTypeInFunctions.ts, 24, 30))
 
 impl.explicitInterface = function() { return this.a; };
@@ -181,7 +181,7 @@ impl.explicitInterface = function() { return this.a; };
 >impl : Symbol(impl, Decl(thisTypeInFunctions.ts, 37, 3))
 >explicitInterface : Symbol(I.explicitInterface, Decl(thisTypeInFunctions.ts, 24, 50))
 >this.a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
->this : Symbol(I, Decl(thisTypeInFunctions.ts, 19, 21))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 25, 22))
 >a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
 
 impl.explicitStructural = () => 12;
@@ -199,7 +199,7 @@ impl.explicitThis = function () { return this.a; };
 >impl : Symbol(impl, Decl(thisTypeInFunctions.ts, 37, 3))
 >explicitThis : Symbol(I.explicitThis, Decl(thisTypeInFunctions.ts, 25, 39))
 >this.a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
->this : Symbol(I, Decl(thisTypeInFunctions.ts, 19, 21))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 26, 17))
 >a : Symbol(I.a, Decl(thisTypeInFunctions.ts, 20, 13))
 
 // parameter checking
@@ -536,7 +536,7 @@ c.explicitC = function(m) { return this.n + m };
 >explicitC : Symbol(C.explicitC, Decl(thisTypeInFunctions.ts, 8, 5))
 >m : Symbol(m, Decl(thisTypeInFunctions.ts, 126, 23))
 >this.n : Symbol(C.n, Decl(thisTypeInFunctions.ts, 4, 9))
->this : Symbol(C, Decl(thisTypeInFunctions.ts, 3, 1))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 9, 14))
 >n : Symbol(C.n, Decl(thisTypeInFunctions.ts, 4, 9))
 >m : Symbol(m, Decl(thisTypeInFunctions.ts, 126, 23))
 
@@ -546,7 +546,7 @@ c.explicitProperty = function(m) { return this.n + m };
 >explicitProperty : Symbol(C.explicitProperty, Decl(thisTypeInFunctions.ts, 11, 5))
 >m : Symbol(m, Decl(thisTypeInFunctions.ts, 127, 30))
 >this.n : Symbol(n, Decl(thisTypeInFunctions.ts, 12, 28))
->this : Symbol(, Decl(thisTypeInFunctions.ts, 12, 26))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 12, 21))
 >n : Symbol(n, Decl(thisTypeInFunctions.ts, 12, 28))
 >m : Symbol(m, Decl(thisTypeInFunctions.ts, 127, 30))
 
@@ -556,7 +556,7 @@ c.explicitThis = function(m) { return this.n + m };
 >explicitThis : Symbol(C.explicitThis, Decl(thisTypeInFunctions.ts, 5, 14))
 >m : Symbol(m, Decl(thisTypeInFunctions.ts, 128, 26))
 >this.n : Symbol(C.n, Decl(thisTypeInFunctions.ts, 4, 9))
->this : Symbol(C, Decl(thisTypeInFunctions.ts, 3, 1))
+>this : Symbol(this, Decl(thisTypeInFunctions.ts, 6, 17))
 >n : Symbol(C.n, Decl(thisTypeInFunctions.ts, 4, 9))
 >m : Symbol(m, Decl(thisTypeInFunctions.ts, 128, 26))
 
diff --git a/tests/baselines/reference/thisTypeInFunctions.types b/tests/baselines/reference/thisTypeInFunctions.types
index 24c4fb87bafb1..863ecbce628b7 100644
--- a/tests/baselines/reference/thisTypeInFunctions.types
+++ b/tests/baselines/reference/thisTypeInFunctions.types
@@ -132,7 +132,7 @@ function implicitThis(n: number): number {
 let impl: I = {
 >impl : I
 >I : I
->{    a: 12,    explicitVoid2: () => this.a, // ok, this: any because it refers to some outer object (window?)    explicitVoid1() { return 12; },    explicitStructural() {        return this.a;    },    explicitInterface() {        return this.a;    },    explicitThis() {        return this.a;    },} : { a: number; explicitVoid2: () => any; explicitVoid1(): number; explicitStructural(): number; explicitInterface(): number; explicitThis(): number; }
+>{    a: 12,    explicitVoid2: () => this.a, // ok, this: any because it refers to some outer object (window?)    explicitVoid1() { return 12; },    explicitStructural() {        return this.a;    },    explicitInterface() {        return this.a;    },    explicitThis() {        return this.a;    },} : { a: number; explicitVoid2: () => any; explicitVoid1(this: void): number; explicitStructural(this: { a: number; }): number; explicitInterface(this: I): number; explicitThis(this: I): number; }
 
     a: 12,
 >a : number
@@ -146,11 +146,11 @@ let impl: I = {
 >a : any
 
     explicitVoid1() { return 12; },
->explicitVoid1 : () => number
+>explicitVoid1 : (this: void) => number
 >12 : number
 
     explicitStructural() {
->explicitStructural : () => number
+>explicitStructural : (this: { a: number; }) => number
 
         return this.a;
 >this.a : number
@@ -159,7 +159,7 @@ let impl: I = {
 
     },
     explicitInterface() {
->explicitInterface : () => number
+>explicitInterface : (this: I) => number
 
         return this.a;
 >this.a : number
@@ -168,7 +168,7 @@ let impl: I = {
 
     },
     explicitThis() {
->explicitThis : () => number
+>explicitThis : (this: I) => number
 
         return this.a;
 >this.a : number
@@ -178,11 +178,11 @@ let impl: I = {
     },
 }
 impl.explicitVoid1 = function () { return 12; };
->impl.explicitVoid1 = function () { return 12; } : () => number
+>impl.explicitVoid1 = function () { return 12; } : (this: void) => number
 >impl.explicitVoid1 : (this: void) => number
 >impl : I
 >explicitVoid1 : (this: void) => number
->function () { return 12; } : () => number
+>function () { return 12; } : (this: void) => number
 >12 : number
 
 impl.explicitVoid2 = () => 12;
@@ -194,21 +194,21 @@ impl.explicitVoid2 = () => 12;
 >12 : number
 
 impl.explicitStructural = function() { return this.a; };
->impl.explicitStructural = function() { return this.a; } : () => number
+>impl.explicitStructural = function() { return this.a; } : (this: { a: number; }) => number
 >impl.explicitStructural : (this: { a: number; }) => number
 >impl : I
 >explicitStructural : (this: { a: number; }) => number
->function() { return this.a; } : () => number
+>function() { return this.a; } : (this: { a: number; }) => number
 >this.a : number
 >this : { a: number; }
 >a : number
 
 impl.explicitInterface = function() { return this.a; };
->impl.explicitInterface = function() { return this.a; } : () => number
+>impl.explicitInterface = function() { return this.a; } : (this: I) => number
 >impl.explicitInterface : (this: I) => number
 >impl : I
 >explicitInterface : (this: I) => number
->function() { return this.a; } : () => number
+>function() { return this.a; } : (this: I) => number
 >this.a : number
 >this : I
 >a : number
@@ -230,11 +230,11 @@ impl.explicitInterface = () => 12;
 >12 : number
 
 impl.explicitThis = function () { return this.a; };
->impl.explicitThis = function () { return this.a; } : () => number
+>impl.explicitThis = function () { return this.a; } : (this: I) => number
 >impl.explicitThis : (this: I) => number
 >impl : I
 >explicitThis : (this: I) => number
->function () { return this.a; } : () => number
+>function () { return this.a; } : (this: I) => number
 >this.a : number
 >this : I
 >a : number
@@ -433,7 +433,7 @@ let unboundToSpecified: (this: { y: number }, x: number) => number = x => x + th
 >this : { y: number; }
 >y : number
 >x : number
->x => x + this.y : (x: number) => any
+>x => x + this.y : (this: { y: number; }, x: number) => any
 >x : number
 >x + this.y : any
 >x : number
@@ -472,7 +472,7 @@ let specifiedLambda: (this: void, x: number) => number = x => x + 12;
 >specifiedLambda : (this: void, x: number) => number
 >this : void
 >x : number
->x => x + 12 : (x: number) => number
+>x => x + 12 : (this: void, x: number) => number
 >x : number
 >x + 12 : number
 >x : number
@@ -560,40 +560,40 @@ c.explicitProperty = reconstructed.explicitProperty;
 
 // lambdas are assignable to anything
 c.explicitC = m => m;
->c.explicitC = m => m : (m: number) => number
+>c.explicitC = m => m : (this: C, m: number) => number
 >c.explicitC : (this: C, m: number) => number
 >c : C
 >explicitC : (this: C, m: number) => number
->m => m : (m: number) => number
+>m => m : (this: C, m: number) => number
 >m : number
 >m : number
 
 c.explicitThis = m => m;
->c.explicitThis = m => m : (m: number) => number
+>c.explicitThis = m => m : (this: C, m: number) => number
 >c.explicitThis : (this: C, m: number) => number
 >c : C
 >explicitThis : (this: C, m: number) => number
->m => m : (m: number) => number
+>m => m : (this: C, m: number) => number
 >m : number
 >m : number
 
 c.explicitProperty = m => m;
->c.explicitProperty = m => m : (m: number) => number
+>c.explicitProperty = m => m : (this: { n: number; }, m: number) => number
 >c.explicitProperty : (this: { n: number; }, m: number) => number
 >c : C
 >explicitProperty : (this: { n: number; }, m: number) => number
->m => m : (m: number) => number
+>m => m : (this: { n: number; }, m: number) => number
 >m : number
 >m : number
 
 // this inside lambdas refer to outer scope
 // the outer-scoped lambda at top-level is still just `any`
 c.explicitC = m => m + this.n;
->c.explicitC = m => m + this.n : (m: number) => any
+>c.explicitC = m => m + this.n : (this: C, m: number) => any
 >c.explicitC : (this: C, m: number) => number
 >c : C
 >explicitC : (this: C, m: number) => number
->m => m + this.n : (m: number) => any
+>m => m + this.n : (this: C, m: number) => any
 >m : number
 >m + this.n : any
 >m : number
@@ -602,11 +602,11 @@ c.explicitC = m => m + this.n;
 >n : any
 
 c.explicitThis = m => m + this.n;
->c.explicitThis = m => m + this.n : (m: number) => any
+>c.explicitThis = m => m + this.n : (this: C, m: number) => any
 >c.explicitThis : (this: C, m: number) => number
 >c : C
 >explicitThis : (this: C, m: number) => number
->m => m + this.n : (m: number) => any
+>m => m + this.n : (this: C, m: number) => any
 >m : number
 >m + this.n : any
 >m : number
@@ -615,11 +615,11 @@ c.explicitThis = m => m + this.n;
 >n : any
 
 c.explicitProperty = m => m + this.n;
->c.explicitProperty = m => m + this.n : (m: number) => any
+>c.explicitProperty = m => m + this.n : (this: { n: number; }, m: number) => any
 >c.explicitProperty : (this: { n: number; }, m: number) => number
 >c : C
 >explicitProperty : (this: { n: number; }, m: number) => number
->m => m + this.n : (m: number) => any
+>m => m + this.n : (this: { n: number; }, m: number) => any
 >m : number
 >m + this.n : any
 >m : number
@@ -652,11 +652,11 @@ c.explicitThis = function(this: C, m: number) { return this.n + m };
 
 // this:any compatibility
 c.explicitC = function(m) { return this.n + m };
->c.explicitC = function(m) { return this.n + m } : (m: number) => number
+>c.explicitC = function(m) { return this.n + m } : (this: C, m: number) => number
 >c.explicitC : (this: C, m: number) => number
 >c : C
 >explicitC : (this: C, m: number) => number
->function(m) { return this.n + m } : (m: number) => number
+>function(m) { return this.n + m } : (this: C, m: number) => number
 >m : number
 >this.n + m : number
 >this.n : number
@@ -665,11 +665,11 @@ c.explicitC = function(m) { return this.n + m };
 >m : number
 
 c.explicitProperty = function(m) { return this.n + m };
->c.explicitProperty = function(m) { return this.n + m } : (m: number) => number
+>c.explicitProperty = function(m) { return this.n + m } : (this: { n: number; }, m: number) => number
 >c.explicitProperty : (this: { n: number; }, m: number) => number
 >c : C
 >explicitProperty : (this: { n: number; }, m: number) => number
->function(m) { return this.n + m } : (m: number) => number
+>function(m) { return this.n + m } : (this: { n: number; }, m: number) => number
 >m : number
 >this.n + m : number
 >this.n : number
@@ -678,11 +678,11 @@ c.explicitProperty = function(m) { return this.n + m };
 >m : number
 
 c.explicitThis = function(m) { return this.n + m };
->c.explicitThis = function(m) { return this.n + m } : (m: number) => number
+>c.explicitThis = function(m) { return this.n + m } : (this: C, m: number) => number
 >c.explicitThis : (this: C, m: number) => number
 >c : C
 >explicitThis : (this: C, m: number) => number
->function(m) { return this.n + m } : (m: number) => number
+>function(m) { return this.n + m } : (this: C, m: number) => number
 >m : number
 >this.n + m : number
 >this.n : number
@@ -723,11 +723,11 @@ c.explicitC = function(this: B, m: number) { return this.n + m };
 
 // this:void compatibility
 c.explicitVoid = n => n;
->c.explicitVoid = n => n : (n: number) => number
+>c.explicitVoid = n => n : (this: void, n: number) => number
 >c.explicitVoid : (this: void, m: number) => number
 >c : C
 >explicitVoid : (this: void, m: number) => number
->n => n : (n: number) => number
+>n => n : (this: void, n: number) => number
 >n : number
 >n : number
 
diff --git a/tests/baselines/reference/thisTypeInFunctions2.symbols b/tests/baselines/reference/thisTypeInFunctions2.symbols
index cdc7fb321d46f..5cc26e3ad43a3 100644
--- a/tests/baselines/reference/thisTypeInFunctions2.symbols
+++ b/tests/baselines/reference/thisTypeInFunctions2.symbols
@@ -61,12 +61,12 @@ extend1({
 >init : Symbol(init, Decl(thisTypeInFunctions2.ts, 20, 9))
 
         this // this: IndexedWithThis because of contextual typing.
->this : Symbol(IndexedWithThis, Decl(thisTypeInFunctions2.ts, 0, 0))
+>this : Symbol(this, Decl(thisTypeInFunctions2.ts, 2, 12))
 
         // this.mine
         this.willDestroy
 >this.willDestroy : Symbol(IndexedWithThis.willDestroy, Decl(thisTypeInFunctions2.ts, 2, 32))
->this : Symbol(IndexedWithThis, Decl(thisTypeInFunctions2.ts, 0, 0))
+>this : Symbol(this, Decl(thisTypeInFunctions2.ts, 2, 12))
 >willDestroy : Symbol(IndexedWithThis.willDestroy, Decl(thisTypeInFunctions2.ts, 2, 32))
 
     },
@@ -77,7 +77,10 @@ extend1({
 >foo : Symbol(foo, Decl(thisTypeInFunctions2.ts, 26, 13))
 
         this.url; // this: any because 'foo' matches the string indexer
+>this : Symbol(this, Decl(thisTypeInFunctions2.ts, 4, 87))
+
         this.willDestroy;
+>this : Symbol(this, Decl(thisTypeInFunctions2.ts, 4, 87))
     }
 });
 extend2({
diff --git a/tests/baselines/reference/thisTypeInFunctions2.types b/tests/baselines/reference/thisTypeInFunctions2.types
index 371b5f5cafc17..25fb2f28a6063 100644
--- a/tests/baselines/reference/thisTypeInFunctions2.types
+++ b/tests/baselines/reference/thisTypeInFunctions2.types
@@ -58,10 +58,10 @@ declare function simple(arg: SimpleInterface): void;
 extend1({
 >extend1({    init() {        this // this: IndexedWithThis because of contextual typing.        // this.mine        this.willDestroy    },    mine: 12,    foo() {        this.url; // this: any because 'foo' matches the string indexer        this.willDestroy;    }}) : void
 >extend1 : (args: IndexedWithThis) => void
->{    init() {        this // this: IndexedWithThis because of contextual typing.        // this.mine        this.willDestroy    },    mine: 12,    foo() {        this.url; // this: any because 'foo' matches the string indexer        this.willDestroy;    }} : { init(): void; mine: number; foo(): void; }
+>{    init() {        this // this: IndexedWithThis because of contextual typing.        // this.mine        this.willDestroy    },    mine: 12,    foo() {        this.url; // this: any because 'foo' matches the string indexer        this.willDestroy;    }} : { init(this: IndexedWithThis): void; mine: number; foo(this: any): void; }
 
     init() {
->init : () => void
+>init : (this: IndexedWithThis) => void
 
         this // this: IndexedWithThis because of contextual typing.
 >this : IndexedWithThis
@@ -78,7 +78,7 @@ extend1({
 >12 : number
 
     foo() {
->foo : () => void
+>foo : (this: any) => void
 
         this.url; // this: any because 'foo' matches the string indexer
 >this.url : any
diff --git a/tests/baselines/reference/tsxDefaultImports.js b/tests/baselines/reference/tsxDefaultImports.js
new file mode 100644
index 0000000000000..79f5d2b8fa1bc
--- /dev/null
+++ b/tests/baselines/reference/tsxDefaultImports.js
@@ -0,0 +1,34 @@
+//// [tests/cases/compiler/tsxDefaultImports.ts] ////
+
+//// [a.ts]
+
+enum SomeEnum {
+  one,
+}
+export default class SomeClass {
+  public static E = SomeEnum;
+}
+
+//// [b.ts]
+import {default as Def} from "./a"
+let a = Def.E.one;
+
+
+//// [a.js]
+"use strict";
+var SomeEnum;
+(function (SomeEnum) {
+    SomeEnum[SomeEnum["one"] = 0] = "one";
+})(SomeEnum || (SomeEnum = {}));
+var SomeClass = (function () {
+    function SomeClass() {
+    }
+    SomeClass.E = SomeEnum;
+    return SomeClass;
+}());
+exports.__esModule = true;
+exports["default"] = SomeClass;
+//// [b.js]
+"use strict";
+var a_1 = require("./a");
+var a = a_1["default"].E.one;
diff --git a/tests/baselines/reference/tsxDefaultImports.symbols b/tests/baselines/reference/tsxDefaultImports.symbols
new file mode 100644
index 0000000000000..e42392e24aafb
--- /dev/null
+++ b/tests/baselines/reference/tsxDefaultImports.symbols
@@ -0,0 +1,29 @@
+=== tests/cases/compiler/a.ts ===
+
+enum SomeEnum {
+>SomeEnum : Symbol(SomeEnum, Decl(a.ts, 0, 0))
+
+  one,
+>one : Symbol(SomeEnum.one, Decl(a.ts, 1, 15))
+}
+export default class SomeClass {
+>SomeClass : Symbol(SomeClass, Decl(a.ts, 3, 1))
+
+  public static E = SomeEnum;
+>E : Symbol(SomeClass.E, Decl(a.ts, 4, 32))
+>SomeEnum : Symbol(SomeEnum, Decl(a.ts, 0, 0))
+}
+
+=== tests/cases/compiler/b.ts ===
+import {default as Def} from "./a"
+>default : Symbol(Def, Decl(b.ts, 0, 8))
+>Def : Symbol(Def, Decl(b.ts, 0, 8))
+
+let a = Def.E.one;
+>a : Symbol(a, Decl(b.ts, 1, 3))
+>Def.E.one : Symbol(SomeEnum.one, Decl(a.ts, 1, 15))
+>Def.E : Symbol(Def.E, Decl(a.ts, 4, 32))
+>Def : Symbol(Def, Decl(b.ts, 0, 8))
+>E : Symbol(Def.E, Decl(a.ts, 4, 32))
+>one : Symbol(SomeEnum.one, Decl(a.ts, 1, 15))
+
diff --git a/tests/baselines/reference/tsxDefaultImports.types b/tests/baselines/reference/tsxDefaultImports.types
new file mode 100644
index 0000000000000..a9bdedf3efd21
--- /dev/null
+++ b/tests/baselines/reference/tsxDefaultImports.types
@@ -0,0 +1,29 @@
+=== tests/cases/compiler/a.ts ===
+
+enum SomeEnum {
+>SomeEnum : SomeEnum
+
+  one,
+>one : SomeEnum
+}
+export default class SomeClass {
+>SomeClass : SomeClass
+
+  public static E = SomeEnum;
+>E : typeof SomeEnum
+>SomeEnum : typeof SomeEnum
+}
+
+=== tests/cases/compiler/b.ts ===
+import {default as Def} from "./a"
+>default : typeof Def
+>Def : typeof Def
+
+let a = Def.E.one;
+>a : SomeEnum
+>Def.E.one : SomeEnum
+>Def.E : typeof SomeEnum
+>Def : typeof Def
+>E : typeof SomeEnum
+>one : SomeEnum
+
diff --git a/tests/baselines/reference/tupleTypes.errors.txt b/tests/baselines/reference/tupleTypes.errors.txt
index 75f413eb170f4..3b55476e4b1d5 100644
--- a/tests/baselines/reference/tupleTypes.errors.txt
+++ b/tests/baselines/reference/tupleTypes.errors.txt
@@ -4,8 +4,7 @@ tests/cases/compiler/tupleTypes.ts(14,1): error TS2322: Type 'undefined[]' is no
 tests/cases/compiler/tupleTypes.ts(15,1): error TS2322: Type '[number]' is not assignable to type '[number, string]'.
   Property '1' is missing in type '[number]'.
 tests/cases/compiler/tupleTypes.ts(17,1): 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/compiler/tupleTypes.ts(41,1): error TS2322: Type 'undefined[]' is not assignable to type '[number, string]'.
 tests/cases/compiler/tupleTypes.ts(47,1): error TS2322: Type '[number, string]' is not assignable to type 'number[]'.
   Types of property 'pop' are incompatible.
@@ -18,11 +17,9 @@ tests/cases/compiler/tupleTypes.ts(49,1): error TS2322: Type '[number, {}]' is n
       Type 'number | {}' is not assignable to type 'number'.
         Type '{}' is not assignable to type 'number'.
 tests/cases/compiler/tupleTypes.ts(50,1): error TS2322: Type '[number, number]' is not assignable to type '[number, string]'.
-  Types of property '1' are incompatible.
-    Type 'number' is not assignable to type 'string'.
+  Type 'number' is not assignable to type 'string'.
 tests/cases/compiler/tupleTypes.ts(51,1): error TS2322: Type '[number, {}]' is not assignable to type '[number, string]'.
-  Types of property '1' are incompatible.
-    Type '{}' is not assignable to type 'string'.
+  Type '{}' is not assignable to type 'string'.
 
 
 ==== tests/cases/compiler/tupleTypes.ts (9 errors) ====
@@ -53,8 +50,7 @@ tests/cases/compiler/tupleTypes.ts(51,1): error TS2322: Type '[number, {}]' is n
     t = ["hello", 1];     // Error
     ~
 !!! 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'.
     t = [1, "hello", 2];  // Ok
     
     var tf: [string, (x: string) => number] = ["hello", x => x.length];
@@ -104,13 +100,11 @@ tests/cases/compiler/tupleTypes.ts(51,1): error TS2322: Type '[number, {}]' is n
     a1 = a2;  // Error
     ~~
 !!! error TS2322: Type '[number, number]' is not assignable to type '[number, string]'.
-!!! error TS2322:   Types of property '1' are incompatible.
-!!! error TS2322:     Type 'number' is not assignable to type 'string'.
+!!! error TS2322:   Type 'number' is not assignable to type 'string'.
     a1 = a3;  // Error
     ~~
 !!! error TS2322: Type '[number, {}]' is not assignable to type '[number, string]'.
-!!! error TS2322:   Types of property '1' are incompatible.
-!!! error TS2322:     Type '{}' is not assignable to type 'string'.
+!!! error TS2322:   Type '{}' is not assignable to type 'string'.
     a3 = a1;
     a3 = a2;
     
\ No newline at end of file
diff --git a/tests/baselines/reference/typingsLookup4.js b/tests/baselines/reference/typingsLookup4.js
new file mode 100644
index 0000000000000..c11bc13c6138b
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup4.js
@@ -0,0 +1,36 @@
+//// [tests/cases/conformance/typings/typingsLookup4.ts] ////
+
+//// [package.json]
+{ "typings": "jquery.d.ts" }
+
+//// [jquery.d.ts]
+export const j: number;
+
+//// [package.json]
+{ "typings": "kquery" }
+
+//// [kquery.d.ts]
+export const k: number;
+
+//// [package.json]
+{ "typings": "lquery" }
+
+//// [lquery.ts]
+export const l = 2;
+
+//// [a.ts]
+import { j } from "jquery";
+import { k } from "kquery";
+import { l } from "lquery";
+j + k + l;
+
+
+//// [lquery.js]
+"use strict";
+exports.l = 2;
+//// [a.js]
+"use strict";
+var jquery_1 = require("jquery");
+var kquery_1 = require("kquery");
+var lquery_1 = require("lquery");
+jquery_1.j + kquery_1.k + lquery_1.l;
diff --git a/tests/baselines/reference/typingsLookup4.symbols b/tests/baselines/reference/typingsLookup4.symbols
new file mode 100644
index 0000000000000..144548c645265
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup4.symbols
@@ -0,0 +1,27 @@
+=== /a.ts ===
+import { j } from "jquery";
+>j : Symbol(j, Decl(a.ts, 0, 8))
+
+import { k } from "kquery";
+>k : Symbol(k, Decl(a.ts, 1, 8))
+
+import { l } from "lquery";
+>l : Symbol(l, Decl(a.ts, 2, 8))
+
+j + k + l;
+>j : Symbol(j, Decl(a.ts, 0, 8))
+>k : Symbol(k, Decl(a.ts, 1, 8))
+>l : Symbol(l, Decl(a.ts, 2, 8))
+
+=== /node_modules/@types/jquery/jquery.d.ts ===
+export const j: number;
+>j : Symbol(j, Decl(jquery.d.ts, 0, 12))
+
+=== /node_modules/@types/kquery/kquery.d.ts ===
+export const k: number;
+>k : Symbol(k, Decl(kquery.d.ts, 0, 12))
+
+=== /node_modules/@types/lquery/lquery.ts ===
+export const l = 2;
+>l : Symbol(l, Decl(lquery.ts, 0, 12))
+
diff --git a/tests/baselines/reference/typingsLookup4.trace.json b/tests/baselines/reference/typingsLookup4.trace.json
new file mode 100644
index 0000000000000..4bca8456f5846
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup4.trace.json
@@ -0,0 +1,93 @@
+[
+    "======== Resolving module 'jquery' from '/a.ts'. ========",
+    "Module resolution kind is not specified, using 'NodeJs'.",
+    "Loading module 'jquery' from 'node_modules' folder.",
+    "File '/node_modules/jquery.ts' does not exist.",
+    "File '/node_modules/jquery.tsx' does not exist.",
+    "File '/node_modules/jquery.d.ts' does not exist.",
+    "File '/node_modules/jquery/package.json' does not exist.",
+    "File '/node_modules/jquery/index.ts' does not exist.",
+    "File '/node_modules/jquery/index.tsx' does not exist.",
+    "File '/node_modules/jquery/index.d.ts' does not exist.",
+    "File '/node_modules/@types/jquery.ts' does not exist.",
+    "File '/node_modules/@types/jquery.tsx' does not exist.",
+    "File '/node_modules/@types/jquery.d.ts' does not exist.",
+    "Found 'package.json' at '/node_modules/@types/jquery/package.json'.",
+    "'package.json' has 'typings' field 'jquery.d.ts' that references '/node_modules/@types/jquery/jquery.d.ts'.",
+    "File '/node_modules/@types/jquery/jquery.d.ts' exist - use it as a name resolution result.",
+    "Resolving real path for '/node_modules/@types/jquery/jquery.d.ts', result '/node_modules/@types/jquery/jquery.d.ts'",
+    "======== Module name 'jquery' was successfully resolved to '/node_modules/@types/jquery/jquery.d.ts'. ========",
+    "======== Resolving module 'kquery' from '/a.ts'. ========",
+    "Module resolution kind is not specified, using 'NodeJs'.",
+    "Loading module 'kquery' from 'node_modules' folder.",
+    "File '/node_modules/kquery.ts' does not exist.",
+    "File '/node_modules/kquery.tsx' does not exist.",
+    "File '/node_modules/kquery.d.ts' does not exist.",
+    "File '/node_modules/kquery/package.json' does not exist.",
+    "File '/node_modules/kquery/index.ts' does not exist.",
+    "File '/node_modules/kquery/index.tsx' does not exist.",
+    "File '/node_modules/kquery/index.d.ts' does not exist.",
+    "File '/node_modules/@types/kquery.ts' does not exist.",
+    "File '/node_modules/@types/kquery.tsx' does not exist.",
+    "File '/node_modules/@types/kquery.d.ts' does not exist.",
+    "Found 'package.json' at '/node_modules/@types/kquery/package.json'.",
+    "'package.json' has 'typings' field 'kquery' that references '/node_modules/@types/kquery/kquery'.",
+    "File '/node_modules/@types/kquery/kquery' does not exist.",
+    "File '/node_modules/@types/kquery/kquery.ts' does not exist.",
+    "File '/node_modules/@types/kquery/kquery.tsx' does not exist.",
+    "File '/node_modules/@types/kquery/kquery.d.ts' exist - use it as a name resolution result.",
+    "Resolving real path for '/node_modules/@types/kquery/kquery.d.ts', result '/node_modules/@types/kquery/kquery.d.ts'",
+    "======== Module name 'kquery' was successfully resolved to '/node_modules/@types/kquery/kquery.d.ts'. ========",
+    "======== Resolving module 'lquery' from '/a.ts'. ========",
+    "Module resolution kind is not specified, using 'NodeJs'.",
+    "Loading module 'lquery' from 'node_modules' folder.",
+    "File '/node_modules/lquery.ts' does not exist.",
+    "File '/node_modules/lquery.tsx' does not exist.",
+    "File '/node_modules/lquery.d.ts' does not exist.",
+    "File '/node_modules/lquery/package.json' does not exist.",
+    "File '/node_modules/lquery/index.ts' does not exist.",
+    "File '/node_modules/lquery/index.tsx' does not exist.",
+    "File '/node_modules/lquery/index.d.ts' does not exist.",
+    "File '/node_modules/@types/lquery.ts' does not exist.",
+    "File '/node_modules/@types/lquery.tsx' does not exist.",
+    "File '/node_modules/@types/lquery.d.ts' does not exist.",
+    "Found 'package.json' at '/node_modules/@types/lquery/package.json'.",
+    "'package.json' has 'typings' field 'lquery' that references '/node_modules/@types/lquery/lquery'.",
+    "File '/node_modules/@types/lquery/lquery' does not exist.",
+    "File '/node_modules/@types/lquery/lquery.ts' exist - use it as a name resolution result.",
+    "Resolving real path for '/node_modules/@types/lquery/lquery.ts', result '/node_modules/@types/lquery/lquery.ts'",
+    "======== Module name 'lquery' was successfully resolved to '/node_modules/@types/lquery/lquery.ts'. ========",
+    "======== Resolving type reference directive 'jquery', containing file '/__inferred type names__.ts', root directory '/node_modules/@types'. ========",
+    "Resolving with primary search path '/node_modules/@types'",
+    "Found 'package.json' at '/node_modules/@types/jquery/package.json'.",
+    "'package.json' has 'typings' field 'jquery.d.ts' that references '/node_modules/@types/jquery/jquery.d.ts'.",
+    "File '/node_modules/@types/jquery/jquery.d.ts' exist - use it as a name resolution result.",
+    "======== Type reference directive 'jquery' was successfully resolved to '/node_modules/@types/jquery/jquery.d.ts', primary: true. ========",
+    "======== Resolving type reference directive 'kquery', containing file '/__inferred type names__.ts', root directory '/node_modules/@types'. ========",
+    "Resolving with primary search path '/node_modules/@types'",
+    "Found 'package.json' at '/node_modules/@types/kquery/package.json'.",
+    "'package.json' has 'typings' field 'kquery' that references '/node_modules/@types/kquery/kquery'.",
+    "File '/node_modules/@types/kquery/kquery' does not exist.",
+    "File '/node_modules/@types/kquery/kquery.d.ts' exist - use it as a name resolution result.",
+    "======== Type reference directive 'kquery' was successfully resolved to '/node_modules/@types/kquery/kquery.d.ts', primary: true. ========",
+    "======== Resolving type reference directive 'lquery', containing file '/__inferred type names__.ts', root directory '/node_modules/@types'. ========",
+    "Resolving with primary search path '/node_modules/@types'",
+    "Found 'package.json' at '/node_modules/@types/lquery/package.json'.",
+    "'package.json' has 'typings' field 'lquery' that references '/node_modules/@types/lquery/lquery'.",
+    "File '/node_modules/@types/lquery/lquery' does not exist.",
+    "File '/node_modules/@types/lquery/lquery.d.ts' does not exist.",
+    "File '/node_modules/@types/lquery/index.d.ts' does not exist.",
+    "Looking up in 'node_modules' folder, initial location '/'",
+    "File '/node_modules/lquery.ts' does not exist.",
+    "File '/node_modules/lquery.d.ts' does not exist.",
+    "File '/node_modules/lquery/package.json' does not exist.",
+    "File '/node_modules/lquery/index.ts' does not exist.",
+    "File '/node_modules/lquery/index.d.ts' does not exist.",
+    "File '/node_modules/@types/lquery.ts' does not exist.",
+    "File '/node_modules/@types/lquery.d.ts' does not exist.",
+    "Found 'package.json' at '/node_modules/@types/lquery/package.json'.",
+    "'package.json' has 'typings' field 'lquery' that references '/node_modules/@types/lquery/lquery'.",
+    "File '/node_modules/@types/lquery/lquery' does not exist.",
+    "File '/node_modules/@types/lquery/lquery.ts' exist - use it as a name resolution result.",
+    "======== Type reference directive 'lquery' was successfully resolved to '/node_modules/@types/lquery/lquery.ts', primary: false. ========"
+]
\ No newline at end of file
diff --git a/tests/baselines/reference/typingsLookup4.types b/tests/baselines/reference/typingsLookup4.types
new file mode 100644
index 0000000000000..d922c7b1dfa53
--- /dev/null
+++ b/tests/baselines/reference/typingsLookup4.types
@@ -0,0 +1,30 @@
+=== /a.ts ===
+import { j } from "jquery";
+>j : number
+
+import { k } from "kquery";
+>k : number
+
+import { l } from "lquery";
+>l : number
+
+j + k + l;
+>j + k + l : number
+>j + k : number
+>j : number
+>k : number
+>l : number
+
+=== /node_modules/@types/jquery/jquery.d.ts ===
+export const j: number;
+>j : number
+
+=== /node_modules/@types/kquery/kquery.d.ts ===
+export const k: number;
+>k : number
+
+=== /node_modules/@types/lquery/lquery.ts ===
+export const l = 2;
+>l : number
+>2 : number
+
diff --git a/tests/cases/compiler/instantiateContextuallyTypedGenericThis.ts b/tests/cases/compiler/instantiateContextuallyTypedGenericThis.ts
new file mode 100644
index 0000000000000..f06f06ee7a1c5
--- /dev/null
+++ b/tests/cases/compiler/instantiateContextuallyTypedGenericThis.ts
@@ -0,0 +1,11 @@
+interface JQuery {
+    each<T>(
+        collection: T[], callback: (this: T, dit: T) => T
+    ): T[];
+}
+
+let $: JQuery;
+let lines: string[];
+$.each(lines, function(dit) {
+    return dit.charAt(0) + this.charAt(1);
+});
diff --git a/tests/cases/compiler/tsxDefaultImports.ts b/tests/cases/compiler/tsxDefaultImports.ts
new file mode 100644
index 0000000000000..4e313b33eac78
--- /dev/null
+++ b/tests/cases/compiler/tsxDefaultImports.ts
@@ -0,0 +1,12 @@
+// @Filename: a.ts
+
+enum SomeEnum {
+  one,
+}
+export default class SomeClass {
+  public static E = SomeEnum;
+}
+
+// @Filename: b.ts
+import {default as Def} from "./a"
+let a = Def.E.one;
diff --git a/tests/cases/conformance/async/es6/await_unaryExpression_es6.ts b/tests/cases/conformance/async/es6/await_unaryExpression_es6.ts
new file mode 100644
index 0000000000000..09cf0a87a5adc
--- /dev/null
+++ b/tests/cases/conformance/async/es6/await_unaryExpression_es6.ts
@@ -0,0 +1,17 @@
+// @target: es6
+
+async function bar() {
+    !await 42; // OK
+}
+
+async function bar1() {
+    +await 42; // OK
+}
+
+async function bar3() {
+    -await 42; // OK
+}
+
+async function bar4() {
+    ~await 42; // OK
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts b/tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts
new file mode 100644
index 0000000000000..5ccf1a1c35a87
--- /dev/null
+++ b/tests/cases/conformance/async/es6/await_unaryExpression_es6_1.ts
@@ -0,0 +1,21 @@
+// @target: es6
+
+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;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts b/tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts
new file mode 100644
index 0000000000000..24683765d1996
--- /dev/null
+++ b/tests/cases/conformance/async/es6/await_unaryExpression_es6_2.ts
@@ -0,0 +1,13 @@
+// @target: es6
+
+async function bar1() {
+    delete await 42;
+}
+
+async function bar2() {
+    delete await 42;
+}
+
+async function bar3() {
+    void await 42;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts b/tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts
new file mode 100644
index 0000000000000..b595ab5e748ad
--- /dev/null
+++ b/tests/cases/conformance/async/es6/await_unaryExpression_es6_3.ts
@@ -0,0 +1,19 @@
+// @target: es6
+
+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
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/jsdoc/jsdocNeverUndefinedNull.ts b/tests/cases/conformance/jsdoc/jsdocNeverUndefinedNull.ts
new file mode 100644
index 0000000000000..c095bc1c920d4
--- /dev/null
+++ b/tests/cases/conformance/jsdoc/jsdocNeverUndefinedNull.ts
@@ -0,0 +1,11 @@
+// @allowJs: true
+// @filename: in.js
+// @out: out.js
+/**
+ * @param {never} p1
+ * @param {undefined} p2
+ * @param {null} p3
+ * @returns {void} nothing
+ */
+function f(p1, p2, p3) {
+}
diff --git a/tests/cases/conformance/typings/typingsLookup4.ts b/tests/cases/conformance/typings/typingsLookup4.ts
new file mode 100644
index 0000000000000..234090aebad52
--- /dev/null
+++ b/tests/cases/conformance/typings/typingsLookup4.ts
@@ -0,0 +1,31 @@
+// @traceResolution: true
+// @noImplicitReferences: true
+// @currentDirectory: /
+// A file extension is optional in typings entries.
+
+// @filename: /tsconfig.json
+{}
+
+// @filename: /node_modules/@types/jquery/package.json
+{ "typings": "jquery.d.ts" }
+
+// @filename: /node_modules/@types/jquery/jquery.d.ts
+export const j: number;
+
+// @filename: /node_modules/@types/kquery/package.json
+{ "typings": "kquery" }
+
+// @filename: /node_modules/@types/kquery/kquery.d.ts
+export const k: number;
+
+// @filename: /node_modules/@types/lquery/package.json
+{ "typings": "lquery" }
+
+// @filename: /node_modules/@types/lquery/lquery.ts
+export const l = 2;
+
+// @filename: /a.ts
+import { j } from "jquery";
+import { k } from "kquery";
+import { l } from "lquery";
+j + k + l;
diff --git a/tests/cases/fourslash/jsdocNullableUnion.ts b/tests/cases/fourslash/jsdocNullableUnion.ts
new file mode 100644
index 0000000000000..19dc9818d6950
--- /dev/null
+++ b/tests/cases/fourslash/jsdocNullableUnion.ts
@@ -0,0 +1,23 @@
+///<reference path="fourslash.ts" />
+// @allowNonTsExtensions: true
+// @Filename: Foo.js
+////
+//// * @param {never | {x: string}} p1
+//// * @param {undefined | {y: number}} p2
+//// * @param {null | {z: boolean}} p3
+//// * @returns {void} nothing
+//// */
+////function f(p1, p2, p3) {
+////    p1./*1*/
+////    p2./*2*/
+////    p3./*3*/
+////}
+
+goTo.marker('1');
+verify.memberListContains("x");
+
+goTo.marker('2');
+verify.memberListContains("y");
+
+goTo.marker('3');
+verify.memberListContains("z");
diff --git a/tests/cases/fourslash/server/completionEntryDetailAcrossFiles02.ts b/tests/cases/fourslash/server/completionEntryDetailAcrossFiles02.ts
new file mode 100644
index 0000000000000..2c5e53ea224cc
--- /dev/null
+++ b/tests/cases/fourslash/server/completionEntryDetailAcrossFiles02.ts
@@ -0,0 +1,20 @@
+/// <reference path="../fourslash.ts"/>
+
+// @allowNonTsExtensions: true
+// @Filename: a.js
+//// /**
+////  * Modify the parameter
+////  * @param {string} p1
+////  */
+//// var foo = function (p1) { }
+//// module.exports.foo = foo;
+//// fo/*1*/
+
+// @Filename: b.ts
+//// import a = require("./a");
+//// a.fo/*2*/
+
+goTo.marker('1');
+verify.completionEntryDetailIs("foo", "var foo: (p1: string) => void", "Modify the parameter");
+goTo.marker('2');
+verify.completionEntryDetailIs("foo", "(property) a.foo: (p1: string) => void", "Modify the parameter");
diff --git a/tests/cases/fourslash/syntacticClassificationsDocComment4.ts b/tests/cases/fourslash/syntacticClassificationsDocComment4.ts
new file mode 100644
index 0000000000000..d8ac2f12d8b32
--- /dev/null
+++ b/tests/cases/fourslash/syntacticClassificationsDocComment4.ts
@@ -0,0 +1,24 @@
+/// <reference path="fourslash.ts"/>
+
+//// /** @param {number} p1 */
+//// function foo(p1) {}
+
+var c = classification;
+verify.syntacticClassificationsAre(
+    c.comment("/** "),
+    c.punctuation("@"),
+    c.docCommentTagName("param"),
+    c.comment(" "),
+    c.punctuation("{"),
+    c.keyword("number"),
+    c.punctuation("}"),
+    c.comment(" "),
+    c.parameterName("p1"),
+    c.comment(" */"),
+    c.keyword("function"),
+    c.identifier("foo"),
+    c.punctuation("("),
+    c.parameterName("p1"),
+    c.punctuation(")"),
+    c.punctuation("{"),
+    c.punctuation("}"));