diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 6c9a943b95138..8a240eae3c1d0 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -94,7 +94,7 @@ module ts {
             symbolToString: symbolToString,
             writeSymbol: writeSymbol,
             getAugmentedPropertiesOfApparentType: getAugmentedPropertiesOfApparentType,
-            getRootSymbol: getRootSymbol,
+            getRootSymbols: getRootSymbols,
             getContextualType: getContextualType,
             getFullyQualifiedName: getFullyQualifiedName,
             getResolvedSignature: getResolvedSignature,
@@ -145,6 +145,7 @@ module ts {
         var globalRegExpType: ObjectType;
 
         var tupleTypes: Map<TupleType> = {};
+        var unionTypes: Map<UnionType> = {};
         var stringLiteralTypes: Map<StringLiteralType> = {};
         var emitExtends = false;
 
@@ -1090,6 +1091,9 @@ module ts {
                 else if (type.flags & TypeFlags.Tuple) {
                     writeTupleType(<TupleType>type);
                 }
+                else if (type.flags & TypeFlags.Union) {
+                    writeUnionType(<UnionType>type);
+                }
                 else if (type.flags & TypeFlags.Anonymous) {
                     writeAnonymousType(<ObjectType>type, flags);
                 }
@@ -1107,18 +1111,23 @@ module ts {
                 }
             }
 
-            function writeTypeList(types: Type[]) {
+            function writeTypeList(types: Type[], union: boolean) {
                 for (var i = 0; i < types.length; i++) {
                     if (i > 0) {
-                        writePunctuation(writer, SyntaxKind.CommaToken);
+                        if (union) {
+                            writeSpace(writer);
+                        }
+                        writePunctuation(writer, union ? SyntaxKind.BarToken : SyntaxKind.CommaToken);
                         writeSpace(writer);
                     }
-                    writeType(types[i], flags | TypeFormatFlags.WriteArrowStyleSignature);
+                    // Don't output function type literals in unions because '() => string | () => number' would be parsed
+                    // as a function type that returns a union type. Instead output '{ (): string; } | { (): number; }'.
+                    writeType(types[i], union ? flags & ~TypeFormatFlags.WriteArrowStyleSignature : flags | TypeFormatFlags.WriteArrowStyleSignature);
                 }
             }
 
             function writeTypeReference(type: TypeReference) {
-                if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType)) {
+                if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType) && !(type.typeArguments[0].flags & TypeFlags.Union)) {
                     // If we are writing array element type the arrow style signatures are not allowed as 
                     // we need to surround it by curlies, e.g. { (): T; }[]; as () => T[] would mean something different
                     writeType(type.typeArguments[0], flags & ~TypeFormatFlags.WriteArrowStyleSignature);
@@ -1128,17 +1137,21 @@ module ts {
                 else {
                     writeSymbol(type.target.symbol, writer, enclosingDeclaration, SymbolFlags.Type);
                     writePunctuation(writer, SyntaxKind.LessThanToken);
-                    writeTypeList(type.typeArguments);
+                    writeTypeList(type.typeArguments, /*union*/ false);
                     writePunctuation(writer, SyntaxKind.GreaterThanToken);
                 }
             }
 
             function writeTupleType(type: TupleType) {
                 writePunctuation(writer, SyntaxKind.OpenBracketToken);
-                writeTypeList(type.elementTypes);
+                writeTypeList(type.elementTypes, /*union*/ false);
                 writePunctuation(writer, SyntaxKind.CloseBracketToken);
             }
 
+            function writeUnionType(type: UnionType) {
+                writeTypeList(type.types, /*union*/ true);
+            }
+
             function writeAnonymousType(type: ObjectType, flags: TypeFormatFlags) {
                 // Always use 'typeof T' for type of class, enum, and module objects
                 if (type.symbol && type.symbol.flags & (SymbolFlags.Class | SymbolFlags.Enum | SymbolFlags.ValueModule)) {
@@ -1718,6 +1731,15 @@ module ts {
             return links.type;
         }
 
+        function getTypeOfUnionProperty(symbol: Symbol): Type {
+            var links = getSymbolLinks(symbol);
+            if (!links.type) {
+                var types = map(links.unionType.types, t => getTypeOfSymbol(getPropertyOfType(getApparentType(t), symbol.name)));
+                links.type = getUnionType(types);
+            }
+            return links.type;
+        }
+
         function getTypeOfSymbol(symbol: Symbol): Type {
             if (symbol.flags & (SymbolFlags.Variable | SymbolFlags.Property)) {
                 return getTypeOfVariableOrParameterOrProperty(symbol);
@@ -1737,6 +1759,9 @@ module ts {
             if (symbol.flags & SymbolFlags.Instantiated) {
                 return getTypeOfInstantiatedSymbol(symbol);
             }
+            if (symbol.flags & SymbolFlags.UnionProperty) {
+                return getTypeOfUnionProperty(symbol);
+            }
             return unknownType;
         }
 
@@ -2027,12 +2052,101 @@ module ts {
         }
 
         function resolveTupleTypeMembers(type: TupleType) {
-            var arrayType = resolveObjectTypeMembers(createArrayType(getBestCommonType(type.elementTypes)));
+            var arrayType = resolveObjectTypeMembers(createArrayType(getUnionType(type.elementTypes)));
             var members = createTupleTypeMemberSymbols(type.elementTypes);
             addInheritedMembers(members, arrayType.properties);
             setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexType, arrayType.numberIndexType);
         }
 
+        function signatureListsIdentical(s: Signature[], t: Signature[]): boolean {
+            if (s.length !== t.length) {
+                return false;
+            }
+            for (var i = 0; i < s.length; i++) {
+                if (!compareSignatures(s[i], t[i], /*compareReturnTypes*/ false, isTypeIdenticalTo)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        // If the lists of call or construct signatures in the given types are all identical except for return types,
+        // and if none of the signatures are generic, return a list of signatures that has substitutes a union of the
+        // return types of the corresponding signatures in each resulting signature.
+        function getUnionSignatures(types: Type[], kind: SignatureKind): Signature[] {
+            var signatureLists = map(types, t => getSignaturesOfType(t, kind));
+            var signatures = signatureLists[0];
+            for (var i = 0; i < signatures.length; i++) {
+                if (signatures[i].typeParameters) {
+                    return emptyArray;
+                }
+            }
+            for (var i = 1; i < signatureLists.length; i++) {
+                if (!signatureListsIdentical(signatures, signatureLists[i])) {
+                    return emptyArray;
+                }
+            }
+            var result = map(signatures, cloneSignature);
+            for (var i = 0; i < result.length; i++) {
+                var s = result[i];
+                // Clear resolved return type we possibly got from cloneSignature
+                s.resolvedReturnType = undefined;
+                s.unionSignatures = map(signatureLists, signatures => signatures[i]);
+            }
+            return result;
+        }
+
+        function getUnionIndexType(types: Type[], kind: IndexKind): Type {
+            var indexTypes: Type[] = [];
+            for (var i = 0; i < types.length; i++) {
+                var indexType = getIndexTypeOfType(types[i], kind);
+                if (!indexType) {
+                    return undefined;
+                }
+                indexTypes.push(indexType);
+            }
+            return getUnionType(indexTypes);
+        }
+
+        function resolveUnionTypeMembers(type: UnionType) {
+            var types: Type[] = [];
+            forEach(type.types, t => {
+                var apparentType = getApparentType(t);
+                if (!contains(types, apparentType)) {
+                    types.push(apparentType);
+                }
+            });
+            if (types.length <= 1) {
+                var resolved = types.length ? resolveObjectTypeMembers(types[0]) : emptyObjectType;
+                setObjectTypeMembers(type, resolved.members, resolved.callSignatures, resolved.constructSignatures, resolved.stringIndexType, resolved.numberIndexType);
+                return;
+            }
+            var members: SymbolTable = {};
+            forEach(getPropertiesOfType(types[0]), prop => {
+                for (var i = 1; i < types.length; i++) {
+                    if (!getPropertyOfType(types[i], prop.name)) {
+                        return;
+                    }
+                }
+                var symbol = <TransientSymbol>createSymbol(SymbolFlags.UnionProperty | SymbolFlags.Transient, prop.name);
+                symbol.unionType = type;
+
+                symbol.declarations = [];
+                for (var i = 0; i < types.length; i++) {
+                    var s = getPropertyOfType(types[i], prop.name);
+                    if (s.declarations)
+                        symbol.declarations.push.apply(symbol.declarations, s.declarations);
+                }
+
+                members[prop.name] = symbol;
+            });
+            var callSignatures = getUnionSignatures(types, SignatureKind.Call);
+            var constructSignatures = getUnionSignatures(types, SignatureKind.Construct);
+            var stringIndexType = getUnionIndexType(types, IndexKind.String);
+            var numberIndexType = getUnionIndexType(types, IndexKind.Number);
+            setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType);
+        }
+
         function resolveAnonymousTypeMembers(type: ObjectType) {
             var symbol = type.symbol;
             if (symbol.flags & SymbolFlags.TypeLiteral) {
@@ -2081,6 +2195,9 @@ module ts {
                 else if (type.flags & TypeFlags.Tuple) {
                     resolveTupleTypeMembers(<TupleType>type);
                 }
+                else if (type.flags & TypeFlags.Union) {
+                    resolveUnionTypeMembers(<UnionType>type);
+                }
                 else {
                     resolveTypeReferenceMembers(<TypeReference>type);
                 }
@@ -2241,6 +2358,9 @@ module ts {
                 if (signature.target) {
                     var type = instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper);
                 }
+                else if (signature.unionSignatures) {
+                    var type = getUnionType(map(signature.unionSignatures, getReturnTypeOfSignature));
+                }
                 else {
                     var type = getReturnTypeFromBody(<FunctionDeclaration>signature.declaration);
                 }
@@ -2549,6 +2669,102 @@ module ts {
             return links.resolvedType;
         }
 
+        function addTypeToSortedSet(sortedSet: Type[], type: Type) {
+            if (type.flags & TypeFlags.Union) {
+                addTypesToSortedSet(sortedSet, (<UnionType>type).types);
+            }
+            else {
+                var i = 0;
+                var id = type.id;
+                while (i < sortedSet.length && sortedSet[i].id < id) {
+                    i++;
+                }
+                if (i === sortedSet.length || sortedSet[i].id !== id) {
+                    sortedSet.splice(i, 0, type);
+                }
+            }
+        }
+
+        function addTypesToSortedSet(sortedTypes: Type[], types: Type[]) {
+            for (var i = 0, len = types.length; i < len; i++) {
+                addTypeToSortedSet(sortedTypes, types[i]);
+            }
+        }
+
+        function isSubtypeOfAny(candidate: Type, types: Type[]): boolean {
+            for (var i = 0, len = types.length; i < len; i++) {
+                if (candidate !== types[i] && isTypeSubtypeOf(candidate, types[i])) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        function removeSubtypes(types: Type[]) {
+            var i = types.length;
+            while (i > 0) {
+                i--;
+                if (isSubtypeOfAny(types[i], types)) {
+                    types.splice(i, 1);
+                }
+            }
+        }
+
+        function containsAnyType(types: Type[]) {
+            for (var i = 0; i < types.length; i++) {
+                if (types[i].flags & TypeFlags.Any) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        function removeAllButLast(types: Type[], typeToRemove: Type) {
+            var i = types.length;
+            while (i > 0 && types.length > 1) {
+                i--;
+                if (types[i] === typeToRemove) {
+                    types.splice(i, 1);
+                }
+            }
+        }
+
+        function getUnionType(types: Type[], noSubtypeReduction?: boolean): Type {
+            if (types.length === 0) {
+                return emptyObjectType;
+            }
+            var sortedTypes: Type[] = [];
+            addTypesToSortedSet(sortedTypes, types);
+            if (noSubtypeReduction) {
+                if (containsAnyType(sortedTypes)) {
+                    return anyType;
+                }
+                removeAllButLast(sortedTypes, undefinedType);
+                removeAllButLast(sortedTypes, nullType);
+            }
+            else {
+                removeSubtypes(sortedTypes);
+            }
+            if (sortedTypes.length === 1) {
+                return sortedTypes[0];
+            }
+            var id = getTypeListId(sortedTypes);
+            var type = unionTypes[id];
+            if (!type) {
+                type = unionTypes[id] = <UnionType>createObjectType(TypeFlags.Union);
+                type.types = sortedTypes;
+            }
+            return type;
+        }
+
+        function getTypeFromUnionTypeNode(node: UnionTypeNode): Type {
+            var links = getNodeLinks(node);
+            if (!links.resolvedType) {
+                links.resolvedType = getUnionType(map(node.types, getTypeFromTypeNode), /*noSubtypeReduction*/ true);
+            }
+            return links.resolvedType;
+        }
+
         function getTypeFromTypeLiteralNode(node: TypeLiteralNode): Type {
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
@@ -2595,6 +2811,8 @@ module ts {
                     return getTypeFromArrayTypeNode(<ArrayTypeNode>node);
                 case SyntaxKind.TupleType:
                     return getTypeFromTupleTypeNode(<TupleTypeNode>node);
+                case SyntaxKind.UnionType:
+                    return getTypeFromUnionTypeNode(<UnionTypeNode>node);
                 case SyntaxKind.TypeLiteral:
                     return getTypeFromTypeLiteralNode(<TypeLiteralNode>node);
                 // This function assumes that an identifier or qualified name is a type expression
@@ -2759,6 +2977,9 @@ module ts {
                 if (type.flags & TypeFlags.Tuple) {
                     return createTupleType(instantiateList((<TupleType>type).elementTypes, mapper, instantiateType));
                 }
+                if (type.flags & TypeFlags.Union) {
+                    return getUnionType(instantiateList((<UnionType>type).types, mapper, instantiateType), /*noSubtypeReduction*/ true);
+                }
             }
             return type;
         }
@@ -2920,7 +3141,7 @@ module ts {
                 errorInfo = chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2);
             }
 
-            function isRelatedTo(source: Type, target: Type, reportErrors: boolean): boolean {
+            function isRelatedTo(source: Type, target: Type, reportErrors?: boolean): boolean {
                 return isRelatedToWithCustomErrors(source, target, reportErrors, /*chainedMessage*/ undefined, /*terminalMessage*/ undefined);
             }
 
@@ -2941,8 +3162,17 @@ module ts {
                         if (source === numberType && target.flags & TypeFlags.Enum) return true;
                     }
                 }
-
-                if (source.flags & TypeFlags.TypeParameter && target.flags & TypeFlags.TypeParameter) {
+                if (source.flags & TypeFlags.Union) {
+                    if (unionTypeRelatedToType(<UnionType>source, target, reportErrors)) {
+                        return true;
+                    }
+                }
+                else if (target.flags & TypeFlags.Union) {
+                    if (typeRelatedToUnionType(source, <UnionType>target, reportErrors)) {
+                        return true;
+                    }
+                }
+                else if (source.flags & TypeFlags.TypeParameter && target.flags & TypeFlags.TypeParameter) {
                     if (typeParameterRelatedTo(<TypeParameter>source, <TypeParameter>target, reportErrors)) {
                         return true;
                     }
@@ -2959,7 +3189,7 @@ module ts {
                     // Report structural errors only if we haven't reported any errors yet
                     var reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo;
                     // identity relation does not use apparent type
-                    var sourceOrApparentType =  relation === identityRelation ? source : getApparentType(source);
+                    var sourceOrApparentType = relation === identityRelation ? source : getApparentType(source);
                     if (sourceOrApparentType.flags & TypeFlags.ObjectType && target.flags & TypeFlags.ObjectType &&
                         objectTypeRelatedTo(sourceOrApparentType, <ObjectType>target, reportStructuralErrors)) {
                         errorInfo = saveErrorInfo;
@@ -2980,6 +3210,26 @@ module ts {
                 return false;
             }
 
+            function typeRelatedToUnionType(source: Type, target: UnionType, reportErrors: boolean): boolean {
+                var targetTypes = target.types;
+                for (var i = 0, len = targetTypes.length; i < len; i++) {
+                    if (isRelatedTo(source, targetTypes[i], reportErrors && i === len - 1)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            function unionTypeRelatedToType(source: UnionType, target: Type, reportErrors: boolean): boolean {
+                var sourceTypes = source.types;
+                for (var i = 0, len = sourceTypes.length; i < len; i++) {
+                    if (!isRelatedTo(sourceTypes[i], target, reportErrors)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
             function typesRelatedTo(sources: Type[], targets: Type[], reportErrors: boolean): boolean {
                 for (var i = 0, len = sources.length; i < len; i++) {
                     if (!isRelatedTo(sources[i], targets[i], reportErrors)) return false;
@@ -3081,34 +3331,12 @@ module ts {
 
             function propertiesRelatedTo(source: ObjectType, target: ObjectType, reportErrors: boolean): boolean {
                 if (relation === identityRelation) {
-                    return propertiesAreIdenticalTo(source, target, reportErrors);
-                }
-                else {
-                    return propertiesAreSubtypeOrAssignableTo(<ApparentType>source, target, reportErrors);
+                    return propertiesIdenticalTo(source, target, reportErrors);
                 }
-            }
-
-            function propertiesAreIdenticalTo(source: ObjectType, target: ObjectType, reportErrors: boolean): boolean {
-                var sourceProperties = getPropertiesOfType(source);
-                var targetProperties = getPropertiesOfType(target);
-                if (sourceProperties.length !== targetProperties.length) {
-                    return false;
-                }
-                for (var i = 0, len = sourceProperties.length; i < len; ++i) {
-                    var sourceProp = sourceProperties[i];
-                    var targetProp = getPropertyOfType(target, sourceProp.name);
-                    if (!targetProp || !isPropertyIdenticalToRecursive(sourceProp, targetProp, reportErrors, isRelatedTo)) {
-                        return false;
-                    }
-                }
-                return true;
-            }
-
-            function propertiesAreSubtypeOrAssignableTo(source: ApparentType, target: ObjectType, reportErrors: boolean): boolean {
                 var properties = getPropertiesOfType(target);
                 for (var i = 0; i < properties.length; i++) {
                     var targetProp = properties[i];
-                    var sourceProp = getPropertyOfApparentType(source, targetProp.name);
+                    var sourceProp = getPropertyOfApparentType(<ApparentType>source, targetProp.name);
                     if (sourceProp !== targetProp) {
                         if (!sourceProp) {
                             if (!isOptionalProperty(targetProp)) {
@@ -3181,80 +3409,26 @@ module ts {
                 return true;
             }
 
-            function signaturesRelatedTo(source: ObjectType, target: ObjectType, kind: SignatureKind, reportErrors: boolean): boolean {
-                if (relation === identityRelation) {
-                    return areSignaturesIdenticalTo(source, target, kind, reportErrors);
-                }
-                else {
-                    return areSignaturesSubtypeOrAssignableTo(source, target, kind, reportErrors);
-                }
-            }
-
-            function areSignaturesIdenticalTo(source: ObjectType, target: ObjectType, kind: SignatureKind, reportErrors: boolean): boolean {
-                var sourceSignatures = getSignaturesOfType(source, kind);
-                var targetSignatures = getSignaturesOfType(target, kind);
-                if (sourceSignatures.length !== targetSignatures.length) {
+            function propertiesIdenticalTo(source: ObjectType, target: ObjectType, reportErrors: boolean): boolean {
+                var sourceProperties = getPropertiesOfType(source);
+                var targetProperties = getPropertiesOfType(target);
+                if (sourceProperties.length !== targetProperties.length) {
                     return false;
                 }
-
-                for (var i = 0, len = sourceSignatures.length; i < len; ++i) {
-                    if (!isSignatureIdenticalTo(sourceSignatures[i], targetSignatures[i], reportErrors)) {
+                for (var i = 0, len = sourceProperties.length; i < len; ++i) {
+                    var sourceProp = sourceProperties[i];
+                    var targetProp = getPropertyOfType(target, sourceProp.name);
+                    if (!targetProp || !isPropertyIdenticalToRecursive(sourceProp, targetProp, reportErrors, isRelatedTo)) {
                         return false;
                     }
                 }
-
                 return true;
             }
 
-            function isSignatureIdenticalTo(source: Signature, target: Signature, reportErrors: boolean): boolean {
-                if (source === target) {
-                    return true;
-                }
-
-                if (source.hasRestParameter !== target.hasRestParameter) {
-                    return false;
-                }
-
-                if (source.parameters.length !== target.parameters.length) {
-                    return false;
-                }
-
-                if (source.minArgumentCount !== target.minArgumentCount) {
-                    return false;
-                }
-
-                if (source.typeParameters && target.typeParameters) {
-                    if (source.typeParameters.length !== target.typeParameters.length) {
-                        return false;
-                    }
-
-                    for (var i = 0, len = source.typeParameters.length; i < len; ++i) {
-                        if (!isRelatedTo(source.typeParameters[i], target.typeParameters[i], reportErrors)) {
-                            return false;
-                        }
-                    }
-                }
-                else if (source.typeParameters || source.typeParameters) {
-                    return false;
-                }
-
-                // Spec 1.0 Section 3.8.3 & 3.8.4:
-                // M and N (the signatures) are instantiated using type Any as the type argument for all type parameters declared by M and N
-                source = getErasedSignature(source);
-                target = getErasedSignature(target);
-                for (var i = 0, len = source.parameters.length; i < len; i++) {
-                    var s = source.hasRestParameter && i === len - 1 ? getRestTypeOfSignature(source) : getTypeOfSymbol(source.parameters[i]);
-                    var t = target.hasRestParameter && i === len - 1 ? getRestTypeOfSignature(target) : getTypeOfSymbol(target.parameters[i]);
-                    if (!isRelatedTo(s, t, reportErrors)) {
-                        return false;
-                    }
+            function signaturesRelatedTo(source: ObjectType, target: ObjectType, kind: SignatureKind, reportErrors: boolean): boolean {
+                if (relation === identityRelation) {
+                    return signaturesIdenticalTo(source, target, kind, reportErrors);
                 }
-                var t = getReturnTypeOfSignature(target);
-                var s = getReturnTypeOfSignature(source);
-                return isRelatedTo(s, t, reportErrors);
-            }
-
-            function areSignaturesSubtypeOrAssignableTo(source: ObjectType, target: ObjectType, kind: SignatureKind, reportErrors: boolean): boolean {
                 if (target === anyFunctionType || source === anyFunctionType) return true;
                 var sourceSignatures = getSignaturesOfType(source, kind);
                 var targetSignatures = getSignaturesOfType(target, kind);
@@ -3266,7 +3440,7 @@ module ts {
                         for (var j = 0; j < sourceSignatures.length; j++) {
                             var s = sourceSignatures[j];
                             if (!s.hasStringLiterals || source.flags & TypeFlags.FromSignature) {
-                                if (isSignatureSubtypeOrAssignableTo(s, t, localErrors)) {
+                                if (signatureRelatedTo(s, t, localErrors)) {
                                     errorInfo = saveErrorInfo;
                                     continue outer;
                                 }
@@ -3280,15 +3454,13 @@ module ts {
                 return true;
             }
 
-            function isSignatureSubtypeOrAssignableTo(source: Signature, target: Signature, reportErrors: boolean): boolean {
+            function signatureRelatedTo(source: Signature, target: Signature, reportErrors: boolean): boolean {
                 if (source === target) {
                     return true;
                 }
-
                 if (!target.hasRestParameter && source.minArgumentCount > target.parameters.length) {
                     return false;
                 }
-
                 var sourceMax = source.parameters.length;
                 var targetMax = target.parameters.length;
                 var checkCount: number;
@@ -3334,71 +3506,117 @@ module ts {
                 return isRelatedTo(s, t, reportErrors);
             }
 
+            function signaturesIdenticalTo(source: ObjectType, target: ObjectType, kind: SignatureKind, reportErrors: boolean): boolean {
+                var sourceSignatures = getSignaturesOfType(source, kind);
+                var targetSignatures = getSignaturesOfType(target, kind);
+                if (sourceSignatures.length !== targetSignatures.length) {
+                    return false;
+                }
+                for (var i = 0, len = sourceSignatures.length; i < len; ++i) {
+                    if (!compareSignatures(sourceSignatures[i], targetSignatures[i], /*compareReturnTypes*/ true, isRelatedTo)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+
             function stringIndexTypesRelatedTo(source: ObjectType, target: ObjectType, reportErrors: boolean): boolean {
                 if (relation === identityRelation) {
-                    return areIndexTypesIdenticalTo(IndexKind.String, source, target, reportErrors);
-                }
-                else {
-                    var targetType = getIndexTypeOfType(target, IndexKind.String);
-                    if (targetType) {
-                        var sourceType = getIndexTypeOfType(source, IndexKind.String);
-                        if (!sourceType) {
-                            if (reportErrors) {
-                                reportError(Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source));
-                            }
-                            return false;
+                    return indexTypesIdenticalTo(IndexKind.String, source, target, reportErrors);
+                }
+                var targetType = getIndexTypeOfType(target, IndexKind.String);
+                if (targetType) {
+                    var sourceType = getIndexTypeOfType(source, IndexKind.String);
+                    if (!sourceType) {
+                        if (reportErrors) {
+                            reportError(Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source));
                         }
-                        if (!isRelatedTo(sourceType, targetType, reportErrors)) {
-                            if (reportErrors) {
-                                reportError(Diagnostics.Index_signatures_are_incompatible_Colon);
-                            }
-                            return false;
+                        return false;
+                    }
+                    if (!isRelatedTo(sourceType, targetType, reportErrors)) {
+                        if (reportErrors) {
+                            reportError(Diagnostics.Index_signatures_are_incompatible_Colon);
                         }
+                        return false;
                     }
-                    return true;
                 }
+                return true;
             } 
 
             function numberIndexTypesRelatedTo(source: ObjectType, target: ObjectType, reportErrors: boolean): boolean {
                 if (relation === identityRelation) {
-                    return areIndexTypesIdenticalTo(IndexKind.Number, source, target, reportErrors);
-                }
-                else {
-                    var targetType = getIndexTypeOfType(target, IndexKind.Number);
-                    if (targetType) {
-                        var sourceStringType = getIndexTypeOfType(source, IndexKind.String);
-                        var sourceNumberType = getIndexTypeOfType(source, IndexKind.Number);
-                        if (!(sourceStringType || sourceNumberType)) {
-                            if (reportErrors) {
-                                reportError(Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source));
-                            }
-                            return false;
-                        }
-                        if (sourceStringType && sourceNumberType) {
-                            // If we know for sure we're testing both string and numeric index types then only report errors from the second one
-                            var compatible = isRelatedTo(sourceStringType, targetType, false) || isRelatedTo(sourceNumberType, targetType, reportErrors);
-                        }
-                        else {
-                            var compatible = isRelatedTo(sourceStringType || sourceNumberType, targetType, reportErrors);
+                    return indexTypesIdenticalTo(IndexKind.Number, source, target, reportErrors);
+                }
+                var targetType = getIndexTypeOfType(target, IndexKind.Number);
+                if (targetType) {
+                    var sourceStringType = getIndexTypeOfType(source, IndexKind.String);
+                    var sourceNumberType = getIndexTypeOfType(source, IndexKind.Number);
+                    if (!(sourceStringType || sourceNumberType)) {
+                        if (reportErrors) {
+                            reportError(Diagnostics.Index_signature_is_missing_in_type_0, typeToString(source));
                         }
-                        if (!compatible) {
-                            if (reportErrors) {
-                                reportError(Diagnostics.Index_signatures_are_incompatible_Colon);
-                            }
-                            return false;
+                        return false;
+                    }
+                    if (sourceStringType && sourceNumberType) {
+                        // If we know for sure we're testing both string and numeric index types then only report errors from the second one
+                        var compatible = isRelatedTo(sourceStringType, targetType, false) || isRelatedTo(sourceNumberType, targetType, reportErrors);
+                    }
+                    else {
+                        var compatible = isRelatedTo(sourceStringType || sourceNumberType, targetType, reportErrors);
+                    }
+                    if (!compatible) {
+                        if (reportErrors) {
+                            reportError(Diagnostics.Index_signatures_are_incompatible_Colon);
                         }
+                        return false;
                     }
-                    return true;
                 }
+                return true;
             }
 
-            function areIndexTypesIdenticalTo(indexKind: IndexKind, source: ObjectType, target: ObjectType, reportErrors: boolean): boolean {
+            function indexTypesIdenticalTo(indexKind: IndexKind, source: ObjectType, target: ObjectType, reportErrors: boolean): boolean {
                 var targetType = getIndexTypeOfType(target, indexKind);
                 var sourceType = getIndexTypeOfType(source, indexKind);
                 return (!sourceType && !targetType) || (sourceType && targetType && isRelatedTo(sourceType, targetType, reportErrors));
             }
         }
 
+        function compareSignatures(source: Signature, target: Signature, compareReturnTypes: boolean, compareTypes: (s: Type, t: Type) => boolean): boolean {
+            if (source === target) {
+                return true;
+            }
+            if (source.parameters.length !== target.parameters.length ||
+                source.minArgumentCount !== target.minArgumentCount ||
+                source.hasRestParameter !== target.hasRestParameter) {
+                return false;
+            }
+            if (source.typeParameters && target.typeParameters) {
+                if (source.typeParameters.length !== target.typeParameters.length) {
+                    return false;
+                }
+                for (var i = 0, len = source.typeParameters.length; i < len; ++i) {
+                    if (!compareTypes(source.typeParameters[i], target.typeParameters[i])) {
+                        return false;
+                    }
+                }
+            }
+            else if (source.typeParameters || source.typeParameters) {
+                return false;
+            }
+            // Spec 1.0 Section 3.8.3 & 3.8.4:
+            // M and N (the signatures) are instantiated using type Any as the type argument for all type parameters declared by M and N
+            source = getErasedSignature(source);
+            target = getErasedSignature(target);
+            for (var i = 0, len = source.parameters.length; i < len; i++) {
+                var s = source.hasRestParameter && i === len - 1 ? getRestTypeOfSignature(source) : getTypeOfSymbol(source.parameters[i]);
+                var t = target.hasRestParameter && i === len - 1 ? getRestTypeOfSignature(target) : getTypeOfSymbol(target.parameters[i]);
+                if (!compareTypes(s, t)) {
+                    return false;
+                }
+            }
+            return !compareReturnTypes || compareTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target));
+        }
+
         function isSupertypeOfEach(candidate: Type, types: Type[]): boolean {
             for (var i = 0, len = types.length; i < len; i++) {
                 if (candidate !== types[i] && !isTypeSubtypeOf(types[i], candidate)) return false;
@@ -3406,9 +3624,12 @@ module ts {
             return true;
         }
 
-        function getBestCommonType(types: Type[], contextualType?: Type, candidatesOnly?: boolean): Type {
-            if (contextualType && isSupertypeOfEach(contextualType, types)) return contextualType;
-            return forEach(types, t => isSupertypeOfEach(t, types) ? t : undefined) || (candidatesOnly ? undefined : emptyObjectType);
+        function getCommonSupertype(types: Type[]): Type {
+            return forEach(types, t => isSupertypeOfEach(t, types) ? t : undefined);
+        }
+
+        function getBestCommonType(types: Type[], contextualType: Type): Type {
+            return contextualType && isSupertypeOfEach(contextualType, types) ? contextualType : getUnionType(types);
         }
 
         function isTypeOfObjectLiteral(type: Type): boolean {
@@ -3427,10 +3648,13 @@ module ts {
         }
 
         /* If we are widening on a literal, then we may need to the 'node' parameter for reporting purposes */
-        function getWidenedType(type: Type, supressNoImplicitAnyErrors?: boolean): Type {
+        function getWidenedType(type: Type, suppressNoImplicitAnyErrors?: boolean): Type {
             if (type.flags & (TypeFlags.Undefined | TypeFlags.Null)) {
                 return anyType;
             }
+            if (type.flags & TypeFlags.Union) {
+                return getWidenedTypeOfUnion(type);
+            }
             if (isTypeOfObjectLiteral(type)) {
                 return getWidenedTypeOfObjectLiteral(type);
             }
@@ -3439,6 +3663,10 @@ module ts {
             }
             return type;
 
+            function getWidenedTypeOfUnion(type: Type): Type {
+                return getUnionType(map((<UnionType>type).types, t => getWidenedType(t, suppressNoImplicitAnyErrors)));
+            }
+
             function getWidenedTypeOfObjectLiteral(type: Type): Type {
                 var properties = getPropertiesOfType(type);
                 if (properties.length) {
@@ -3449,8 +3677,7 @@ module ts {
                         var widenedType = getWidenedType(propType);
                         if (propType !== widenedType) {
                             propTypeWasWidened = true;
-
-                            if (!supressNoImplicitAnyErrors && program.getCompilerOptions().noImplicitAny && getInnermostTypeOfNestedArrayTypes(widenedType) === anyType) {
+                            if (!suppressNoImplicitAnyErrors && compilerOptions.noImplicitAny && getInnermostTypeOfNestedArrayTypes(widenedType) === anyType) {
                                 error(p.valueDeclaration, Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, p.name, typeToString(widenedType));
                             }
                         }
@@ -3480,10 +3707,8 @@ module ts {
 
             function getWidenedTypeOfArrayLiteral(type: Type): Type {
                 var elementType = (<TypeReference>type).typeArguments[0];
-                var widenedType = getWidenedType(elementType, supressNoImplicitAnyErrors);
-
+                var widenedType = getWidenedType(elementType, suppressNoImplicitAnyErrors);
                 type = elementType !== widenedType ? createArrayType(widenedType) : type;
-
                 return type;
             }
         }
@@ -3520,6 +3745,7 @@ module ts {
             for (var i = 0; i < typeParameters.length; i++) inferences.push([]);
             return {
                 typeParameters: typeParameters,
+                inferenceCount: 0,
                 inferences: inferences,
                 inferredTypes: new Array(typeParameters.length),
             };
@@ -3557,6 +3783,7 @@ module ts {
                     var typeParameters = context.typeParameters;
                     for (var i = 0; i < typeParameters.length; i++) {
                         if (target === typeParameters[i]) {
+                            context.inferenceCount++;
                             var inferences = context.inferences[i];
                             if (!contains(inferences, source)) inferences.push(source);
                             break;
@@ -3571,6 +3798,34 @@ module ts {
                         inferFromTypes(sourceTypes[i], targetTypes[i]);
                     }
                 }
+                else if (target.flags & TypeFlags.Union) {
+                    var targetTypes = (<UnionType>target).types;
+                    var startCount = context.inferenceCount;
+                    var typeParameterCount = 0;
+                    var typeParameter: TypeParameter;
+                    // First infer to each type in union that isn't a type parameter
+                    for (var i = 0; i < targetTypes.length; i++) {
+                        var t = targetTypes[i];
+                        if (t.flags & TypeFlags.TypeParameter && contains(context.typeParameters, t)) {
+                            typeParameter = <TypeParameter>t;
+                            typeParameterCount++;
+                        }
+                        else {
+                            inferFromTypes(source, t);
+                        }
+                    }
+                    // If no inferences were produced above and union contains a single naked type parameter, infer to that type parameter
+                    if (context.inferenceCount === startCount && typeParameterCount === 1) {
+                        inferFromTypes(source, typeParameter);
+                    }
+                }
+                else if (source.flags & TypeFlags.Union) {
+                    // Source is a union type, infer from each consituent type
+                    var sourceTypes = (<UnionType>source).types;
+                    for (var i = 0; i < sourceTypes.length; i++) {
+                        inferFromTypes(sourceTypes[i], target);
+                    }
+                }
                 else if (source.flags & TypeFlags.ObjectType && (target.flags & (TypeFlags.Reference | TypeFlags.Tuple) ||
                     (target.flags & TypeFlags.Anonymous) && target.symbol && target.symbol.flags & (SymbolFlags.Method | SymbolFlags.TypeLiteral))) {
                     // If source is an object type, and target is a type reference, a tuple type, the type of a method, or a type literal, infer from members
@@ -3634,9 +3889,19 @@ module ts {
         function getInferredType(context: InferenceContext, index: number): Type {
             var result = context.inferredTypes[index];
             if (!result) {
-                var commonType = getWidenedType(getBestCommonType(context.inferences[index]));
+                var inferences = context.inferences[index];
+                if (inferences.length) {
+                    // Find type that is supertype of all others
+                    var supertype = getCommonSupertype(inferences);
+                    // Infer widened supertype, or the undefined type for no common supertype
+                    var inferredType = supertype ? getWidenedType(supertype) : undefinedType;
+                }
+                else {
+                    // Infer the empty object type when no inferences were made
+                    inferredType = emptyObjectType;
+                }
                 var constraint = getConstraintOfTypeParameter(context.typeParameters[index]);
-                var result = constraint && !isTypeAssignableTo(commonType, constraint) ? constraint : commonType;
+                var result = constraint && !isTypeAssignableTo(inferredType, constraint) ? constraint : inferredType;
                 context.inferredTypes[index] = result;
             }
             return result;
@@ -3656,44 +3921,288 @@ module ts {
 
         // EXPRESSION TYPE CHECKING
 
-        function checkIdentifier(node: Identifier): Type {
-            function isInTypeQuery(node: Node): boolean {
-                // TypeScript 1.0 spec (April 2014): 3.6.3
-                // A type query consists of the keyword typeof followed by an expression.
-                // The expression is restricted to a single identifier or a sequence of identifiers separated by periods
-                while (node) {
+        function getResolvedSymbol(node: Identifier): Symbol {
+            var links = getNodeLinks(node);
+            if (!links.resolvedSymbol) {
+                links.resolvedSymbol = resolveName(node, node.text, SymbolFlags.Value | SymbolFlags.ExportValue, Diagnostics.Cannot_find_name_0, identifierToString(node)) || unknownSymbol;
+            }
+            return links.resolvedSymbol;
+        }
+
+        function isInTypeQuery(node: Node): boolean {
+            // TypeScript 1.0 spec (April 2014): 3.6.3
+            // A type query consists of the keyword typeof followed by an expression.
+            // The expression is restricted to a single identifier or a sequence of identifiers separated by periods
+            while (node) {
+                switch (node.kind) {
+                    case SyntaxKind.TypeQuery:
+                        return true;
+                    case SyntaxKind.Identifier:
+                    case SyntaxKind.QualifiedName:
+                        node = node.parent;
+                        continue;
+                    default:
+                        return false;
+                }
+            }
+            Debug.fail("should not get here");
+        }
+
+        // Remove one or more primitive types from a union type
+        function subtractPrimitiveTypes(type: Type, subtractMask: TypeFlags): Type {
+            if (type.flags & TypeFlags.Union) {
+                var types = (<UnionType>type).types;
+                if (forEach(types, t => t.flags & subtractMask)) {
+                    return getUnionType(filter(types, t => !(t.flags & subtractMask)));
+                }
+            }
+            return type;
+        }
+
+        // Check if a given variable is assigned within a given syntax node
+        function isVariableAssignedWithin(symbol: Symbol, node: Node): boolean {
+            var links = getNodeLinks(node);
+            if (links.assignmentChecks) {
+                var cachedResult = links.assignmentChecks[symbol.id];
+                if (cachedResult !== undefined) {
+                    return cachedResult;
+                }
+            }
+            else {
+                links.assignmentChecks = {};
+            }
+            return links.assignmentChecks[symbol.id] = isAssignedIn(node);
+
+            function isAssignedInBinaryExpression(node: BinaryExpression) {
+                if (node.operator >= SyntaxKind.FirstAssignment && node.operator <= SyntaxKind.LastAssignment) {
+                    var n = node.left;
+                    while (n.kind === SyntaxKind.ParenExpression) {
+                        n = (<ParenExpression>n).expression;
+                    }
+                    if (n.kind === SyntaxKind.Identifier && getResolvedSymbol(<Identifier>n) === symbol) {
+                        return true;
+                    }
+                }
+                return forEachChild(node, isAssignedIn);
+            }
+
+            function isAssignedInVariableDeclaration(node: VariableDeclaration) {
+                if (getSymbolOfNode(node) === symbol && node.initializer) {
+                    return true;
+                }
+                return forEachChild(node, isAssignedIn);
+            }
+
+            function isAssignedIn(node: Node): boolean {
+                switch (node.kind) {
+                    case SyntaxKind.BinaryExpression:
+                        return isAssignedInBinaryExpression(<BinaryExpression>node);
+                    case SyntaxKind.VariableDeclaration:
+                        return isAssignedInVariableDeclaration(<VariableDeclaration>node);
+                    case SyntaxKind.ArrayLiteral:
+                    case SyntaxKind.ObjectLiteral:
+                    case SyntaxKind.PropertyAccess:
+                    case SyntaxKind.IndexedAccess:
+                    case SyntaxKind.CallExpression:
+                    case SyntaxKind.NewExpression:
+                    case SyntaxKind.TypeAssertion:
+                    case SyntaxKind.ParenExpression:
+                    case SyntaxKind.PrefixOperator:
+                    case SyntaxKind.PostfixOperator:
+                    case SyntaxKind.ConditionalExpression:
+                    case SyntaxKind.Block:
+                    case SyntaxKind.VariableStatement:
+                    case SyntaxKind.ExpressionStatement:
+                    case SyntaxKind.IfStatement:
+                    case SyntaxKind.DoStatement:
+                    case SyntaxKind.WhileStatement:
+                    case SyntaxKind.ForStatement:
+                    case SyntaxKind.ForInStatement:
+                    case SyntaxKind.ReturnStatement:
+                    case SyntaxKind.WithStatement:
+                    case SyntaxKind.SwitchStatement:
+                    case SyntaxKind.CaseClause:
+                    case SyntaxKind.DefaultClause:
+                    case SyntaxKind.LabeledStatement:
+                    case SyntaxKind.ThrowStatement:
+                    case SyntaxKind.TryStatement:
+                    case SyntaxKind.TryBlock:
+                    case SyntaxKind.CatchBlock:
+                    case SyntaxKind.FinallyBlock:
+                        return forEachChild(node, isAssignedIn);
+                }
+                return false;
+            }
+        }
+
+        // Get the narrowed type of a given symbol at a given location
+        function getNarrowedTypeOfSymbol(symbol: Symbol, node: Node) {
+            var type = getTypeOfSymbol(symbol);
+            // Only narrow when symbol is variable of a non-primitive type
+            if (symbol.flags & SymbolFlags.Variable && isTypeAnyOrObjectOrTypeParameter(type)) {
+                while (true) {
+                    var child = node;
+                    node = node.parent;
+                    // Stop at containing function or module block
+                    if (!node || node.kind === SyntaxKind.FunctionBlock || node.kind === SyntaxKind.ModuleBlock) {
+                        break;
+                    }
+                    var narrowedType = type;
                     switch (node.kind) {
-                        case SyntaxKind.TypeQuery:
-                            return true;
-                        case SyntaxKind.Identifier:
-                        case SyntaxKind.QualifiedName:
-                            node = node.parent;
-                            continue;
-                        default:
-                            return false;
+                        case SyntaxKind.IfStatement:
+                            // In a branch of an if statement, narrow based on controlling expression
+                            if (child !== (<IfStatement>node).expression) {
+                                narrowedType = narrowType(type, (<IfStatement>node).expression, /*assumeTrue*/ child === (<IfStatement>node).thenStatement);
+                            }
+                            break;
+                        case SyntaxKind.ConditionalExpression:
+                            // In a branch of a conditional expression, narrow based on controlling condition
+                            if (child !== (<ConditionalExpression>node).condition) {
+                                narrowedType = narrowType(type, (<ConditionalExpression>node).condition, /*assumeTrue*/ child === (<ConditionalExpression>node).whenTrue);
+                            }
+                            break;
+                        case SyntaxKind.BinaryExpression:
+                            // In the right operand of an && or ||, narrow based on left operand
+                            if (child === (<BinaryExpression>node).right) {
+                                if ((<BinaryExpression>node).operator === SyntaxKind.AmpersandAmpersandToken) {
+                                    narrowedType = narrowType(type, (<BinaryExpression>node).left, /*assumeTrue*/ true);
+                                }
+                                else if ((<BinaryExpression>node).operator === SyntaxKind.BarBarToken) {
+                                    narrowedType = narrowType(type, (<BinaryExpression>node).left, /*assumeTrue*/ false);
+                                }
+                            }
+                            break;
+                    }
+                    // Only use narrowed type if construct contains no assignments to variable
+                    if (narrowedType !== type) {
+                        if (isVariableAssignedWithin(symbol, node)) {
+                            break;
+                        }
+                        type = narrowedType;
                     }
                 }
-                Debug.fail("should not get here");
             }
+            return type;
 
-            var symbol = resolveName(node, node.text, SymbolFlags.Value | SymbolFlags.ExportValue, Diagnostics.Cannot_find_name_0, identifierToString(node));
-            if (!symbol) {
-                symbol = unknownSymbol;
+            function narrowTypeByEquality(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type {
+                var left = <UnaryExpression>expr.left;
+                var right = <LiteralExpression>expr.right;
+                // Check that we have 'typeof <symbol>' on the left and string literal on the right
+                if (left.kind !== SyntaxKind.PrefixOperator || left.operator !== SyntaxKind.TypeOfKeyword ||
+                    left.operand.kind !== SyntaxKind.Identifier || right.kind !== SyntaxKind.StringLiteral ||
+                    getResolvedSymbol(<Identifier>left.operand) !== symbol) {
+                    return type;
+                }
+                var t = right.text;
+                var checkType: Type = t === "string" ? stringType : t === "number" ? numberType : t === "boolean" ? booleanType : emptyObjectType;
+                if (expr.operator === SyntaxKind.ExclamationEqualsEqualsToken) {
+                    assumeTrue = !assumeTrue;
+                }
+                if (assumeTrue) {
+                    // The assumed result is true. If check was for a primitive type, that type is the narrowed type. Otherwise we can
+                    // remove the primitive types from the narrowed type.
+                    return checkType === emptyObjectType ? subtractPrimitiveTypes(type, TypeFlags.String | TypeFlags.Number | TypeFlags.Boolean) : checkType;
+                }
+                else {
+                    // The assumed result is false. If check was for a primitive type we can remove that type from the narrowed type.
+                    // Otherwise we don't have enough information to do anything.
+                    return checkType === emptyObjectType ? type : subtractPrimitiveTypes(type, checkType.flags);
+                }
             }
 
+            function narrowTypeByAnd(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type {
+                if (assumeTrue) {
+                    // The assumed result is true, therefore we narrow assuming each operand to be true.
+                    return narrowType(narrowType(type, expr.left, /*assumeTrue*/ true), expr.right, /*assumeTrue*/ true);
+                }
+                else {
+                    // The assumed result is false. This means either the first operand was false, or the first operand was true
+                    // and the second operand was false. We narrow with those assumptions and union the two resulting types.
+                    return getUnionType([
+                        narrowType(type, expr.left, /*assumeTrue*/ false),
+                        narrowType(narrowType(type, expr.left, /*assumeTrue*/ true), expr.right, /*assumeTrue*/ false)
+                    ]);
+                }
+            }
+
+            function narrowTypeByOr(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type {
+                if (assumeTrue) {
+                    // The assumed result is true. This means either the first operand was true, or the first operand was false
+                    // and the second operand was true. We narrow with those assumptions and union the two resulting types.
+                    return getUnionType([
+                        narrowType(type, expr.left, /*assumeTrue*/ true),
+                        narrowType(narrowType(type, expr.left, /*assumeTrue*/ false), expr.right, /*assumeTrue*/ true)
+                    ]);
+                }
+                else {
+                    // The assumed result is false, therefore we narrow assuming each operand to be false.
+                    return narrowType(narrowType(type, expr.left, /*assumeTrue*/ false), expr.right, /*assumeTrue*/ false);
+                }
+            }
+
+            function narrowTypeByInstanceof(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type {
+                // Check that assumed result is true and we have variable symbol on the left
+                if (!assumeTrue || expr.left.kind !== SyntaxKind.Identifier || getResolvedSymbol(<Identifier>expr.left) !== symbol) {
+                    return type;
+                }
+                // Check that right operand is a function type with a prototype property
+                var rightType = checkExpression(expr.right);
+                if (!isTypeSubtypeOf(rightType, globalFunctionType)) {
+                    return type;
+                }
+                var prototypeProperty = getPropertyOfType(getApparentType(rightType), "prototype");
+                if (!prototypeProperty) {
+                    return type;
+                }
+                var prototypeType = getTypeOfSymbol(prototypeProperty);
+                // Narrow to type of prototype property if it is a subtype of current type
+                return isTypeSubtypeOf(prototypeType, type) ? prototypeType : type;
+            }
+
+            // Narrow the given type based on the given expression having the assumed boolean value
+            function narrowType(type: Type, expr: Expression, assumeTrue: boolean): Type {
+                switch (expr.kind) {
+                    case SyntaxKind.ParenExpression:
+                        return narrowType(type, (<ParenExpression>expr).expression, assumeTrue);
+                    case SyntaxKind.BinaryExpression:
+                        var operator = (<BinaryExpression>expr).operator;
+                        if (operator === SyntaxKind.EqualsEqualsEqualsToken || operator === SyntaxKind.ExclamationEqualsEqualsToken) {
+                            return narrowTypeByEquality(type, <BinaryExpression>expr, assumeTrue);
+                        }
+                        else if (operator === SyntaxKind.AmpersandAmpersandToken) {
+                            return narrowTypeByAnd(type, <BinaryExpression>expr, assumeTrue);
+                        }
+                        else if (operator === SyntaxKind.BarBarToken) {
+                            return narrowTypeByOr(type, <BinaryExpression>expr, assumeTrue);
+                        }
+                        else if (operator === SyntaxKind.InstanceOfKeyword) {
+                            return narrowTypeByInstanceof(type, <BinaryExpression>expr, assumeTrue);
+                        }
+                        break;
+                    case SyntaxKind.PrefixOperator:
+                        if ((<UnaryExpression>expr).operator === SyntaxKind.ExclamationToken) {
+                            return narrowType(type, (<UnaryExpression>expr).operand, !assumeTrue);
+                        }
+                        break;
+                }
+                return type;
+            }
+        }
+
+        function checkIdentifier(node: Identifier): Type {
+            var symbol = getResolvedSymbol(node);
+
             if (symbol.flags & SymbolFlags.Import) {
                 // Mark the import as referenced so that we emit it in the final .js file.
                 // exception: identifiers that appear in type queries
                 getSymbolLinks(symbol).referenced = !isInTypeQuery(node);
             }
 
-            getNodeLinks(node).resolvedSymbol = symbol;
-
             checkCollisionWithCapturedSuperVariable(node, node);
             checkCollisionWithCapturedThisVariable(node, node);
             checkCollisionWithIndexVariableInGeneratedCode(node, node);
 
-            return getTypeOfSymbol(getExportSymbolOfValueSymbolIfExported(symbol));
+            return getNarrowedTypeOfSymbol(getExportSymbolOfValueSymbolIfExported(symbol), node);
         }
 
         function captureLexicalThis(node: Node, container: Node): void {
@@ -3968,6 +4477,54 @@ module ts {
             return undefined;
         }
 
+        // Apply a mapping function to a contextual type and return the resulting type. If the contextual type
+        // is a union type, the mapping function is applied to each constituent type and a union of the resulting
+        // types is returned.
+        function applyToContextualType(type: Type, mapper: (t: Type) => Type): Type {
+            if (!(type.flags & TypeFlags.Union)) {
+                return mapper(type);
+            }
+            var types = (<UnionType>type).types;
+            var mappedType: Type;
+            var mappedTypes: Type[];
+            for (var i = 0; i < types.length; i++) {
+                var t = mapper(types[i]);
+                if (t) {
+                    if (!mappedType) {
+                        mappedType = t;
+                    }
+                    else if (!mappedTypes) {
+                        mappedTypes = [mappedType, t];
+                    }
+                    else {
+                        mappedTypes.push(t);
+                    }
+                }
+            }
+            return mappedTypes ? getUnionType(mappedTypes) : mappedType;
+        }
+
+        function getTypeOfPropertyOfContextualType(type: Type, name: string) {
+            return applyToContextualType(type, t => {
+                var prop = getPropertyOfType(t, name);
+                return prop ? getTypeOfSymbol(prop) : undefined;
+            });
+        }
+
+        function getIndexTypeOfContextualType(type: Type, kind: IndexKind) {
+            return applyToContextualType(type, t => getIndexTypeOfType(t, kind));
+        }
+
+        // Return true if the given contextual type is a tuple-like type
+        function contextualTypeIsTupleType(type: Type): boolean {
+            return !!(type.flags & TypeFlags.Union ? forEach((<UnionType>type).types, t => getPropertyOfType(t, "0")) : getPropertyOfType(type, "0"));
+        }
+
+        // Return true if the given contextual type provides an index signature of the given kind
+        function contextualTypeHasIndexSignature(type: Type, kind: IndexKind): boolean {
+            return !!(type.flags & TypeFlags.Union ? forEach((<UnionType>type).types, t => getIndexTypeOfType(t, kind)) : getIndexTypeOfType(type, kind));
+        }
+
         // In an object literal contextually typed by a type T, the contextual type of a property assignment is the type of
         // the matching property in T, if one exists. Otherwise, it is the type of the numeric index signature in T, if one
         // exists. Otherwise, it is the type of the string index signature in T, if one exists.
@@ -3977,11 +4534,9 @@ module ts {
             var type = getContextualType(objectLiteral);
             var name = declaration.name.text;
             if (type && name) {
-                var prop = getPropertyOfType(type, name);
-                if (prop) {
-                    return getTypeOfSymbol(prop);
-                }
-                return isNumericName(name) && getIndexTypeOfType(type, IndexKind.Number) || getIndexTypeOfType(type, IndexKind.String);
+                return getTypeOfPropertyOfContextualType(type, name) ||
+                    isNumericName(name) && getIndexTypeOfContextualType(type, IndexKind.Number) ||
+                    getIndexTypeOfContextualType(type, IndexKind.String);
             }
             return undefined;
         }
@@ -3994,11 +4549,7 @@ module ts {
             var type = getContextualType(arrayLiteral);
             if (type) {
                 var index = indexOf(arrayLiteral.elements, node);
-                var prop = getPropertyOfType(type, "" + index);
-                if (prop) {
-                    return getTypeOfSymbol(prop);
-                }
-                return getIndexTypeOfType(type, IndexKind.Number);
+                return getTypeOfPropertyOfContextualType(type, "" + index) || getIndexTypeOfContextualType(type, IndexKind.Number);
             }
             return undefined;
         }
@@ -4016,7 +4567,6 @@ module ts {
                 // We cannot answer semantic questions within a with block, do not proceed any further
                 return undefined;
             }
-
             if (node.contextualType) {
                 return node.contextualType;
             }
@@ -4046,18 +4596,45 @@ module ts {
             return undefined;
         }
 
+        // Return the single non-generic signature in the given type, or undefined if none exists
+        function getNonGenericSignature(type: Type): Signature {
+            var signatures = getSignaturesOfType(type, SignatureKind.Call);
+            if (signatures.length !== 1) {
+                return undefined;
+            }
+            var signature = signatures[0];
+            if (signature.typeParameters) {
+                return undefined;
+            }
+            return signature;
+        }
+
+        // Return the contextual signature for a given expression node. A contextual type provides a
+        // contextual signature if it has a single call signature and if that call signature is non-generic.
+        // If the contextual type is a union type and each constituent type that has a contextual signature
+        // provides the same contextual signature, then the union type provides that contextual signature.
         function getContextualSignature(node: Expression): Signature {
             var type = getContextualType(node);
-            if (type) {
-                var signatures = getSignaturesOfType(type, SignatureKind.Call);
-                if (signatures.length === 1) {
-                    var signature = signatures[0];
-                    if (!signature.typeParameters) {
-                        return signature;
+            if (!type) {
+                return undefined;
+            }
+            if (!(type.flags & TypeFlags.Union)) {
+                return getNonGenericSignature(type);
+            }
+            var result: Signature;
+            var types = (<UnionType>type).types;
+            for (var i = 0; i < types.length; i++) {
+                var signature = getNonGenericSignature(types[i]);
+                if (signature) {
+                    if (!result) {
+                        result = signature;
+                    }
+                    else if (!compareSignatures(result, signature, /*compareReturnTypes*/ true, isTypeIdenticalTo)) {
+                        return undefined;
                     }
                 }
             }
-            return undefined;
+            return result;
         }
 
         // Presence of a contextual type mapper indicates inferential typing, except the identityMapper object is
@@ -4067,27 +4644,16 @@ module ts {
         }
 
         function checkArrayLiteral(node: ArrayLiteral, contextualMapper?: TypeMapper): Type {
-            var contextualType = getContextualType(node);
             var elements = node.elements;
-            var elementTypes: Type[] = [];
-            var isTupleLiteral: boolean = false;
-            for (var i = 0; i < elements.length; i++) {
-                if (contextualType && getPropertyOfType(contextualType, "" + i)) {
-                    isTupleLiteral = true;
-                }
-                var element = elements[i];
-                var type = element.kind !== SyntaxKind.OmittedExpression ? checkExpression(element, contextualMapper) : undefinedType;
-                elementTypes.push(type);
+            if (!elements.length) {
+                return createArrayType(undefinedType);
             }
-            if (isTupleLiteral) {
+            var elementTypes = map(elements, e => checkExpression(e, contextualMapper));
+            var contextualType = getContextualType(node);
+            if (contextualType && contextualTypeIsTupleType(contextualType)) {
                 return createTupleType(elementTypes);
             }
-            var contextualElementType = contextualType && !isInferentialContext(contextualMapper) ? getIndexTypeOfType(contextualType, IndexKind.Number) : undefined;
-            var elementType = getBestCommonType(uniqueElements(elementTypes), contextualElementType, true);
-            if (!elementType) {
-                elementType = elements.length ? emptyObjectType : undefinedType;
-            }
-            return createArrayType(elementType);
+            return createArrayType(getUnionType(elementTypes));
         }
 
         function isNumericName(name: string) {
@@ -4098,7 +4664,6 @@ module ts {
             var members = node.symbol.members;
             var properties: SymbolTable = {};
             var contextualType = getContextualType(node);
-
             for (var id in members) {
                 if (hasProperty(members, id)) {
                     var member = members[id];
@@ -4136,21 +4701,19 @@ module ts {
             return createAnonymousType(node.symbol, properties, emptyArray, emptyArray, stringIndexType, numberIndexType);
 
             function getIndexType(kind: IndexKind) {
-                if (contextualType) {
-                    var indexType = getIndexTypeOfType(contextualType, kind);
-                    if (indexType) {
-                        var propTypes: Type[] = [];
-                        for (var id in properties) {
-                            if (hasProperty(properties, id)) {
-                                if (kind === IndexKind.String || isNumericName(id)) {
-                                    var type = getTypeOfSymbol(properties[id]);
-                                    if (!contains(propTypes, type)) propTypes.push(type);
-                                }
+                if (contextualType && contextualTypeHasIndexSignature(contextualType, kind)) {
+                    var propTypes: Type[] = [];
+                    for (var id in properties) {
+                        if (hasProperty(properties, id)) {
+                            if (kind === IndexKind.String || isNumericName(id)) {
+                                var type = getTypeOfSymbol(properties[id]);
+                                if (!contains(propTypes, type)) propTypes.push(type);
                             }
                         }
-                        return getBestCommonType(propTypes, isInferentialContext(contextualMapper) ? undefined : indexType);
                     }
+                    return propTypes.length ? getUnionType(propTypes) : undefinedType;
                 }
+                return undefined;
             }
         }
 
@@ -4406,7 +4969,9 @@ module ts {
                     }
                 }
             }
-            return getInferredTypes(context);
+            var inferredTypes = getInferredTypes(context);
+            // Inference has failed if the undefined type is in list of inferences
+            return contains(inferredTypes, undefinedType) ? undefined : inferredTypes;
         }
 
         function checkTypeArguments(signature: Signature, typeArguments: TypeNode[]): Type[] {
@@ -4431,7 +4996,6 @@ module ts {
                     if (arg.kind === SyntaxKind.OmittedExpression) {
                         continue;
                     }
-
                     var paramType = getTypeAtPosition(signature, i);
                     // String literals get string literal types unless we're reporting errors
                     var argType = arg.kind === SyntaxKind.StringLiteral && !reportErrors ?
@@ -4467,26 +5031,30 @@ module ts {
                 }
             }
             var relation = candidates.length === 1 ? assignableRelation : subtypeRelation;
+            var lastCandidate: Signature;
             while (true) {
                 for (var i = 0; i < candidates.length; i++) {
                     if (!signatureHasCorrectArity(node, candidates[i])) {
                         continue;
                     }
-
                     while (true) {
-                        var candidateWithCorrectArity = candidates[i];
-                        if (candidateWithCorrectArity.typeParameters) {
+                        var candidate = candidates[i];
+                        if (candidate.typeParameters) {
                             var typeArguments = node.typeArguments ?
-                                checkTypeArguments(candidateWithCorrectArity, node.typeArguments) :
-                                inferTypeArguments(candidateWithCorrectArity, args, excludeArgument);
-                            candidateWithCorrectArity = getSignatureInstantiation(candidateWithCorrectArity, typeArguments);
+                                checkTypeArguments(candidate, node.typeArguments) :
+                                inferTypeArguments(candidate, args, excludeArgument);
+                            if (!typeArguments) {
+                                break;
+                            }
+                            candidate = getSignatureInstantiation(candidate, typeArguments);
                         }
-                        if (!checkApplicableSignature(node, candidateWithCorrectArity, relation, excludeArgument, /*reportErrors*/ false)) {
+                        lastCandidate = candidate;
+                        if (!checkApplicableSignature(node, candidate, relation, excludeArgument, /*reportErrors*/ false)) {
                             break;
                         }
                         var index = excludeArgument ? indexOf(excludeArgument, true) : -1;
                         if (index < 0) {
-                            return candidateWithCorrectArity;
+                            return candidate;
                         }
                         excludeArgument[index] = false;
                     }
@@ -4501,8 +5069,8 @@ module ts {
             // no arguments excluded from assignability checks.
             // If candidate is undefined, it means that no candidates had a suitable arity. In that case,
             // skip the checkApplicableSignature check.
-            if (candidateWithCorrectArity) {
-                checkApplicableSignature(node, candidateWithCorrectArity, relation, /*excludeArgument*/ undefined, /*reportErrors*/ true);
+            if (lastCandidate) {
+                checkApplicableSignature(node, lastCandidate, relation, /*excludeArgument*/ undefined, /*reportErrors*/ true);
             }
             else {
                 error(node, Diagnostics.Supplied_parameters_do_not_match_any_signature_of_call_target);
@@ -4602,7 +5170,9 @@ module ts {
             // but is a subtype of the Function interface, the call is an untyped function call. In an
             // untyped function call no TypeArgs are permitted, Args can be any argument list, no contextual
             // types are provided for the argument expressions, and the result is always of type Any.
-            if ((funcType === anyType) || (!callSignatures.length && !constructSignatures.length && isTypeAssignableTo(funcType, globalFunctionType))) {
+            // We exclude union types because we may have a union of function types that happen to have
+            // no common signatures.
+            if (funcType === anyType || (!callSignatures.length && !constructSignatures.length && !(funcType.flags & TypeFlags.Union) && isTypeAssignableTo(funcType, globalFunctionType))) {
                 if (node.typeArguments) {
                     error(node, Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
                 }
@@ -4746,11 +5316,12 @@ module ts {
         }
 
         function getReturnTypeFromBody(func: FunctionDeclaration, contextualMapper?: TypeMapper): Type {
+            var contextualSignature = getContextualSignature(func);
             if (func.body.kind !== SyntaxKind.FunctionBlock) {
                 var unwidenedType = checkAndMarkExpression(func.body, contextualMapper);
                 var widenedType = getWidenedType(unwidenedType);
 
-                if (fullTypeCheck && compilerOptions.noImplicitAny && widenedType !== unwidenedType && getInnermostTypeOfNestedArrayTypes(widenedType) === anyType) {
+                if (fullTypeCheck && compilerOptions.noImplicitAny && !contextualSignature && widenedType !== unwidenedType && getInnermostTypeOfNestedArrayTypes(widenedType) === anyType) {
                     error(func, Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeToString(widenedType));
                 }
 
@@ -4762,7 +5333,9 @@ module ts {
 
             // Try to return the best common type if we have any return expressions.
             if (types.length > 0) {
-                var commonType = getBestCommonType(types, /*contextualType:*/ undefined, /*candidatesOnly:*/ true);
+                // When return statements are contextually typed we allow the return type to be a union type. Otherwise we require the
+                // return expressions to have a best common supertype.
+                var commonType = contextualSignature ? getUnionType(types) : getCommonSupertype(types);
                 if (!commonType) {
                     error(func, Diagnostics.No_best_common_type_exists_among_return_expressions);
                     
@@ -4772,7 +5345,7 @@ module ts {
                 var widenedType = getWidenedType(commonType);
 
                 // Check and report for noImplicitAny if the best common type implicitly gets widened to an 'any'/arrays-of-'any' type.
-                if (fullTypeCheck && compilerOptions.noImplicitAny && widenedType !== commonType && getInnermostTypeOfNestedArrayTypes(widenedType) === anyType) {
+                if (fullTypeCheck && compilerOptions.noImplicitAny && !contextualSignature && widenedType !== commonType && getInnermostTypeOfNestedArrayTypes(widenedType) === anyType) {
                     var typeName = typeToString(widenedType);
 
                     if (func.name) {
@@ -4993,8 +5566,8 @@ module ts {
             return numberType;
         }
 
-        function isTypeAnyTypeObjectTypeOrTypeParameter(type: Type): boolean {
-            return type === anyType || ((type.flags & (TypeFlags.ObjectType | TypeFlags.TypeParameter)) !== 0);
+        function isTypeAnyOrObjectOrTypeParameter(type: Type): boolean {
+            return (type.flags & (TypeFlags.Any | TypeFlags.ObjectType | TypeFlags.TypeParameter)) !== 0;
         }
 
         function checkInstanceOfExpression(node: BinaryExpression, leftType: Type, rightType: Type): Type {
@@ -5003,7 +5576,7 @@ module ts {
             // and the right operand to be of type Any or a subtype of the 'Function' interface type. 
             // The result is always of the Boolean primitive type.
             // NOTE: do not raise error if leftType is unknown as related error was already reported
-            if (leftType !== unknownType && !isTypeAnyTypeObjectTypeOrTypeParameter(leftType)) {
+            if (leftType !== unknownType && !isTypeAnyOrObjectOrTypeParameter(leftType)) {
                 error(node.left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
             }
             // NOTE: do not raise error if right is unknown as related error was already reported
@@ -5021,7 +5594,7 @@ module ts {
             if (leftType !== anyType && leftType !== stringType && leftType !== numberType) {
                 error(node.left, Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_types_any_string_or_number);
             }
-            if (!isTypeAnyTypeObjectTypeOrTypeParameter(rightType)) {
+            if (!isTypeAnyOrObjectOrTypeParameter(rightType)) {
                 error(node.right, Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
             }
             return booleanType;
@@ -5133,7 +5706,7 @@ module ts {
                 case SyntaxKind.AmpersandAmpersandToken:
                     return rightType;
                 case SyntaxKind.BarBarToken:
-                    return getBestCommonType([leftType, rightType], isInferentialContext(contextualMapper) ? undefined : getContextualType(node));
+                    return getUnionType([leftType, rightType]);
                 case SyntaxKind.EqualsToken:
                     checkAssignmentOperator(rightType);
                     return rightType;
@@ -5183,18 +5756,7 @@ module ts {
             checkExpression(node.condition);
             var type1 = checkExpression(node.whenTrue, contextualMapper);
             var type2 = checkExpression(node.whenFalse, contextualMapper);
-            var contextualType = isInferentialContext(contextualMapper) ? undefined : getContextualType(node);
-            var resultType = getBestCommonType([type1, type2], contextualType, true);
-            if (!resultType) {
-                if (contextualType) {
-                    error(node, Diagnostics.No_best_common_type_exists_between_0_1_and_2, typeToString(contextualType), typeToString(type1), typeToString(type2));
-                }
-                else {
-                    error(node, Diagnostics.No_best_common_type_exists_between_0_and_1, typeToString(type1), typeToString(type2));
-                }
-                resultType = emptyObjectType;
-            }
-            return resultType;
+            return getUnionType([type1, type2]);
         }
 
         function checkExpressionWithContextualType(node: Expression, contextualType: Type, contextualMapper?: TypeMapper): Type {
@@ -5282,6 +5844,8 @@ module ts {
                     return checkBinaryExpression(<BinaryExpression>node, contextualMapper);
                 case SyntaxKind.ConditionalExpression:
                     return checkConditionalExpression(<ConditionalExpression>node, contextualMapper);
+                case SyntaxKind.OmittedExpression:
+                    return undefinedType;
             }
             return unknownType;
         }
@@ -5586,6 +6150,10 @@ module ts {
             forEach(node.elementTypes, checkSourceElement);
         }
 
+        function checkUnionType(node: UnionTypeNode) {
+            forEach(node.types, checkSourceElement);
+        }
+
         function isPrivateWithinAmbient(node: Node): boolean {
             return (node.flags & NodeFlags.Private) && isInAmbientContext(node);
         }
@@ -6247,7 +6815,7 @@ module ts {
             var exprType = checkExpression(node.expression);
             // unknownType is returned i.e. if node.expression is identifier whose name cannot be resolved
             // in this case error about missing name is already reported - do not report extra one
-            if (!isTypeAnyTypeObjectTypeOrTypeParameter(exprType) && exprType !== unknownType) {
+            if (!isTypeAnyOrObjectOrTypeParameter(exprType) && exprType !== unknownType) {
                 error(node.expression, Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter);
             }
 
@@ -6869,6 +7437,8 @@ module ts {
                     return checkArrayType(<ArrayTypeNode>node);
                 case SyntaxKind.TupleType:
                     return checkTupleType(<TupleTypeNode>node);
+                case SyntaxKind.UnionType:
+                    return checkUnionType(<UnionTypeNode>node);
                 case SyntaxKind.FunctionDeclaration:
                     return checkFunctionDeclaration(<FunctionDeclaration>node);
                 case SyntaxKind.Block:
@@ -7528,8 +8098,26 @@ module ts {
             }
         }
 
-        function getRootSymbol(symbol: Symbol) {
-            return ((symbol.flags & SymbolFlags.Transient) && getSymbolLinks(symbol).target) || symbol;
+        function getRootSymbol(symbol: Symbol): Symbol {
+            return symbol.flags & SymbolFlags.Transient && getSymbolLinks(symbol).target || symbol;
+        }
+
+        function getRootSymbols(symbol: Symbol): Symbol[] {
+            if (symbol.flags & SymbolFlags.UnionProperty) {
+                var symbols: Symbol[] = [];
+                var name = symbol.name;
+                forEach(getSymbolLinks(symbol).unionType.types, t => {
+                    symbols.push(getPropertyOfType(getApparentType(t), name));
+                });
+                return symbols;
+            }
+            else if (symbol.flags & SymbolFlags.Transient) {
+                var target = getSymbolLinks(symbol).target;
+                if (target) {
+                    return [target];
+                }
+            }
+            return [symbol];
         }
 
         // Emitter support
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 3da94137fc856..ee7f4701d19d9 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -82,7 +82,7 @@ module ts {
         return array1.concat(array2);
     }
 
-    export function uniqueElements<T>(array: T[]): T[] {
+    export function deduplicate<T>(array: T[]): T[] {
         if (array) {
             var result: T[] = [];
             for (var i = 0, len = array.length; i < len; i++) {
diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts
index f6e8275786d29..ac2a79c603d5f 100644
--- a/src/compiler/diagnosticInformationMap.generated.ts
+++ b/src/compiler/diagnosticInformationMap.generated.ts
@@ -181,8 +181,6 @@ module ts {
         The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: { code: 2363, category: DiagnosticCategory.Error, key: "The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type." },
         Invalid_left_hand_side_of_assignment_expression: { code: 2364, category: DiagnosticCategory.Error, key: "Invalid left-hand side of assignment expression." },
         Operator_0_cannot_be_applied_to_types_1_and_2: { code: 2365, category: DiagnosticCategory.Error, key: "Operator '{0}' cannot be applied to types '{1}' and '{2}'." },
-        No_best_common_type_exists_between_0_1_and_2: { code: 2366, category: DiagnosticCategory.Error, key: "No best common type exists between '{0}', '{1}', and '{2}'." },
-        No_best_common_type_exists_between_0_and_1: { code: 2367, category: DiagnosticCategory.Error, key: "No best common type exists between '{0}' and '{1}'." },
         Type_parameter_name_cannot_be_0: { code: 2368, category: DiagnosticCategory.Error, key: "Type parameter name cannot be '{0}'" },
         A_parameter_property_is_only_allowed_in_a_constructor_implementation: { code: 2369, category: DiagnosticCategory.Error, key: "A parameter property is only allowed in a constructor implementation." },
         A_rest_parameter_must_be_of_an_array_type: { code: 2370, category: DiagnosticCategory.Error, key: "A rest parameter must be of an array type." },
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 97c82a0a71869..d8895d151442a 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -716,14 +716,6 @@
         "category": "Error",
         "code": 2365
     },
-    "No best common type exists between '{0}', '{1}', and '{2}'.": {
-        "category": "Error",
-        "code": 2366
-    },
-    "No best common type exists between '{0}' and '{1}'.": {
-        "category": "Error",
-        "code": 2367
-    },
     "Type parameter name cannot be '{0}'": {
         "category": "Error",
         "code": 2368
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 8a78500db8d49..b7582b9ed06ca 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -225,6 +225,8 @@ module ts {
                 return child((<ArrayTypeNode>node).elementType);
             case SyntaxKind.TupleType:
                 return children((<TupleTypeNode>node).elementTypes);
+            case SyntaxKind.UnionType:
+                return children((<UnionTypeNode>node).types);
             case SyntaxKind.ArrayLiteral:
                 return children((<ArrayLiteral>node).elements);
             case SyntaxKind.ObjectLiteral:
@@ -1729,9 +1731,9 @@ module ts {
             }
         }
 
-        function parseType(): TypeNode {
+        function parseNonUnionType(): TypeNode {
             var type = parseNonArrayType();
-            while (type && !scanner.hasPrecedingLineBreak() && parseOptional(SyntaxKind.OpenBracketToken)) {
+            while (!scanner.hasPrecedingLineBreak() && parseOptional(SyntaxKind.OpenBracketToken)) {
                 parseExpected(SyntaxKind.CloseBracketToken);
                 var node = <ArrayTypeNode>createNode(SyntaxKind.ArrayType, type.pos);
                 node.elementType = type;
@@ -1740,6 +1742,22 @@ module ts {
             return type;
         }
 
+        function parseType(): TypeNode {
+            var type = parseNonUnionType();
+            if (token === SyntaxKind.BarToken) {
+                var types = <NodeArray<TypeNode>>[type];
+                types.pos = type.pos;
+                while (parseOptional(SyntaxKind.BarToken)) {
+                    types.push(parseNonUnionType());
+                }
+                types.end = getNodeEnd();
+                var node = <UnionTypeNode>createNode(SyntaxKind.UnionType, type.pos);
+                node.types = types;
+                type = finishNode(node);
+            }
+            return type;
+        }
+
         function parseTypeAnnotation(): TypeNode {
             return parseOptional(SyntaxKind.ColonToken) ? parseType() : undefined;
         }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index c0571bdfb6088..b2da87c4ec0ce 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -154,6 +154,7 @@ module ts {
         TypeLiteral,
         ArrayType,
         TupleType,
+        UnionType,
         // Expression
         ArrayLiteral,
         ObjectLiteral,
@@ -224,7 +225,7 @@ module ts {
         FirstFutureReservedWord = ImplementsKeyword,
         LastFutureReservedWord = YieldKeyword,
         FirstTypeNode = TypeReference,
-        LastTypeNode = TupleType,
+        LastTypeNode = UnionType,
         FirstPunctuation = OpenBraceToken,
         LastPunctuation = CaretEqualsToken,
         FirstToken = EndOfFileToken,
@@ -337,6 +338,10 @@ module ts {
         elementTypes: NodeArray<TypeNode>;
     }
 
+    export interface UnionTypeNode extends TypeNode {
+        types: NodeArray<TypeNode>;
+    }
+
     export interface StringLiteralTypeNode extends TypeNode {
         text: string;
     }
@@ -648,7 +653,7 @@ module ts {
         writeSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void;
         getFullyQualifiedName(symbol: Symbol): string;
         getAugmentedPropertiesOfApparentType(type: Type): Symbol[];
-        getRootSymbol(symbol: Symbol): Symbol;
+        getRootSymbols(symbol: Symbol): Symbol[];
         getContextualType(node: Node): Type;
         getResolvedSignature(node: CallExpression, candidatesOutArray?: Signature[]): Signature;
         getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature;
@@ -757,19 +762,22 @@ module ts {
         ConstructSignature = 0x00010000,  // Construct signature
         IndexSignature     = 0x00020000,  // Index signature
         TypeParameter      = 0x00040000,  // Type parameter
+        UnionProperty      = 0x00080000,  // Property in union type
 
         // Export markers (see comment in declareModuleMember in binder)
-        ExportValue        = 0x00080000,  // Exported value marker
-        ExportType         = 0x00100000,  // Exported type marker
-        ExportNamespace    = 0x00200000,  // Exported namespace marker
-
-        Import             = 0x00400000,  // Import
-        Instantiated       = 0x00800000,  // Instantiated symbol
-        Merged             = 0x01000000,  // Merged symbol (created during program binding)
-        Transient          = 0x02000000,  // Transient symbol (created during type check)
-        Prototype          = 0x04000000,  // Symbol for the prototype property (without source code representation)
-
-        Value     = Variable | Property | EnumMember | Function | Class | Enum | ValueModule | Method | GetAccessor | SetAccessor,
+        ExportValue        = 0x00100000,  // Exported value marker
+        ExportType         = 0x00200000,  // Exported type marker
+        ExportNamespace    = 0x00400000,  // Exported namespace marker
+
+        Import             = 0x00800000,  // Import
+        Instantiated       = 0x01000000,  // Instantiated symbol
+        Merged             = 0x02000000,  // Merged symbol (created during program binding)
+        Transient          = 0x04000000,  // Transient symbol (created during type check)
+        Prototype          = 0x08000000,  // Prototype property (no source representation)
+        Undefined          = 0x10000000,  // Symbol for the undefined
+
+        Value     = Variable | Property | EnumMember | Function | Class | Enum | ValueModule | Method | GetAccessor | SetAccessor | UnionProperty,
+
         Type      = Class | Interface | Enum | TypeLiteral | ObjectLiteral | TypeParameter,
         Namespace = ValueModule | NamespaceModule,
         Module    = ValueModule | NamespaceModule,
@@ -827,6 +835,7 @@ module ts {
         mapper?: TypeMapper;           // Type mapper for instantiation alias
         referenced?: boolean;          // True if alias symbol has been referenced as a value
         exportAssignSymbol?: Symbol;   // Symbol exported from external module
+        unionType?: UnionType;         // Containing union type for union property
     }
 
     export interface TransientSymbol extends Symbol, SymbolLinks { }
@@ -849,14 +858,15 @@ module ts {
     }
 
     export interface NodeLinks {
-        resolvedType?: Type;            // Cached type of type node
-        resolvedSignature?: Signature;  // Cached signature of signature node or call expression
-        resolvedSymbol?: Symbol;        // Cached name resolution result
-        flags?: NodeCheckFlags;         // Set of flags specific to Node
-        enumMemberValue?: number;       // Constant value of enum member
+        resolvedType?: Type;              // Cached type of type node
+        resolvedSignature?: Signature;    // Cached signature of signature node or call expression
+        resolvedSymbol?: Symbol;          // Cached name resolution result
+        flags?: NodeCheckFlags;           // Set of flags specific to Node
+        enumMemberValue?: number;         // Constant value of enum member
         isIllegalTypeReferenceInConstraint?: boolean; // Is type reference in constraint refers to the type parameter from the same list
-        isVisible?: boolean;            // Is this node visible
-        localModuleName?: string;       // Local name for module instance
+        isVisible?: boolean;              // Is this node visible
+        localModuleName?: string;         // Local name for module instance
+        assignmentChecks?: Map<boolean>;  // Cache of assignment checks
     }
 
     export enum TypeFlags {
@@ -874,13 +884,14 @@ module ts {
         Interface          = 0x00000800,  // Interface
         Reference          = 0x00001000,  // Generic type reference
         Tuple              = 0x00002000,  // Tuple
-        Anonymous          = 0x00004000,  // Anonymous
-        FromSignature      = 0x00008000,  // Created for signature assignment check
+        Union              = 0x00004000,  // Union
+        Anonymous          = 0x00008000,  // Anonymous
+        FromSignature      = 0x00010000,  // Created for signature assignment check
 
-        Intrinsic = Any | String | Number | Boolean | Void | Undefined | Null,
+        Intrinsic  = Any | String | Number | Boolean | Void | Undefined | Null,
         StringLike = String | StringLiteral,
         NumberLike = Number | Enum,
-        ObjectType = Class | Interface | Reference | Tuple | Anonymous
+        ObjectType = Class | Interface | Reference | Tuple | Union | Anonymous,
     }
 
     // Properties common to all types
@@ -938,6 +949,10 @@ module ts {
         baseArrayType: TypeReference;  // Array<T> where T is best common type of element types
     }
 
+    export interface UnionType extends ObjectType {
+        types: Type[];  // Constituent types
+    }
+
     // Resolved object type
     export interface ResolvedObjectType extends ObjectType {
         members: SymbolTable;              // Properties by name
@@ -970,6 +985,7 @@ module ts {
         hasStringLiterals: boolean;         // True if specialized
         target?: Signature;                 // Instantiation target
         mapper?: TypeMapper;                // Instantiation mapper
+        unionSignatures?: Signature[];      // Underlying signatures of a union signature
         erasedSignatureCache?: Signature;   // Erased version of signature (deferred)
         isolatedSignatureType?: ObjectType; // A manufactured type that just contains the signature for purposes of signature comparison
     }
@@ -984,9 +1000,10 @@ module ts {
     }
 
     export interface InferenceContext {
-        typeParameters: TypeParameter[];
-        inferences: Type[][];
-        inferredTypes: Type[];
+        typeParameters: TypeParameter[];  // Type parameters for which inferences are made
+        inferenceCount: number;           // Incremented for every inference made (whether new or not)
+        inferences: Type[][];             // Inferences made for each type parameter
+        inferredTypes: Type[];            // Inferred type for each type parameter
     }
 
     export interface DiagnosticMessage {
diff --git a/src/services/services.ts b/src/services/services.ts
index 0e8b00f2faf5e..618026408fed6 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -2259,6 +2259,10 @@ module ts {
                 return undefined;
             }
 
+            // TODO(drosen): Right now we just permit *all* semantic meanings when calling 'getSymbolKind'
+            //               which is permissible given that it is backwards compatible; but really we should consider
+            //               passing the meaning for the node so that we don't report that a suggestion for a value is an interface.
+            //               We COULD also just do what 'getSymbolModifiers' does, which is to use the first declaration.
             return {
                 name: displayName,
                 kind: getSymbolKind(symbol, typeChecker),
@@ -2613,7 +2617,7 @@ module ts {
                 //               which is permissible given that it is backwards compatible; but really we should consider
                 //               passing the meaning for the node so that we don't report that a suggestion for a value is an interface.
                 //               We COULD also just do what 'getSymbolModifiers' does, which is to use the first declaration.
-                var displayPartsDocumentationsAndSymbolKind = getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, getSourceFile(filename), session.location, session.typeChecker, session.location);
+                var displayPartsDocumentationsAndSymbolKind = getSymbolDisplayPartsDocumentationAndSymbolKind(symbol, getSourceFile(filename), session.location, session.typeChecker, session.location, SemanticMeaning.All);
                 return {
                     name: entryName,
                     kind: displayPartsDocumentationsAndSymbolKind.symbolKind,
@@ -2658,7 +2662,7 @@ module ts {
 
         // TODO(drosen): use contextual SemanticMeaning.
         function getSymbolKind(symbol: Symbol, typeResolver: TypeChecker): string {
-            var flags = typeInfoResolver.getRootSymbol(symbol).getFlags();
+            var flags = typeInfoResolver.getRootSymbols(symbol)[0].getFlags();
 
             if (flags & SymbolFlags.Class) return ScriptElementKind.classElement;
             if (flags & SymbolFlags.Enum) return ScriptElementKind.enumElement;
@@ -2740,15 +2744,13 @@ module ts {
                 : ScriptElementKindModifier.none;
         }
 
-        // TODO(drosen): use contextual SemanticMeaning.
-        function getSymbolDisplayPartsDocumentationAndSymbolKind(symbol: Symbol,
-                                                                sourceFile: SourceFile,
-                                                                enclosingDeclaration: Node,
-                                                                typeResolver: TypeChecker,
-                                                                location: Node) {
+        function getSymbolDisplayPartsDocumentationAndSymbolKind(symbol: Symbol, sourceFile: SourceFile, enclosingDeclaration: Node,
+            typeResolver: TypeChecker, location: Node,
+            // TODO(drosen): Currently completion entry details passes the SemanticMeaning.All instead of using semanticMeaning of location
+            semanticMeaning = getMeaningFromLocation(location)) {
             var displayParts: SymbolDisplayPart[] = [];
             var documentation: SymbolDisplayPart[];
-            var symbolFlags = typeResolver.getRootSymbol(symbol).flags;
+            var symbolFlags = typeResolver.getRootSymbols(symbol)[0].flags;
             var symbolKind = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(symbol, symbolFlags, typeResolver);
             var hasAddedSymbolInfo: boolean;
             // Class at constructor site need to be shown as constructor apart from property,method, vars
@@ -2858,14 +2860,13 @@ module ts {
                     }
                 }
             }
-
             if (symbolFlags & SymbolFlags.Class && !hasAddedSymbolInfo) {
                 displayParts.push(keywordPart(SyntaxKind.ClassKeyword));
                 displayParts.push(spacePart());
                 addFullSymbolName(symbol);
                 writeTypeParametersOfSymbol(symbol, sourceFile);
             }
-            if (symbolFlags & SymbolFlags.Interface) {
+            if ((symbolFlags & SymbolFlags.Interface) && (semanticMeaning & SemanticMeaning.Type)) {
                 addNewLineIfDisplayPartsExist();
                 displayParts.push(keywordPart(SyntaxKind.InterfaceKeyword));
                 displayParts.push(spacePart());
@@ -2884,7 +2885,7 @@ module ts {
                 displayParts.push(spacePart());
                 addFullSymbolName(symbol);
             }
-            if (symbolFlags & SymbolFlags.TypeParameter) {
+            if ((symbolFlags & SymbolFlags.TypeParameter) && (semanticMeaning & SemanticMeaning.Type)) {
                 addNewLineIfDisplayPartsExist();
                 displayParts.push(punctuationPart(SyntaxKind.OpenParenToken));
                 displayParts.push(textPart("type parameter"));
@@ -3050,7 +3051,6 @@ module ts {
 
             var symbol = typeInfoResolver.getSymbolInfo(node);
             if (!symbol) {
-                
                 // Try getting just type at this position and show
                 switch (node.kind) {
                     case SyntaxKind.Identifier:
@@ -3085,7 +3085,7 @@ module ts {
         }
 
         /// Goto definition
-        function getDefinitionAtPosition(filename: string, position: number): DefinitionInfo[]{
+        function getDefinitionAtPosition(filename: string, position: number): DefinitionInfo[] {
             function getDefinitionInfo(node: Node, symbolKind: string, symbolName: string, containerName: string): DefinitionInfo {
                 return {
                     fileName: node.getSourceFile().filename,
@@ -3117,7 +3117,7 @@ module ts {
                     result.push(getDefinitionInfo(declarations[declarations.length - 1], symbolKind, symbolName, containerName));
                     return true;
                 }
-                
+
                 return false;
             }
 
@@ -3181,7 +3181,7 @@ module ts {
 
             // Could not find a symbol e.g. node is string or number keyword,
             // or the symbol was an internal symbol and does not have a declaration e.g. undefined symbol
-            if (!symbol || !(symbol.getDeclarations())) {
+            if (!symbol) {
                 return undefined;
             }
 
@@ -3714,18 +3714,20 @@ module ts {
                 return [getReferenceEntryFromNode(node)];
             }
 
-            // the symbol was an internal symbol and does not have a declaration e.g.undefined symbol
-            if (!symbol.getDeclarations()) {
+            var declarations = symbol.declarations;
+
+            // The symbol was an internal symbol and does not have a declaration e.g.undefined symbol
+            if (!declarations || !declarations.length) {
                 return undefined;
             }
 
             var result: ReferenceEntry[];
 
             // Compute the meaning from the location and the symbol it references
-            var searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), symbol.getDeclarations());
+            var searchMeaning = getIntersectingMeaningFromDeclarations(getMeaningFromLocation(node), declarations);
 
             // Get the text to search for, we need to normalize it as external module names will have quote
-            var symbolName = getNormalizedSymbolName(symbol);
+            var symbolName = getNormalizedSymbolName(symbol.name, declarations);
 
             // Get syntactic diagnostics
             var scope = getSymbolScope(symbol);
@@ -3747,15 +3749,15 @@ module ts {
 
             return result;
 
-            function getNormalizedSymbolName(symbol: Symbol): string {
+            function getNormalizedSymbolName(symbolName: string, declarations: Declaration[]): string {
                 // Special case for function expressions, whose names are solely local to their bodies.
-                var functionExpression = getDeclarationOfKind(symbol, SyntaxKind.FunctionExpression);
+                var functionExpression = forEach(declarations, d => d.kind === SyntaxKind.FunctionExpression ? d : undefined);
 
                 if (functionExpression && functionExpression.name) {
                     var name = functionExpression.name.text;
                 }
                 else {
-                    var name = symbol.name;
+                    var name = symbolName;
                 }
 
                 var length = name.length;
@@ -3782,22 +3784,24 @@ module ts {
                 var scope: Node = undefined;
 
                 var declarations = symbol.getDeclarations();
-                for (var i = 0, n = declarations.length; i < n; i++) {
-                    var container = getContainerNode(declarations[i]);
+                if (declarations) {
+                    for (var i = 0, n = declarations.length; i < n; i++) {
+                        var container = getContainerNode(declarations[i]);
 
-                    if (scope && scope !== container) {
-                        // Different declarations have different containers, bail out
-                        return undefined;
-                    }
+                        if (scope && scope !== container) {
+                            // Different declarations have different containers, bail out
+                            return undefined;
+                        }
 
-                    if (container.kind === SyntaxKind.SourceFile && !isExternalModule(<SourceFile>container)) {
-                        // This is a global variable and not an external module, any declaration defined
-                        // within this scope is visible outside the file
-                        return undefined;
-                    }
+                        if (container.kind === SyntaxKind.SourceFile && !isExternalModule(<SourceFile>container)) {
+                            // This is a global variable and not an external module, any declaration defined
+                            // within this scope is visible outside the file
+                            return undefined;
+                        }
 
-                    // The search scope is the container node
-                    scope = container;
+                        // The search scope is the container node
+                        scope = container;
+                    }
                 }
 
                 return scope;
@@ -3933,14 +3937,7 @@ module ts {
                         }
 
                         var referenceSymbol = typeInfoResolver.getSymbolInfo(referenceLocation);
-
-                        // Could not find a symbol e.g. node is string or number keyword,
-                        // or the symbol was an internal symbol and does not have a declaration e.g. undefined symbol
-                        if (!referenceSymbol || !(referenceSymbol.getDeclarations())) {
-                            return;
-                        }
-
-                        if (isRelatableToSearchSet(searchSymbols, referenceSymbol, referenceLocation)) {
+                        if (referenceSymbol && isRelatableToSearchSet(searchSymbols, referenceSymbol, referenceLocation)) {
                             result.push(getReferenceEntryFromNode(referenceLocation));
                         }
                     });
@@ -4102,24 +4099,27 @@ module ts {
                 // The search set contains at least the current symbol
                 var result = [symbol];
 
-                // If the symbol is an instantiation from a another symbol (e.g. widened symbol) , add the root the list
-                var rootSymbol = typeInfoResolver.getRootSymbol(symbol);
-                if (rootSymbol && rootSymbol !== symbol) {
-                    result.push(rootSymbol);
-                }
-
                 // If the location is in a context sensitive location (i.e. in an object literal) try
                 // to get a contextual type for it, and add the property symbol from the contextual
                 // type to the search set
                 if (isNameOfPropertyAssignment(location)) {
-                    var symbolFromContextualType = getPropertySymbolFromContextualType(location);
-                    if (symbolFromContextualType) result.push(typeInfoResolver.getRootSymbol(symbolFromContextualType));
+                    forEach(getPropertySymbolsFromContextualType(location), contextualSymbol => {
+                        result.push.apply(result, typeInfoResolver.getRootSymbols(contextualSymbol));
+                    });
                 }
 
-                // Add symbol of properties/methods of the same name in base classes and implemented interfaces definitions
-                if (symbol.parent && symbol.parent.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
-                    getPropertySymbolsFromBaseTypes(symbol.parent, symbol.getName(), result);
-                }
+                // If this is a union property, add all the symbols from all its source symbols in all unioned types.
+                // If the symbol is an instantiation from a another symbol (e.g. widened symbol) , add the root the list
+                forEach(typeInfoResolver.getRootSymbols(symbol), rootSymbol => {
+                    if (rootSymbol !== symbol) {
+                        result.push(rootSymbol);
+                    }
+
+                    // Add symbol of properties/methods of the same name in base classes and implemented interfaces definitions
+                    if (rootSymbol.parent && rootSymbol.parent.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
+                        getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result);
+                    }
+                });
 
                 return result;
             }
@@ -4155,11 +4155,7 @@ module ts {
             }
 
             function isRelatableToSearchSet(searchSymbols: Symbol[], referenceSymbol: Symbol, referenceLocation: Node): boolean {
-                // Unwrap symbols to get to the root (e.g. transient symbols as a result of widening)
-                var referenceSymbolTarget = typeInfoResolver.getRootSymbol(referenceSymbol);
-
-                // if it is in the list, then we are done
-                if (searchSymbols.indexOf(referenceSymbolTarget) >= 0) {
+                if (searchSymbols.indexOf(referenceSymbol) >= 0) {
                     return true;
                 }
 
@@ -4167,29 +4163,61 @@ module ts {
                 // object literal, lookup the property symbol in the contextual type, and use this symbol to
                 // compare to our searchSymbol
                 if (isNameOfPropertyAssignment(referenceLocation)) {
-                    var symbolFromContextualType = getPropertySymbolFromContextualType(referenceLocation);
-                    if (symbolFromContextualType && searchSymbols.indexOf(typeInfoResolver.getRootSymbol(symbolFromContextualType)) >= 0) {
+                    return forEach(getPropertySymbolsFromContextualType(referenceLocation), contextualSymbol => {
+                        return forEach(typeInfoResolver.getRootSymbols(contextualSymbol), s => searchSymbols.indexOf(s) >= 0);
+                    });
+                }
+
+                // Unwrap symbols to get to the root (e.g. transient symbols as a result of widening)
+                // Or a union property, use its underlying unioned symbols
+                return forEach(typeInfoResolver.getRootSymbols(referenceSymbol), rootSymbol => {
+                    // if it is in the list, then we are done
+                    if (searchSymbols.indexOf(rootSymbol) >= 0) {
                         return true;
                     }
-                }
 
-                // Finally, try all properties with the same name in any type the containing type extend or implemented, and 
-                // see if any is in the list
-                if (referenceSymbol.parent && referenceSymbol.parent.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
-                    var result: Symbol[] = [];
-                    getPropertySymbolsFromBaseTypes(referenceSymbol.parent, referenceSymbol.getName(), result);
-                    return forEach(result, s => searchSymbols.indexOf(s) >= 0);
-                }
+                    // Finally, try all properties with the same name in any type the containing type extended or implemented, and 
+                    // see if any is in the list
+                    if (rootSymbol.parent && rootSymbol.parent.flags & (SymbolFlags.Class | SymbolFlags.Interface)) {
+                        var result: Symbol[] = [];
+                        getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.getName(), result);
+                        return forEach(result, s => searchSymbols.indexOf(s) >= 0);
+                    }
 
-                return false;
+                    return false;
+                });
             }
 
-            function getPropertySymbolFromContextualType(node: Node): Symbol {
+            function getPropertySymbolsFromContextualType(node: Node): Symbol[] {
                 if (isNameOfPropertyAssignment(node)) {
                     var objectLiteral = node.parent.parent;
                     var contextualType = typeInfoResolver.getContextualType(objectLiteral);
+                    var name = (<Identifier>node).text;
                     if (contextualType) {
-                        return typeInfoResolver.getPropertyOfType(contextualType, (<Identifier>node).text);
+                        if (contextualType.flags & TypeFlags.Union) {
+                            // This is a union type, first see if the property we are looking for is a union property (i.e. exists in all types)
+                            // if not, search the constituent types for the property
+                            var unionProperty = contextualType.getProperty(name)
+                            if (unionProperty) {
+                                return [unionProperty];
+                            }
+                            else {
+                                var result: Symbol[] = [];
+                                forEach((<UnionType>contextualType).types, t => {
+                                    var symbol = t.getProperty(name);
+                                    if (symbol) {
+                                        result.push(symbol);
+                                    }
+                                });
+                                return result;
+                            }
+                        }
+                        else {
+                            var symbol = contextualType.getProperty(name);
+                            if (symbol) {
+                                return [symbol];
+                            }
+                        }
                     }
                 }
                 return undefined;
@@ -4691,7 +4719,6 @@ module ts {
             function classifySymbol(symbol: Symbol, meaningAtPosition: SemanticMeaning) {
                 var flags = symbol.getFlags();
 
-                // TODO(drosen): use meaningAtPosition.
                 if (flags & SymbolFlags.Class) {
                     return ClassificationTypeNames.className;
                 }
@@ -4709,8 +4736,6 @@ module ts {
                 else if (flags & SymbolFlags.Module) {
                     return ClassificationTypeNames.moduleName;
                 }
-
-                return undefined;
             }
 
             function processNode(node: Node) {
diff --git a/tests/baselines/reference/aliasUsageInArray.types b/tests/baselines/reference/aliasUsageInArray.types
index df657233f90c3..2e792d396038a 100644
--- a/tests/baselines/reference/aliasUsageInArray.types
+++ b/tests/baselines/reference/aliasUsageInArray.types
@@ -17,7 +17,7 @@ interface IHasVisualizationModel {
 var xs: IHasVisualizationModel[] = [moduleA];
 >xs : IHasVisualizationModel[]
 >IHasVisualizationModel : IHasVisualizationModel
->[moduleA] : IHasVisualizationModel[]
+>[moduleA] : typeof moduleA[]
 >moduleA : typeof moduleA
 
 var xs2: typeof moduleA[] = [moduleA];
diff --git a/tests/baselines/reference/aliasUsageInOrExpression.types b/tests/baselines/reference/aliasUsageInOrExpression.types
index fdcf0be44798e..c937187f04948 100644
--- a/tests/baselines/reference/aliasUsageInOrExpression.types
+++ b/tests/baselines/reference/aliasUsageInOrExpression.types
@@ -53,7 +53,7 @@ var f: { x: IHasVisualizationModel } = <{ x: IHasVisualizationModel }>null ? { x
 >f : { x: IHasVisualizationModel; }
 >x : IHasVisualizationModel
 >IHasVisualizationModel : IHasVisualizationModel
-><{ x: IHasVisualizationModel }>null ? { x: moduleA } : null : { x: IHasVisualizationModel; }
+><{ x: IHasVisualizationModel }>null ? { x: moduleA } : null : { x: typeof moduleA; }
 ><{ x: IHasVisualizationModel }>null : { x: IHasVisualizationModel; }
 >x : IHasVisualizationModel
 >IHasVisualizationModel : IHasVisualizationModel
diff --git a/tests/baselines/reference/arrayBestCommonTypes.js b/tests/baselines/reference/arrayBestCommonTypes.js
index 675d84119c038..f8e158e5b02a6 100644
--- a/tests/baselines/reference/arrayBestCommonTypes.js
+++ b/tests/baselines/reference/arrayBestCommonTypes.js
@@ -1,55 +1,109 @@
 //// [arrayBestCommonTypes.ts]
-interface iface { }
-class base implements iface { }
-class base2 implements iface { }
-class derived extends base { }
-
-
-class f {
-    public voidIfAny(x: boolean, y?: boolean): number;
-    public voidIfAny(x: string, y?: boolean): number;
-    public voidIfAny(x: number, y?: boolean): number;
-    public voidIfAny(x: any, y =false): any { return null; }
-    
-    public x() {
-        <number>(this.voidIfAny([4, 2][0]));
-        <number>(this.voidIfAny([4, 2, undefined][0]));
-        <number>(this.voidIfAny([undefined, 2, 4][0]));
-        <number>(this.voidIfAny([null, 2, 4][0]));
-        <number>(this.voidIfAny([2, 4, null][0]));
-        <number>(this.voidIfAny([undefined, 4, null][0]));
-
-        <number>(this.voidIfAny(['', "q"][0]));
-        <number>(this.voidIfAny(['', "q", undefined][0]));
-        <number>(this.voidIfAny([undefined, "q", ''][0]));
-        <number>(this.voidIfAny([null, "q", ''][0]));
-        <number>(this.voidIfAny(["q", '', null][0]));
-        <number>(this.voidIfAny([undefined, '', null][0]));
-
-        <number>(this.voidIfAny([[3,4],[null]][0][0]));
-        
-        
-        var t1: { x: number; y: base; }[] = [ { x: 7, y: new derived() }, { x: 5, y: new base() } ];
-        var t2: { x: boolean; y: base; }[] = [ { x: true, y: new derived() }, { x: false, y: new base() } ];
-        var t3: { x: string; y: base; }[] = [ { x: undefined, y: new base() }, { x: '', y: new derived() } ];
-
-        var anyObj: any = null;
-        // Order matters here so test all the variants
-        var a1 = [ {x: 0, y: 'a'}, {x: 'a', y: 'a'}, {x: anyObj, y: 'a'} ];
-        var a2 = [ {x: anyObj, y: 'a'}, {x: 0, y: 'a'}, {x: 'a', y: 'a'} ];
-        var a3 = [ {x: 0, y: 'a'}, {x: anyObj, y: 'a'}, {x: 'a', y: 'a'} ];
-        
-        var ifaceObj: iface = null;
-        var baseObj = new base();
-        var base2Obj = new base2();
-
-        var b1 = [ baseObj, base2Obj, ifaceObj ];
-        var b2 = [ base2Obj, baseObj, ifaceObj ];
-        var b3 = [ baseObj, ifaceObj, base2Obj ];
-        var b4 = [ ifaceObj, baseObj, base2Obj ];
+module EmptyTypes {
+    interface iface { }
+    class base implements iface { }
+    class base2 implements iface { }
+    class derived extends base { }
+
+
+    class f {
+        public voidIfAny(x: boolean, y?: boolean): number;
+        public voidIfAny(x: string, y?: boolean): number;
+        public voidIfAny(x: number, y?: boolean): number;
+        public voidIfAny(x: any, y = false): any { return null; }
+
+        public x() {
+            <number>(this.voidIfAny([4, 2][0]));
+            <number>(this.voidIfAny([4, 2, undefined][0]));
+            <number>(this.voidIfAny([undefined, 2, 4][0]));
+            <number>(this.voidIfAny([null, 2, 4][0]));
+            <number>(this.voidIfAny([2, 4, null][0]));
+            <number>(this.voidIfAny([undefined, 4, null][0]));
+
+            <number>(this.voidIfAny(['', "q"][0]));
+            <number>(this.voidIfAny(['', "q", undefined][0]));
+            <number>(this.voidIfAny([undefined, "q", ''][0]));
+            <number>(this.voidIfAny([null, "q", ''][0]));
+            <number>(this.voidIfAny(["q", '', null][0]));
+            <number>(this.voidIfAny([undefined, '', null][0]));
+
+            <number>(this.voidIfAny([[3, 4], [null]][0][0]));
+
+
+            var t1: { x: number; y: base; }[] = [{ x: 7, y: new derived() }, { x: 5, y: new base() }];
+            var t2: { x: boolean; y: base; }[] = [{ x: true, y: new derived() }, { x: false, y: new base() }];
+            var t3: { x: string; y: base; }[] = [{ x: undefined, y: new base() }, { x: '', y: new derived() }];
+
+            var anyObj: any = null;
+            // Order matters here so test all the variants
+            var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
+            var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
+            var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
+
+            var ifaceObj: iface = null;
+            var baseObj = new base();
+            var base2Obj = new base2();
+
+            var b1 = [baseObj, base2Obj, ifaceObj];
+            var b2 = [base2Obj, baseObj, ifaceObj];
+            var b3 = [baseObj, ifaceObj, base2Obj];
+            var b4 = [ifaceObj, baseObj, base2Obj];
+        }
     }
 }
 
+module NonEmptyTypes {
+    interface iface { x: string; }
+    class base implements iface { x: string; y: string; }
+    class base2 implements iface { x: string; z: string; }
+    class derived extends base { a: string; }
+
+
+    class f {
+        public voidIfAny(x: boolean, y?: boolean): number;
+        public voidIfAny(x: string, y?: boolean): number;
+        public voidIfAny(x: number, y?: boolean): number;
+        public voidIfAny(x: any, y = false): any { return null; }
+
+        public x() {
+            <number>(this.voidIfAny([4, 2][0]));
+            <number>(this.voidIfAny([4, 2, undefined][0]));
+            <number>(this.voidIfAny([undefined, 2, 4][0]));
+            <number>(this.voidIfAny([null, 2, 4][0]));
+            <number>(this.voidIfAny([2, 4, null][0]));
+            <number>(this.voidIfAny([undefined, 4, null][0]));
+
+            <number>(this.voidIfAny(['', "q"][0]));
+            <number>(this.voidIfAny(['', "q", undefined][0]));
+            <number>(this.voidIfAny([undefined, "q", ''][0]));
+            <number>(this.voidIfAny([null, "q", ''][0]));
+            <number>(this.voidIfAny(["q", '', null][0]));
+            <number>(this.voidIfAny([undefined, '', null][0]));
+
+            <number>(this.voidIfAny([[3, 4], [null]][0][0]));
+
+
+            var t1: { x: number; y: base; }[] = [{ x: 7, y: new derived() }, { x: 5, y: new base() }];
+            var t2: { x: boolean; y: base; }[] = [{ x: true, y: new derived() }, { x: false, y: new base() }];
+            var t3: { x: string; y: base; }[] = [{ x: undefined, y: new base() }, { x: '', y: new derived() }];
+
+            var anyObj: any = null;
+            // Order matters here so test all the variants
+            var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
+            var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
+            var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
+
+            var ifaceObj: iface = null;
+            var baseObj = new base();
+            var base2Obj = new base2();
+
+            var b1 = [baseObj, base2Obj, ifaceObj];
+            var b2 = [base2Obj, baseObj, ifaceObj];
+            var b3 = [baseObj, ifaceObj, base2Obj];
+            var b4 = [ifaceObj, baseObj, base2Obj];
+        }
+    }
+}
 
 
 
@@ -60,59 +114,121 @@ var __extends = this.__extends || function (d, b) {
     __.prototype = b.prototype;
     d.prototype = new __();
 };
-var base = (function () {
-    function base() {
-    }
-    return base;
-})();
-var base2 = (function () {
-    function base2() {
-    }
-    return base2;
-})();
-var derived = (function (_super) {
-    __extends(derived, _super);
-    function derived() {
-        _super.apply(this, arguments);
-    }
-    return derived;
-})(base);
-var f = (function () {
-    function f() {
-    }
-    f.prototype.voidIfAny = function (x, y) {
-        if (y === void 0) { y = false; }
-        return null;
-    };
-    f.prototype.x = function () {
-        (this.voidIfAny([4, 2][0]));
-        (this.voidIfAny([4, 2, undefined][0]));
-        (this.voidIfAny([undefined, 2, 4][0]));
-        (this.voidIfAny([null, 2, 4][0]));
-        (this.voidIfAny([2, 4, null][0]));
-        (this.voidIfAny([undefined, 4, null][0]));
-        (this.voidIfAny(['', "q"][0]));
-        (this.voidIfAny(['', "q", undefined][0]));
-        (this.voidIfAny([undefined, "q", ''][0]));
-        (this.voidIfAny([null, "q", ''][0]));
-        (this.voidIfAny(["q", '', null][0]));
-        (this.voidIfAny([undefined, '', null][0]));
-        (this.voidIfAny([[3, 4], [null]][0][0]));
-        var t1 = [{ x: 7, y: new derived() }, { x: 5, y: new base() }];
-        var t2 = [{ x: true, y: new derived() }, { x: false, y: new base() }];
-        var t3 = [{ x: undefined, y: new base() }, { x: '', y: new derived() }];
-        var anyObj = null;
-        // Order matters here so test all the variants
-        var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
-        var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
-        var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
-        var ifaceObj = null;
-        var baseObj = new base();
-        var base2Obj = new base2();
-        var b1 = [baseObj, base2Obj, ifaceObj];
-        var b2 = [base2Obj, baseObj, ifaceObj];
-        var b3 = [baseObj, ifaceObj, base2Obj];
-        var b4 = [ifaceObj, baseObj, base2Obj];
-    };
-    return f;
-})();
+var EmptyTypes;
+(function (EmptyTypes) {
+    var base = (function () {
+        function base() {
+        }
+        return base;
+    })();
+    var base2 = (function () {
+        function base2() {
+        }
+        return base2;
+    })();
+    var derived = (function (_super) {
+        __extends(derived, _super);
+        function derived() {
+            _super.apply(this, arguments);
+        }
+        return derived;
+    })(base);
+    var f = (function () {
+        function f() {
+        }
+        f.prototype.voidIfAny = function (x, y) {
+            if (y === void 0) { y = false; }
+            return null;
+        };
+        f.prototype.x = function () {
+            (this.voidIfAny([4, 2][0]));
+            (this.voidIfAny([4, 2, undefined][0]));
+            (this.voidIfAny([undefined, 2, 4][0]));
+            (this.voidIfAny([null, 2, 4][0]));
+            (this.voidIfAny([2, 4, null][0]));
+            (this.voidIfAny([undefined, 4, null][0]));
+            (this.voidIfAny(['', "q"][0]));
+            (this.voidIfAny(['', "q", undefined][0]));
+            (this.voidIfAny([undefined, "q", ''][0]));
+            (this.voidIfAny([null, "q", ''][0]));
+            (this.voidIfAny(["q", '', null][0]));
+            (this.voidIfAny([undefined, '', null][0]));
+            (this.voidIfAny([[3, 4], [null]][0][0]));
+            var t1 = [{ x: 7, y: new derived() }, { x: 5, y: new base() }];
+            var t2 = [{ x: true, y: new derived() }, { x: false, y: new base() }];
+            var t3 = [{ x: undefined, y: new base() }, { x: '', y: new derived() }];
+            var anyObj = null;
+            // Order matters here so test all the variants
+            var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
+            var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
+            var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
+            var ifaceObj = null;
+            var baseObj = new base();
+            var base2Obj = new base2();
+            var b1 = [baseObj, base2Obj, ifaceObj];
+            var b2 = [base2Obj, baseObj, ifaceObj];
+            var b3 = [baseObj, ifaceObj, base2Obj];
+            var b4 = [ifaceObj, baseObj, base2Obj];
+        };
+        return f;
+    })();
+})(EmptyTypes || (EmptyTypes = {}));
+var NonEmptyTypes;
+(function (NonEmptyTypes) {
+    var base = (function () {
+        function base() {
+        }
+        return base;
+    })();
+    var base2 = (function () {
+        function base2() {
+        }
+        return base2;
+    })();
+    var derived = (function (_super) {
+        __extends(derived, _super);
+        function derived() {
+            _super.apply(this, arguments);
+        }
+        return derived;
+    })(base);
+    var f = (function () {
+        function f() {
+        }
+        f.prototype.voidIfAny = function (x, y) {
+            if (y === void 0) { y = false; }
+            return null;
+        };
+        f.prototype.x = function () {
+            (this.voidIfAny([4, 2][0]));
+            (this.voidIfAny([4, 2, undefined][0]));
+            (this.voidIfAny([undefined, 2, 4][0]));
+            (this.voidIfAny([null, 2, 4][0]));
+            (this.voidIfAny([2, 4, null][0]));
+            (this.voidIfAny([undefined, 4, null][0]));
+            (this.voidIfAny(['', "q"][0]));
+            (this.voidIfAny(['', "q", undefined][0]));
+            (this.voidIfAny([undefined, "q", ''][0]));
+            (this.voidIfAny([null, "q", ''][0]));
+            (this.voidIfAny(["q", '', null][0]));
+            (this.voidIfAny([undefined, '', null][0]));
+            (this.voidIfAny([[3, 4], [null]][0][0]));
+            var t1 = [{ x: 7, y: new derived() }, { x: 5, y: new base() }];
+            var t2 = [{ x: true, y: new derived() }, { x: false, y: new base() }];
+            var t3 = [{ x: undefined, y: new base() }, { x: '', y: new derived() }];
+            var anyObj = null;
+            // Order matters here so test all the variants
+            var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
+            var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
+            var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
+            var ifaceObj = null;
+            var baseObj = new base();
+            var base2Obj = new base2();
+            var b1 = [baseObj, base2Obj, ifaceObj];
+            var b2 = [base2Obj, baseObj, ifaceObj];
+            var b3 = [baseObj, ifaceObj, base2Obj];
+            var b4 = [ifaceObj, baseObj, base2Obj];
+        };
+        return f;
+    })();
+})(NonEmptyTypes || (NonEmptyTypes = {}));
diff --git a/tests/baselines/reference/arrayBestCommonTypes.types b/tests/baselines/reference/arrayBestCommonTypes.types
index a0f407358c3fb..c9d39d5c1e8bf 100644
--- a/tests/baselines/reference/arrayBestCommonTypes.types
+++ b/tests/baselines/reference/arrayBestCommonTypes.types
@@ -1,47 +1,50 @@
 === tests/cases/compiler/arrayBestCommonTypes.ts ===
-interface iface { }
+module EmptyTypes {
+>EmptyTypes : typeof EmptyTypes
+
+    interface iface { }
 >iface : iface
 
-class base implements iface { }
+    class base implements iface { }
 >base : base
 >iface : iface
 
-class base2 implements iface { }
+    class base2 implements iface { }
 >base2 : base2
 >iface : iface
 
-class derived extends base { }
+    class derived extends base { }
 >derived : derived
 >base : base
 
 
-class f {
+    class f {
 >f : f
 
-    public voidIfAny(x: boolean, y?: boolean): number;
+        public voidIfAny(x: boolean, y?: boolean): number;
 >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
 >x : boolean
 >y : boolean
 
-    public voidIfAny(x: string, y?: boolean): number;
+        public voidIfAny(x: string, y?: boolean): number;
 >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
 >x : string
 >y : boolean
 
-    public voidIfAny(x: number, y?: boolean): number;
+        public voidIfAny(x: number, y?: boolean): number;
 >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
 >x : number
 >y : boolean
 
-    public voidIfAny(x: any, y =false): any { return null; }
+        public voidIfAny(x: any, y = false): any { return null; }
 >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
 >x : any
 >y : boolean
-    
-    public x() {
+
+        public x() {
 >x : () => void
 
-        <number>(this.voidIfAny([4, 2][0]));
+            <number>(this.voidIfAny([4, 2][0]));
 ><number>(this.voidIfAny([4, 2][0])) : number
 >(this.voidIfAny([4, 2][0])) : number
 >this.voidIfAny([4, 2][0]) : number
@@ -51,7 +54,7 @@ class f {
 >[4, 2][0] : number
 >[4, 2] : number[]
 
-        <number>(this.voidIfAny([4, 2, undefined][0]));
+            <number>(this.voidIfAny([4, 2, undefined][0]));
 ><number>(this.voidIfAny([4, 2, undefined][0])) : number
 >(this.voidIfAny([4, 2, undefined][0])) : number
 >this.voidIfAny([4, 2, undefined][0]) : number
@@ -62,7 +65,7 @@ class f {
 >[4, 2, undefined] : number[]
 >undefined : undefined
 
-        <number>(this.voidIfAny([undefined, 2, 4][0]));
+            <number>(this.voidIfAny([undefined, 2, 4][0]));
 ><number>(this.voidIfAny([undefined, 2, 4][0])) : number
 >(this.voidIfAny([undefined, 2, 4][0])) : number
 >this.voidIfAny([undefined, 2, 4][0]) : number
@@ -73,7 +76,7 @@ class f {
 >[undefined, 2, 4] : number[]
 >undefined : undefined
 
-        <number>(this.voidIfAny([null, 2, 4][0]));
+            <number>(this.voidIfAny([null, 2, 4][0]));
 ><number>(this.voidIfAny([null, 2, 4][0])) : number
 >(this.voidIfAny([null, 2, 4][0])) : number
 >this.voidIfAny([null, 2, 4][0]) : number
@@ -83,7 +86,7 @@ class f {
 >[null, 2, 4][0] : number
 >[null, 2, 4] : number[]
 
-        <number>(this.voidIfAny([2, 4, null][0]));
+            <number>(this.voidIfAny([2, 4, null][0]));
 ><number>(this.voidIfAny([2, 4, null][0])) : number
 >(this.voidIfAny([2, 4, null][0])) : number
 >this.voidIfAny([2, 4, null][0]) : number
@@ -93,7 +96,7 @@ class f {
 >[2, 4, null][0] : number
 >[2, 4, null] : number[]
 
-        <number>(this.voidIfAny([undefined, 4, null][0]));
+            <number>(this.voidIfAny([undefined, 4, null][0]));
 ><number>(this.voidIfAny([undefined, 4, null][0])) : number
 >(this.voidIfAny([undefined, 4, null][0])) : number
 >this.voidIfAny([undefined, 4, null][0]) : number
@@ -104,7 +107,7 @@ class f {
 >[undefined, 4, null] : number[]
 >undefined : undefined
 
-        <number>(this.voidIfAny(['', "q"][0]));
+            <number>(this.voidIfAny(['', "q"][0]));
 ><number>(this.voidIfAny(['', "q"][0])) : number
 >(this.voidIfAny(['', "q"][0])) : number
 >this.voidIfAny(['', "q"][0]) : number
@@ -114,7 +117,7 @@ class f {
 >['', "q"][0] : string
 >['', "q"] : string[]
 
-        <number>(this.voidIfAny(['', "q", undefined][0]));
+            <number>(this.voidIfAny(['', "q", undefined][0]));
 ><number>(this.voidIfAny(['', "q", undefined][0])) : number
 >(this.voidIfAny(['', "q", undefined][0])) : number
 >this.voidIfAny(['', "q", undefined][0]) : number
@@ -125,7 +128,7 @@ class f {
 >['', "q", undefined] : string[]
 >undefined : undefined
 
-        <number>(this.voidIfAny([undefined, "q", ''][0]));
+            <number>(this.voidIfAny([undefined, "q", ''][0]));
 ><number>(this.voidIfAny([undefined, "q", ''][0])) : number
 >(this.voidIfAny([undefined, "q", ''][0])) : number
 >this.voidIfAny([undefined, "q", ''][0]) : number
@@ -136,7 +139,7 @@ class f {
 >[undefined, "q", ''] : string[]
 >undefined : undefined
 
-        <number>(this.voidIfAny([null, "q", ''][0]));
+            <number>(this.voidIfAny([null, "q", ''][0]));
 ><number>(this.voidIfAny([null, "q", ''][0])) : number
 >(this.voidIfAny([null, "q", ''][0])) : number
 >this.voidIfAny([null, "q", ''][0]) : number
@@ -146,7 +149,7 @@ class f {
 >[null, "q", ''][0] : string
 >[null, "q", ''] : string[]
 
-        <number>(this.voidIfAny(["q", '', null][0]));
+            <number>(this.voidIfAny(["q", '', null][0]));
 ><number>(this.voidIfAny(["q", '', null][0])) : number
 >(this.voidIfAny(["q", '', null][0])) : number
 >this.voidIfAny(["q", '', null][0]) : number
@@ -156,7 +159,7 @@ class f {
 >["q", '', null][0] : string
 >["q", '', null] : string[]
 
-        <number>(this.voidIfAny([undefined, '', null][0]));
+            <number>(this.voidIfAny([undefined, '', null][0]));
 ><number>(this.voidIfAny([undefined, '', null][0])) : number
 >(this.voidIfAny([undefined, '', null][0])) : number
 >this.voidIfAny([undefined, '', null][0]) : number
@@ -167,26 +170,26 @@ class f {
 >[undefined, '', null] : string[]
 >undefined : undefined
 
-        <number>(this.voidIfAny([[3,4],[null]][0][0]));
-><number>(this.voidIfAny([[3,4],[null]][0][0])) : number
->(this.voidIfAny([[3,4],[null]][0][0])) : number
->this.voidIfAny([[3,4],[null]][0][0]) : number
+            <number>(this.voidIfAny([[3, 4], [null]][0][0]));
+><number>(this.voidIfAny([[3, 4], [null]][0][0])) : number
+>(this.voidIfAny([[3, 4], [null]][0][0])) : number
+>this.voidIfAny([[3, 4], [null]][0][0]) : number
 >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
 >this : f
 >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
->[[3,4],[null]][0][0] : number
->[[3,4],[null]][0] : number[]
->[[3,4],[null]] : number[][]
->[3,4] : number[]
+>[[3, 4], [null]][0][0] : number
+>[[3, 4], [null]][0] : number[]
+>[[3, 4], [null]] : number[][]
+>[3, 4] : number[]
 >[null] : null[]
-        
-        
-        var t1: { x: number; y: base; }[] = [ { x: 7, y: new derived() }, { x: 5, y: new base() } ];
+
+
+            var t1: { x: number; y: base; }[] = [{ x: 7, y: new derived() }, { x: 5, y: new base() }];
 >t1 : { x: number; y: base; }[]
 >x : number
 >y : base
 >base : base
->[ { x: 7, y: new derived() }, { x: 5, y: new base() } ] : { x: number; y: base; }[]
+>[{ x: 7, y: new derived() }, { x: 5, y: new base() }] : { x: number; y: derived; }[]
 >{ x: 7, y: new derived() } : { x: number; y: derived; }
 >x : number
 >y : derived
@@ -198,12 +201,12 @@ class f {
 >new base() : base
 >base : typeof base
 
-        var t2: { x: boolean; y: base; }[] = [ { x: true, y: new derived() }, { x: false, y: new base() } ];
+            var t2: { x: boolean; y: base; }[] = [{ x: true, y: new derived() }, { x: false, y: new base() }];
 >t2 : { x: boolean; y: base; }[]
 >x : boolean
 >y : base
 >base : base
->[ { x: true, y: new derived() }, { x: false, y: new base() } ] : { x: boolean; y: base; }[]
+>[{ x: true, y: new derived() }, { x: false, y: new base() }] : { x: boolean; y: derived; }[]
 >{ x: true, y: new derived() } : { x: boolean; y: derived; }
 >x : boolean
 >y : derived
@@ -215,12 +218,12 @@ class f {
 >new base() : base
 >base : typeof base
 
-        var t3: { x: string; y: base; }[] = [ { x: undefined, y: new base() }, { x: '', y: new derived() } ];
+            var t3: { x: string; y: base; }[] = [{ x: undefined, y: new base() }, { x: '', y: new derived() }];
 >t3 : { x: string; y: base; }[]
 >x : string
 >y : base
 >base : base
->[ { x: undefined, y: new base() }, { x: '', y: new derived() } ] : { x: string; y: base; }[]
+>[{ x: undefined, y: new base() }, { x: '', y: new derived() }] : { x: string; y: derived; }[]
 >{ x: undefined, y: new base() } : { x: undefined; y: base; }
 >x : undefined
 >undefined : undefined
@@ -233,95 +236,429 @@ class f {
 >new derived() : derived
 >derived : typeof derived
 
-        var anyObj: any = null;
+            var anyObj: any = null;
 >anyObj : any
 
-        // Order matters here so test all the variants
-        var a1 = [ {x: 0, y: 'a'}, {x: 'a', y: 'a'}, {x: anyObj, y: 'a'} ];
+            // Order matters here so test all the variants
+            var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
 >a1 : { x: any; y: string; }[]
->[ {x: 0, y: 'a'}, {x: 'a', y: 'a'}, {x: anyObj, y: 'a'} ] : { x: any; y: string; }[]
->{x: 0, y: 'a'} : { x: number; y: string; }
+>[{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }] : { x: any; y: string; }[]
+>{ x: 0, y: 'a' } : { x: number; y: string; }
 >x : number
 >y : string
->{x: 'a', y: 'a'} : { x: string; y: string; }
+>{ x: 'a', y: 'a' } : { x: string; y: string; }
 >x : string
 >y : string
->{x: anyObj, y: 'a'} : { x: any; y: string; }
+>{ x: anyObj, y: 'a' } : { x: any; y: string; }
 >x : any
 >anyObj : any
 >y : string
 
-        var a2 = [ {x: anyObj, y: 'a'}, {x: 0, y: 'a'}, {x: 'a', y: 'a'} ];
+            var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
 >a2 : { x: any; y: string; }[]
->[ {x: anyObj, y: 'a'}, {x: 0, y: 'a'}, {x: 'a', y: 'a'} ] : { x: any; y: string; }[]
->{x: anyObj, y: 'a'} : { x: any; y: string; }
+>[{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }] : { x: any; y: string; }[]
+>{ x: anyObj, y: 'a' } : { x: any; y: string; }
 >x : any
 >anyObj : any
 >y : string
->{x: 0, y: 'a'} : { x: number; y: string; }
+>{ x: 0, y: 'a' } : { x: number; y: string; }
 >x : number
 >y : string
->{x: 'a', y: 'a'} : { x: string; y: string; }
+>{ x: 'a', y: 'a' } : { x: string; y: string; }
 >x : string
 >y : string
 
-        var a3 = [ {x: 0, y: 'a'}, {x: anyObj, y: 'a'}, {x: 'a', y: 'a'} ];
+            var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
 >a3 : { x: any; y: string; }[]
->[ {x: 0, y: 'a'}, {x: anyObj, y: 'a'}, {x: 'a', y: 'a'} ] : { x: any; y: string; }[]
->{x: 0, y: 'a'} : { x: number; y: string; }
+>[{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }] : { x: any; y: string; }[]
+>{ x: 0, y: 'a' } : { x: number; y: string; }
 >x : number
 >y : string
->{x: anyObj, y: 'a'} : { x: any; y: string; }
+>{ x: anyObj, y: 'a' } : { x: any; y: string; }
 >x : any
 >anyObj : any
 >y : string
->{x: 'a', y: 'a'} : { x: string; y: string; }
+>{ x: 'a', y: 'a' } : { x: string; y: string; }
 >x : string
 >y : string
-        
-        var ifaceObj: iface = null;
+
+            var ifaceObj: iface = null;
 >ifaceObj : iface
 >iface : iface
 
-        var baseObj = new base();
+            var baseObj = new base();
 >baseObj : base
 >new base() : base
 >base : typeof base
 
-        var base2Obj = new base2();
+            var base2Obj = new base2();
 >base2Obj : base2
 >new base2() : base2
 >base2 : typeof base2
 
-        var b1 = [ baseObj, base2Obj, ifaceObj ];
->b1 : base[]
->[ baseObj, base2Obj, ifaceObj ] : base[]
+            var b1 = [baseObj, base2Obj, ifaceObj];
+>b1 : iface[]
+>[baseObj, base2Obj, ifaceObj] : iface[]
 >baseObj : base
 >base2Obj : base2
 >ifaceObj : iface
 
-        var b2 = [ base2Obj, baseObj, ifaceObj ];
->b2 : base2[]
->[ base2Obj, baseObj, ifaceObj ] : base2[]
+            var b2 = [base2Obj, baseObj, ifaceObj];
+>b2 : iface[]
+>[base2Obj, baseObj, ifaceObj] : iface[]
 >base2Obj : base2
 >baseObj : base
 >ifaceObj : iface
 
-        var b3 = [ baseObj, ifaceObj, base2Obj ];
->b3 : base[]
->[ baseObj, ifaceObj, base2Obj ] : base[]
+            var b3 = [baseObj, ifaceObj, base2Obj];
+>b3 : iface[]
+>[baseObj, ifaceObj, base2Obj] : iface[]
 >baseObj : base
 >ifaceObj : iface
 >base2Obj : base2
 
-        var b4 = [ ifaceObj, baseObj, base2Obj ];
+            var b4 = [ifaceObj, baseObj, base2Obj];
 >b4 : iface[]
->[ ifaceObj, baseObj, base2Obj ] : iface[]
+>[ifaceObj, baseObj, base2Obj] : iface[]
 >ifaceObj : iface
 >baseObj : base
 >base2Obj : base2
+        }
     }
 }
 
+module NonEmptyTypes {
+>NonEmptyTypes : typeof NonEmptyTypes
+
+    interface iface { x: string; }
+>iface : iface
+>x : string
+
+    class base implements iface { x: string; y: string; }
+>base : base
+>iface : iface
+>x : string
+>y : string
+
+    class base2 implements iface { x: string; z: string; }
+>base2 : base2
+>iface : iface
+>x : string
+>z : string
+
+    class derived extends base { a: string; }
+>derived : derived
+>base : base
+>a : string
+
+
+    class f {
+>f : f
+
+        public voidIfAny(x: boolean, y?: boolean): number;
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>x : boolean
+>y : boolean
+
+        public voidIfAny(x: string, y?: boolean): number;
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>x : string
+>y : boolean
+
+        public voidIfAny(x: number, y?: boolean): number;
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>x : number
+>y : boolean
+
+        public voidIfAny(x: any, y = false): any { return null; }
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>x : any
+>y : boolean
+
+        public x() {
+>x : () => void
+
+            <number>(this.voidIfAny([4, 2][0]));
+><number>(this.voidIfAny([4, 2][0])) : number
+>(this.voidIfAny([4, 2][0])) : number
+>this.voidIfAny([4, 2][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[4, 2][0] : number
+>[4, 2] : number[]
+
+            <number>(this.voidIfAny([4, 2, undefined][0]));
+><number>(this.voidIfAny([4, 2, undefined][0])) : number
+>(this.voidIfAny([4, 2, undefined][0])) : number
+>this.voidIfAny([4, 2, undefined][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[4, 2, undefined][0] : number
+>[4, 2, undefined] : number[]
+>undefined : undefined
+
+            <number>(this.voidIfAny([undefined, 2, 4][0]));
+><number>(this.voidIfAny([undefined, 2, 4][0])) : number
+>(this.voidIfAny([undefined, 2, 4][0])) : number
+>this.voidIfAny([undefined, 2, 4][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[undefined, 2, 4][0] : number
+>[undefined, 2, 4] : number[]
+>undefined : undefined
+
+            <number>(this.voidIfAny([null, 2, 4][0]));
+><number>(this.voidIfAny([null, 2, 4][0])) : number
+>(this.voidIfAny([null, 2, 4][0])) : number
+>this.voidIfAny([null, 2, 4][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[null, 2, 4][0] : number
+>[null, 2, 4] : number[]
+
+            <number>(this.voidIfAny([2, 4, null][0]));
+><number>(this.voidIfAny([2, 4, null][0])) : number
+>(this.voidIfAny([2, 4, null][0])) : number
+>this.voidIfAny([2, 4, null][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[2, 4, null][0] : number
+>[2, 4, null] : number[]
+
+            <number>(this.voidIfAny([undefined, 4, null][0]));
+><number>(this.voidIfAny([undefined, 4, null][0])) : number
+>(this.voidIfAny([undefined, 4, null][0])) : number
+>this.voidIfAny([undefined, 4, null][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[undefined, 4, null][0] : number
+>[undefined, 4, null] : number[]
+>undefined : undefined
+
+            <number>(this.voidIfAny(['', "q"][0]));
+><number>(this.voidIfAny(['', "q"][0])) : number
+>(this.voidIfAny(['', "q"][0])) : number
+>this.voidIfAny(['', "q"][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>['', "q"][0] : string
+>['', "q"] : string[]
+
+            <number>(this.voidIfAny(['', "q", undefined][0]));
+><number>(this.voidIfAny(['', "q", undefined][0])) : number
+>(this.voidIfAny(['', "q", undefined][0])) : number
+>this.voidIfAny(['', "q", undefined][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>['', "q", undefined][0] : string
+>['', "q", undefined] : string[]
+>undefined : undefined
+
+            <number>(this.voidIfAny([undefined, "q", ''][0]));
+><number>(this.voidIfAny([undefined, "q", ''][0])) : number
+>(this.voidIfAny([undefined, "q", ''][0])) : number
+>this.voidIfAny([undefined, "q", ''][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[undefined, "q", ''][0] : string
+>[undefined, "q", ''] : string[]
+>undefined : undefined
+
+            <number>(this.voidIfAny([null, "q", ''][0]));
+><number>(this.voidIfAny([null, "q", ''][0])) : number
+>(this.voidIfAny([null, "q", ''][0])) : number
+>this.voidIfAny([null, "q", ''][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[null, "q", ''][0] : string
+>[null, "q", ''] : string[]
+
+            <number>(this.voidIfAny(["q", '', null][0]));
+><number>(this.voidIfAny(["q", '', null][0])) : number
+>(this.voidIfAny(["q", '', null][0])) : number
+>this.voidIfAny(["q", '', null][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>["q", '', null][0] : string
+>["q", '', null] : string[]
+
+            <number>(this.voidIfAny([undefined, '', null][0]));
+><number>(this.voidIfAny([undefined, '', null][0])) : number
+>(this.voidIfAny([undefined, '', null][0])) : number
+>this.voidIfAny([undefined, '', null][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[undefined, '', null][0] : string
+>[undefined, '', null] : string[]
+>undefined : undefined
+
+            <number>(this.voidIfAny([[3, 4], [null]][0][0]));
+><number>(this.voidIfAny([[3, 4], [null]][0][0])) : number
+>(this.voidIfAny([[3, 4], [null]][0][0])) : number
+>this.voidIfAny([[3, 4], [null]][0][0]) : number
+>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>this : f
+>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
+>[[3, 4], [null]][0][0] : number
+>[[3, 4], [null]][0] : number[]
+>[[3, 4], [null]] : number[][]
+>[3, 4] : number[]
+>[null] : null[]
+
+
+            var t1: { x: number; y: base; }[] = [{ x: 7, y: new derived() }, { x: 5, y: new base() }];
+>t1 : { x: number; y: base; }[]
+>x : number
+>y : base
+>base : base
+>[{ x: 7, y: new derived() }, { x: 5, y: new base() }] : { x: number; y: base; }[]
+>{ x: 7, y: new derived() } : { x: number; y: derived; }
+>x : number
+>y : derived
+>new derived() : derived
+>derived : typeof derived
+>{ x: 5, y: new base() } : { x: number; y: base; }
+>x : number
+>y : base
+>new base() : base
+>base : typeof base
+
+            var t2: { x: boolean; y: base; }[] = [{ x: true, y: new derived() }, { x: false, y: new base() }];
+>t2 : { x: boolean; y: base; }[]
+>x : boolean
+>y : base
+>base : base
+>[{ x: true, y: new derived() }, { x: false, y: new base() }] : { x: boolean; y: base; }[]
+>{ x: true, y: new derived() } : { x: boolean; y: derived; }
+>x : boolean
+>y : derived
+>new derived() : derived
+>derived : typeof derived
+>{ x: false, y: new base() } : { x: boolean; y: base; }
+>x : boolean
+>y : base
+>new base() : base
+>base : typeof base
+
+            var t3: { x: string; y: base; }[] = [{ x: undefined, y: new base() }, { x: '', y: new derived() }];
+>t3 : { x: string; y: base; }[]
+>x : string
+>y : base
+>base : base
+>[{ x: undefined, y: new base() }, { x: '', y: new derived() }] : Array<{ x: undefined; y: base; } | { x: string; y: derived; }>
+>{ x: undefined, y: new base() } : { x: undefined; y: base; }
+>x : undefined
+>undefined : undefined
+>y : base
+>new base() : base
+>base : typeof base
+>{ x: '', y: new derived() } : { x: string; y: derived; }
+>x : string
+>y : derived
+>new derived() : derived
+>derived : typeof derived
+
+            var anyObj: any = null;
+>anyObj : any
+
+            // Order matters here so test all the variants
+            var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
+>a1 : { x: any; y: string; }[]
+>[{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }] : { x: any; y: string; }[]
+>{ x: 0, y: 'a' } : { x: number; y: string; }
+>x : number
+>y : string
+>{ x: 'a', y: 'a' } : { x: string; y: string; }
+>x : string
+>y : string
+>{ x: anyObj, y: 'a' } : { x: any; y: string; }
+>x : any
+>anyObj : any
+>y : string
+
+            var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
+>a2 : { x: any; y: string; }[]
+>[{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }] : { x: any; y: string; }[]
+>{ x: anyObj, y: 'a' } : { x: any; y: string; }
+>x : any
+>anyObj : any
+>y : string
+>{ x: 0, y: 'a' } : { x: number; y: string; }
+>x : number
+>y : string
+>{ x: 'a', y: 'a' } : { x: string; y: string; }
+>x : string
+>y : string
+
+            var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
+>a3 : { x: any; y: string; }[]
+>[{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }] : { x: any; y: string; }[]
+>{ x: 0, y: 'a' } : { x: number; y: string; }
+>x : number
+>y : string
+>{ x: anyObj, y: 'a' } : { x: any; y: string; }
+>x : any
+>anyObj : any
+>y : string
+>{ x: 'a', y: 'a' } : { x: string; y: string; }
+>x : string
+>y : string
+
+            var ifaceObj: iface = null;
+>ifaceObj : iface
+>iface : iface
+
+            var baseObj = new base();
+>baseObj : base
+>new base() : base
+>base : typeof base
+
+            var base2Obj = new base2();
+>base2Obj : base2
+>new base2() : base2
+>base2 : typeof base2
+
+            var b1 = [baseObj, base2Obj, ifaceObj];
+>b1 : iface[]
+>[baseObj, base2Obj, ifaceObj] : iface[]
+>baseObj : base
+>base2Obj : base2
+>ifaceObj : iface
+
+            var b2 = [base2Obj, baseObj, ifaceObj];
+>b2 : iface[]
+>[base2Obj, baseObj, ifaceObj] : iface[]
+>base2Obj : base2
+>baseObj : base
+>ifaceObj : iface
+
+            var b3 = [baseObj, ifaceObj, base2Obj];
+>b3 : iface[]
+>[baseObj, ifaceObj, base2Obj] : iface[]
+>baseObj : base
+>ifaceObj : iface
+>base2Obj : base2
+
+            var b4 = [ifaceObj, baseObj, base2Obj];
+>b4 : iface[]
+>[ifaceObj, baseObj, base2Obj] : iface[]
+>ifaceObj : iface
+>baseObj : base
+>base2Obj : base2
+        }
+    }
+}
 
 
diff --git a/tests/baselines/reference/arrayConcat2.types b/tests/baselines/reference/arrayConcat2.types
index a4036560305dd..4cd02d31f9d75 100644
--- a/tests/baselines/reference/arrayConcat2.types
+++ b/tests/baselines/reference/arrayConcat2.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/arrayConcat2.ts ===
 var a: string[] = [];
 >a : string[]
->[] : string[]
+>[] : undefined[]
 
 a.concat("hello", 'world');
 >a.concat("hello", 'world') : string[]
diff --git a/tests/baselines/reference/arrayLiteral.types b/tests/baselines/reference/arrayLiteral.types
index 1b356773dc747..9378a508228b6 100644
--- a/tests/baselines/reference/arrayLiteral.types
+++ b/tests/baselines/reference/arrayLiteral.types
@@ -25,7 +25,7 @@ var y = new Array<number>();
 
 var x2: number[] = [];
 >x2 : number[]
->[] : number[]
+>[] : undefined[]
 
 var x2: number[] = new Array(1);
 >x2 : number[]
diff --git a/tests/baselines/reference/arrayLiteralContextualType.errors.txt b/tests/baselines/reference/arrayLiteralContextualType.errors.txt
deleted file mode 100644
index 5f661647d9fc6..0000000000000
--- a/tests/baselines/reference/arrayLiteralContextualType.errors.txt
+++ /dev/null
@@ -1,40 +0,0 @@
-tests/cases/compiler/arrayLiteralContextualType.ts(28,5): error TS2345: Argument of type '{}[]' is not assignable to parameter of type 'IAnimal[]'.
-  Type '{}' is not assignable to type 'IAnimal'.
-tests/cases/compiler/arrayLiteralContextualType.ts(29,5): error TS2345: Argument of type '{}[]' is not assignable to parameter of type '{ [x: number]: IAnimal; }'.
-
-
-==== tests/cases/compiler/arrayLiteralContextualType.ts (2 errors) ====
-    interface IAnimal {
-        name: string;
-    }
-    
-    class Giraffe {
-        name = "Giraffe";
-        neckLength = "3m";
-    }
-    
-    class Elephant {
-        name = "Elephant";
-        trunkDiameter = "20cm";
-    }
-    
-    function foo(animals: IAnimal[]) { }
-    function bar(animals: { [n: number]: IAnimal }) { }
-    
-    foo([
-        new Giraffe(),
-        new Elephant()
-    ]); // Legal because of the contextual type IAnimal provided by the parameter
-    bar([
-        new Giraffe(),
-        new Elephant()
-    ]); // Legal because of the contextual type IAnimal provided by the parameter
-    
-    var arr = [new Giraffe(), new Elephant()];
-    foo(arr); // Error because of no contextual type
-        ~~~
-!!! error TS2345: Argument of type '{}[]' is not assignable to parameter of type 'IAnimal[]'.
-!!! error TS2345:   Type '{}' is not assignable to type 'IAnimal'.
-    bar(arr); // Error because of no contextual type
-        ~~~
-!!! error TS2345: Argument of type '{}[]' is not assignable to parameter of type '{ [x: number]: IAnimal; }'.
\ No newline at end of file
diff --git a/tests/baselines/reference/arrayLiteralContextualType.js b/tests/baselines/reference/arrayLiteralContextualType.js
index a551a754204b2..65e4c135cba8e 100644
--- a/tests/baselines/reference/arrayLiteralContextualType.js
+++ b/tests/baselines/reference/arrayLiteralContextualType.js
@@ -26,8 +26,8 @@ bar([
 ]); // Legal because of the contextual type IAnimal provided by the parameter
 
 var arr = [new Giraffe(), new Elephant()];
-foo(arr); // Error because of no contextual type
-bar(arr); // Error because of no contextual type
+foo(arr); // ok because arr is Array<Giraffe|Elephant> not {}[]
+bar(arr); // ok because arr is Array<Giraffe|Elephant> not {}[]
 
 //// [arrayLiteralContextualType.js]
 var Giraffe = (function () {
@@ -57,5 +57,5 @@ bar([
     new Elephant()
 ]); // Legal because of the contextual type IAnimal provided by the parameter
 var arr = [new Giraffe(), new Elephant()];
-foo(arr); // Error because of no contextual type
-bar(arr); // Error because of no contextual type
+foo(arr); // ok because arr is Array<Giraffe|Elephant> not {}[]
+bar(arr); // ok because arr is Array<Giraffe|Elephant> not {}[]
diff --git a/tests/baselines/reference/arrayLiteralContextualType.types b/tests/baselines/reference/arrayLiteralContextualType.types
new file mode 100644
index 0000000000000..12d08e986f781
--- /dev/null
+++ b/tests/baselines/reference/arrayLiteralContextualType.types
@@ -0,0 +1,86 @@
+=== tests/cases/compiler/arrayLiteralContextualType.ts ===
+interface IAnimal {
+>IAnimal : IAnimal
+
+    name: string;
+>name : string
+}
+
+class Giraffe {
+>Giraffe : Giraffe
+
+    name = "Giraffe";
+>name : string
+
+    neckLength = "3m";
+>neckLength : string
+}
+
+class Elephant {
+>Elephant : Elephant
+
+    name = "Elephant";
+>name : string
+
+    trunkDiameter = "20cm";
+>trunkDiameter : string
+}
+
+function foo(animals: IAnimal[]) { }
+>foo : (animals: IAnimal[]) => void
+>animals : IAnimal[]
+>IAnimal : IAnimal
+
+function bar(animals: { [n: number]: IAnimal }) { }
+>bar : (animals: { [x: number]: IAnimal; }) => void
+>animals : { [x: number]: IAnimal; }
+>n : number
+>IAnimal : IAnimal
+
+foo([
+>foo([    new Giraffe(),    new Elephant()]) : void
+>foo : (animals: IAnimal[]) => void
+>[    new Giraffe(),    new Elephant()] : Array<Giraffe | Elephant>
+
+    new Giraffe(),
+>new Giraffe() : Giraffe
+>Giraffe : typeof Giraffe
+
+    new Elephant()
+>new Elephant() : Elephant
+>Elephant : typeof Elephant
+
+]); // Legal because of the contextual type IAnimal provided by the parameter
+bar([
+>bar([    new Giraffe(),    new Elephant()]) : void
+>bar : (animals: { [x: number]: IAnimal; }) => void
+>[    new Giraffe(),    new Elephant()] : Array<Giraffe | Elephant>
+
+    new Giraffe(),
+>new Giraffe() : Giraffe
+>Giraffe : typeof Giraffe
+
+    new Elephant()
+>new Elephant() : Elephant
+>Elephant : typeof Elephant
+
+]); // Legal because of the contextual type IAnimal provided by the parameter
+
+var arr = [new Giraffe(), new Elephant()];
+>arr : Array<Giraffe | Elephant>
+>[new Giraffe(), new Elephant()] : Array<Giraffe | Elephant>
+>new Giraffe() : Giraffe
+>Giraffe : typeof Giraffe
+>new Elephant() : Elephant
+>Elephant : typeof Elephant
+
+foo(arr); // ok because arr is Array<Giraffe|Elephant> not {}[]
+>foo(arr) : void
+>foo : (animals: IAnimal[]) => void
+>arr : Array<Giraffe | Elephant>
+
+bar(arr); // ok because arr is Array<Giraffe|Elephant> not {}[]
+>bar(arr) : void
+>bar : (animals: { [x: number]: IAnimal; }) => void
+>arr : Array<Giraffe | Elephant>
+
diff --git a/tests/baselines/reference/arrayLiteralInNonVarArgParameter.types b/tests/baselines/reference/arrayLiteralInNonVarArgParameter.types
index c4889e223bb43..4743504c33e75 100644
--- a/tests/baselines/reference/arrayLiteralInNonVarArgParameter.types
+++ b/tests/baselines/reference/arrayLiteralInNonVarArgParameter.types
@@ -7,5 +7,5 @@ function panic(val: string[], ...opt: string[]) { }
 panic([], 'one', 'two');
 >panic([], 'one', 'two') : void
 >panic : (val: string[], ...opt: string[]) => void
->[] : string[]
+>[] : undefined[]
 
diff --git a/tests/baselines/reference/arrayLiteralTypeInference.types b/tests/baselines/reference/arrayLiteralTypeInference.types
index 5b4d9b7fff870..c80e5e170303a 100644
--- a/tests/baselines/reference/arrayLiteralTypeInference.types
+++ b/tests/baselines/reference/arrayLiteralTypeInference.types
@@ -25,7 +25,7 @@ class ActionB extends Action {
 var x1: Action[] = [
 >x1 : Action[]
 >Action : Action
->[    { id: 2, trueness: false },    { id: 3, name: "three" }] : Action[]
+>[    { id: 2, trueness: false },    { id: 3, name: "three" }] : Array<{ id: number; trueness: boolean; } | { id: number; name: string; }>
 
     { id: 2, trueness: false },
 >{ id: 2, trueness: false } : { id: number; trueness: boolean; }
@@ -42,7 +42,7 @@ var x1: Action[] = [
 var x2: Action[] = [
 >x2 : Action[]
 >Action : Action
->[    new ActionA(),    new ActionB()] : Action[]
+>[    new ActionA(),    new ActionB()] : Array<ActionA | ActionB>
 
     new ActionA(),
 >new ActionA() : ActionA
@@ -78,7 +78,7 @@ var z1: { id: number }[] =
 >id : number
 
     [
->[        { id: 2, trueness: false },        { id: 3, name: "three" }    ] : { id: number; }[]
+>[        { id: 2, trueness: false },        { id: 3, name: "three" }    ] : Array<{ id: number; trueness: boolean; } | { id: number; name: string; }>
 
         { id: 2, trueness: false },
 >{ id: 2, trueness: false } : { id: number; trueness: boolean; }
@@ -97,7 +97,7 @@ var z2: { id: number }[] =
 >id : number
 
     [
->[        new ActionA(),        new ActionB()    ] : { id: number; }[]
+>[        new ActionA(),        new ActionB()    ] : Array<ActionA | ActionB>
 
         new ActionA(),
 >new ActionA() : ActionA
@@ -114,7 +114,7 @@ var z3: { id: number }[] =
 >id : number
 
     [
->[        new Action(),        new ActionA(),        new ActionB()    ] : { id: number; }[]
+>[        new Action(),        new ActionA(),        new ActionB()    ] : Action[]
 
         new Action(),
 >new Action() : Action
diff --git a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types
index 7729b280160cb..49b65a86aa6c6 100644
--- a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types
+++ b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types
@@ -23,8 +23,8 @@ var as = [a, b]; // { x: number; y?: number };[]
 >b : { x: number; z?: number; }
 
 var bs = [b, a]; // { x: number; z?: number };[]
->bs : { x: number; z?: number; }[]
->[b, a] : { x: number; z?: number; }[]
+>bs : { x: number; y?: number; }[]
+>[b, a] : { x: number; y?: number; }[]
 >b : { x: number; z?: number; }
 >a : { x: number; y?: number; }
 
diff --git a/tests/baselines/reference/arrayLiterals.js b/tests/baselines/reference/arrayLiterals.js
index 800d2a1255035..16e5ec7eee4c1 100644
--- a/tests/baselines/reference/arrayLiterals.js
+++ b/tests/baselines/reference/arrayLiterals.js
@@ -2,28 +2,21 @@
 // Empty array literal with no contextual type has type Undefined[]
 
 var arr1= [[], [1], ['']];
-var arr1: {}[]; // Bug 825172: Error ({}[] does not match {}[]), but should be OK
 
 var arr2 = [[null], [1], ['']];
-var arr2: {}[]; // Bug 825172: Error ({}[] does not match {}[]), but should be OK
 
 
 // Array literal with elements of only EveryType E has type E[]
 var stringArrArr = [[''], [""]];
-var stringArrArr: string[][];
 
 var stringArr = ['', ""];
-var stringArr: string[];
 
 var numberArr = [0, 0.0, 0x00, 1e1];
-var numberArr: number[];
 
 var boolArr = [false, true, false, true];
-var boolArr: boolean[];
 
 class C { private p; }
 var classArr = [new C(), new C()];
-var classArr: C[]; // Should be OK
 
 var classTypeArray = [C, C, C];
 var classTypeArray: Array<typeof C>; // Should OK, not be a parse error
@@ -31,7 +24,6 @@ var classTypeArray: Array<typeof C>; // Should OK, not be a parse error
 // Contextual type C with numeric index signature makes array literal of EveryType E of type BCT(E,C)[]
 var context1: { [n: number]: { a: string; b: number; }; } = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
 var context2 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
-var context2: Array<{}>; // Should be OK
 
 // Contextual type C with numeric index signature of type Base makes array literal of Derived have type Base[]
 class Base { private p; }
@@ -53,31 +45,23 @@ var __extends = this.__extends || function (d, b) {
     d.prototype = new __();
 };
 var arr1 = [[], [1], ['']];
-var arr1; // Bug 825172: Error ({}[] does not match {}[]), but should be OK
 var arr2 = [[null], [1], ['']];
-var arr2; // Bug 825172: Error ({}[] does not match {}[]), but should be OK
 // Array literal with elements of only EveryType E has type E[]
 var stringArrArr = [[''], [""]];
-var stringArrArr;
 var stringArr = ['', ""];
-var stringArr;
 var numberArr = [0, 0.0, 0x00, 1e1];
-var numberArr;
 var boolArr = [false, true, false, true];
-var boolArr;
 var C = (function () {
     function C() {
     }
     return C;
 })();
 var classArr = [new C(), new C()];
-var classArr; // Should be OK
 var classTypeArray = [C, C, C];
 var classTypeArray; // Should OK, not be a parse error
 // Contextual type C with numeric index signature makes array literal of EveryType E of type BCT(E,C)[]
 var context1 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
 var context2 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
-var context2; // Should be OK
 // Contextual type C with numeric index signature of type Base makes array literal of Derived have type Base[]
 var Base = (function () {
     function Base() {
diff --git a/tests/baselines/reference/arrayLiterals.types b/tests/baselines/reference/arrayLiterals.types
index 29dd1b1997033..8c2fd942c62b6 100644
--- a/tests/baselines/reference/arrayLiterals.types
+++ b/tests/baselines/reference/arrayLiterals.types
@@ -2,25 +2,19 @@
 // Empty array literal with no contextual type has type Undefined[]
 
 var arr1= [[], [1], ['']];
->arr1 : {}[]
->[[], [1], ['']] : {}[]
+>arr1 : Array<string[] | number[]>
+>[[], [1], ['']] : Array<string[] | number[]>
 >[] : undefined[]
 >[1] : number[]
 >[''] : string[]
 
-var arr1: {}[]; // Bug 825172: Error ({}[] does not match {}[]), but should be OK
->arr1 : {}[]
-
 var arr2 = [[null], [1], ['']];
->arr2 : {}[]
->[[null], [1], ['']] : {}[]
+>arr2 : Array<string[] | number[]>
+>[[null], [1], ['']] : Array<string[] | number[]>
 >[null] : null[]
 >[1] : number[]
 >[''] : string[]
 
-var arr2: {}[]; // Bug 825172: Error ({}[] does not match {}[]), but should be OK
->arr2 : {}[]
-
 
 // Array literal with elements of only EveryType E has type E[]
 var stringArrArr = [[''], [""]];
@@ -29,30 +23,18 @@ var stringArrArr = [[''], [""]];
 >[''] : string[]
 >[""] : string[]
 
-var stringArrArr: string[][];
->stringArrArr : string[][]
-
 var stringArr = ['', ""];
 >stringArr : string[]
 >['', ""] : string[]
 
-var stringArr: string[];
->stringArr : string[]
-
 var numberArr = [0, 0.0, 0x00, 1e1];
 >numberArr : number[]
 >[0, 0.0, 0x00, 1e1] : number[]
 
-var numberArr: number[];
->numberArr : number[]
-
 var boolArr = [false, true, false, true];
 >boolArr : boolean[]
 >[false, true, false, true] : boolean[]
 
-var boolArr: boolean[];
->boolArr : boolean[]
-
 class C { private p; }
 >C : C
 >p : any
@@ -65,10 +47,6 @@ var classArr = [new C(), new C()];
 >new C() : C
 >C : typeof C
 
-var classArr: C[]; // Should be OK
->classArr : C[]
->C : C
-
 var classTypeArray = [C, C, C];
 >classTypeArray : typeof C[]
 >[C, C, C] : typeof C[]
@@ -87,7 +65,7 @@ var context1: { [n: number]: { a: string; b: number; }; } = [{ a: '', b: 0, c: '
 >n : number
 >a : string
 >b : number
->[{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }] : { a: string; b: number; }[]
+>[{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }] : Array<{ a: string; b: number; c: string; } | { a: string; b: number; c: number; }>
 >{ a: '', b: 0, c: '' } : { a: string; b: number; c: string; }
 >a : string
 >b : number
@@ -98,8 +76,8 @@ var context1: { [n: number]: { a: string; b: number; }; } = [{ a: '', b: 0, c: '
 >c : number
 
 var context2 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
->context2 : {}[]
->[{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }] : {}[]
+>context2 : Array<{ a: string; b: number; c: string; } | { a: string; b: number; c: number; }>
+>[{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }] : Array<{ a: string; b: number; c: string; } | { a: string; b: number; c: number; }>
 >{ a: '', b: 0, c: '' } : { a: string; b: number; c: string; }
 >a : string
 >b : number
@@ -109,10 +87,6 @@ var context2 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
 >b : number
 >c : number
 
-var context2: Array<{}>; // Should be OK
->context2 : {}[]
->Array : T[]
-
 // Contextual type C with numeric index signature of type Base makes array literal of Derived have type Base[]
 class Base { private p; }
 >Base : Base
@@ -131,7 +105,7 @@ class Derived2 extends Base { private n };
 var context3: Base[] = [new Derived1(), new Derived2()];
 >context3 : Base[]
 >Base : Base
->[new Derived1(), new Derived2()] : Base[]
+>[new Derived1(), new Derived2()] : Array<Derived1 | Derived2>
 >new Derived1() : Derived1
 >Derived1 : typeof Derived1
 >new Derived2() : Derived2
@@ -141,7 +115,7 @@ var context3: Base[] = [new Derived1(), new Derived2()];
 var context4: Base[] = [new Derived1(), new Derived1()];
 >context4 : Base[]
 >Base : Base
->[new Derived1(), new Derived1()] : Base[]
+>[new Derived1(), new Derived1()] : Derived1[]
 >new Derived1() : Derived1
 >Derived1 : typeof Derived1
 >new Derived1() : Derived1
diff --git a/tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types b/tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types
index becff7617b71c..e99ca18673e7f 100644
--- a/tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types
+++ b/tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types
@@ -61,8 +61,8 @@ var xs = [list, myList]; // {}[]
 >myList : MyList<number>
 
 var ys = [list, list2]; // {}[]
->ys : {}[]
->[list, list2] : {}[]
+>ys : Array<List<number> | List<string>>
+>[list, list2] : Array<List<number> | List<string>>
 >list : List<number>
 >list2 : List<string>
 
diff --git a/tests/baselines/reference/assignmentCompatBetweenTupleAndArray.errors.txt b/tests/baselines/reference/assignmentCompatBetweenTupleAndArray.errors.txt
index 38d89bdbd78ea..2395f2bf364d6 100644
--- a/tests/baselines/reference/assignmentCompatBetweenTupleAndArray.errors.txt
+++ b/tests/baselines/reference/assignmentCompatBetweenTupleAndArray.errors.txt
@@ -1,7 +1,8 @@
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatBetweenTupleAndArray.ts(17,1): error TS2322: Type '[number, string]' is not assignable to type 'number[]':
   Types of property 'pop' are incompatible:
-    Type '() => {}' is not assignable to type '() => number':
-      Type '{}' is not assignable to type 'number'.
+    Type '() => string | number' is not assignable to type '() => number':
+      Type 'string | number' is not assignable to type 'number':
+        Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatBetweenTupleAndArray.ts(18,1): error TS2322: Type '{}[]' is not assignable to type '[{}]':
   Property '0' is missing in type '{}[]'.
 
@@ -27,8 +28,9 @@ tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignme
     ~~~~~~~~
 !!! error TS2322: Type '[number, string]' is not assignable to type 'number[]':
 !!! error TS2322:   Types of property 'pop' are incompatible:
-!!! error TS2322:     Type '() => {}' is not assignable to type '() => number':
-!!! error TS2322:       Type '{}' is not assignable to type 'number'.
+!!! error TS2322:     Type '() => string | number' is not assignable to type '() => number':
+!!! error TS2322:       Type 'string | number' is not assignable to type 'number':
+!!! error TS2322:         Type 'string' is not assignable to type 'number'.
     emptyObjTuple = emptyObjArray;
     ~~~~~~~~~~~~~
 !!! error TS2322: Type '{}[]' is not assignable to type '[{}]':
diff --git a/tests/baselines/reference/badOverloadError.types b/tests/baselines/reference/badOverloadError.types
index 837eb5c5c839f..ba9d6e76c1c16 100644
--- a/tests/baselines/reference/badOverloadError.types
+++ b/tests/baselines/reference/badOverloadError.types
@@ -6,6 +6,6 @@ function method() {
 >dictionary : { [x: string]: string; }
 ><{ [index: string]: string; }>{} : { [x: string]: string; }
 >index : string
->{} : { [x: string]: string; }
+>{} : { [x: string]: undefined; }
 }
 
diff --git a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types
index 3deeae69bbed1..2c3ba8bc7c787 100644
--- a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types
+++ b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types
@@ -54,8 +54,8 @@ var r4 = true ? a : b; // typeof a
 >b : { x: number; z?: number; }
 
 var r5 = true ? b : a; // typeof b
->r5 : { x: number; z?: number; }
->true ? b : a : { x: number; z?: number; }
+>r5 : { x: number; y?: number; }
+>true ? b : a : { x: number; y?: number; }
 >b : { x: number; z?: number; }
 >a : { x: number; y?: number; }
 
@@ -72,7 +72,7 @@ var r7: (x: Object) => void = true ? (x: number) => { } : (x: Object) => { };
 >r7 : (x: Object) => void
 >x : Object
 >Object : Object
->true ? (x: number) => { } : (x: Object) => { } : (x: Object) => void
+>true ? (x: number) => { } : (x: Object) => { } : (x: number) => void
 >(x: number) => { } : (x: number) => void
 >x : number
 >(x: Object) => { } : (x: Object) => void
@@ -91,7 +91,7 @@ var r8 = true ? (x: Object) => { } : (x: number) => { }; // returns Object => vo
 var r10: Base = true ? derived : derived2; // no error since we use the contextual type in BCT
 >r10 : Base
 >Base : Base
->true ? derived : derived2 : Base
+>true ? derived : derived2 : Derived | Derived2
 >derived : Derived
 >derived2 : Derived2
 
@@ -112,7 +112,7 @@ function foo5<T, U>(t: T, u: U): Object {
 >Object : Object
 
     return true ? t : u; // BCT is Object
->true ? t : u : Object
+>true ? t : u : T | U
 >t : T
 >u : U
 }
diff --git a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions2.errors.txt b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions2.errors.txt
index 532a40becd9be..83f4678c8f3ae 100644
--- a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions2.errors.txt
+++ b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions2.errors.txt
@@ -1,14 +1,9 @@
-tests/cases/conformance/types/typeRelationships/bestCommonType/bestCommonTypeOfConditionalExpressions2.ts(11,10): error TS2367: No best common type exists between 'number' and 'string'.
-tests/cases/conformance/types/typeRelationships/bestCommonType/bestCommonTypeOfConditionalExpressions2.ts(12,10): error TS2367: No best common type exists between 'Derived' and 'Derived2'.
-tests/cases/conformance/types/typeRelationships/bestCommonType/bestCommonTypeOfConditionalExpressions2.ts(15,12): error TS2367: No best common type exists between 'T' and 'U'.
 tests/cases/conformance/types/typeRelationships/bestCommonType/bestCommonTypeOfConditionalExpressions2.ts(18,15): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
-tests/cases/conformance/types/typeRelationships/bestCommonType/bestCommonTypeOfConditionalExpressions2.ts(19,12): error TS2367: No best common type exists between 'T' and 'U'.
 tests/cases/conformance/types/typeRelationships/bestCommonType/bestCommonTypeOfConditionalExpressions2.ts(22,15): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
 tests/cases/conformance/types/typeRelationships/bestCommonType/bestCommonTypeOfConditionalExpressions2.ts(22,28): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
-tests/cases/conformance/types/typeRelationships/bestCommonType/bestCommonTypeOfConditionalExpressions2.ts(23,12): error TS2367: No best common type exists between 'T' and 'U'.
 
 
-==== tests/cases/conformance/types/typeRelationships/bestCommonType/bestCommonTypeOfConditionalExpressions2.ts (8 errors) ====
+==== tests/cases/conformance/types/typeRelationships/bestCommonType/bestCommonTypeOfConditionalExpressions2.ts (3 errors) ====
     // conditional expressions return the best common type of the branches plus contextual type (using the first candidate if multiple BCTs exist)
     // these are errors
     
@@ -20,24 +15,16 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/bestCommonTypeOfC
     var derived2: Derived2;
     
     var r2 = true ? 1 : '';
-             ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'number' and 'string'.
     var r9 = true ? derived : derived2;
-             ~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'Derived' and 'Derived2'.
     
     function foo<T, U>(t: T, u: U) {
         return true ? t : u;
-               ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'U'.
     }
     
     function foo2<T extends U, U>(t: T, u: U) { // Error for referencing own type parameter
                   ~~~~~~~~~~~
 !!! error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
         return true ? t : u; // Ok because BCT(T, U) = U
-               ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'U'.
     }
     
     function foo3<T extends U, U extends V, V>(t: T, u: U) {
@@ -46,6 +33,4 @@ tests/cases/conformance/types/typeRelationships/bestCommonType/bestCommonTypeOfC
                                ~~~~~~~~~~~
 !!! error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
         return true ? t : u;
-               ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'U'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/bestCommonTypeOfTuple.types b/tests/baselines/reference/bestCommonTypeOfTuple.types
index c8a3fb98a51a7..87624c267aa28 100644
--- a/tests/baselines/reference/bestCommonTypeOfTuple.types
+++ b/tests/baselines/reference/bestCommonTypeOfTuple.types
@@ -75,13 +75,13 @@ t4 = [E1.one, E2.two, 20];
 >two : E2
 
 var e1 = t1[2];  // {}
->e1 : {}
->t1[2] : {}
+>e1 : { (x: number): string; } | { (x: number): number; }
+>t1[2] : { (x: number): string; } | { (x: number): number; }
 >t1 : [(x: number) => string, (x: number) => number]
 
 var e2 = t2[2];  // {}
->e2 : {}
->t2[2] : {}
+>e2 : E1 | E2
+>t2[2] : E1 | E2
 >t2 : [E1, E2]
 
 var e3 = t3[2];  // any
diff --git a/tests/baselines/reference/bestCommonTypeOfTuple2.types b/tests/baselines/reference/bestCommonTypeOfTuple2.types
index 49d100ed94d07..a87407e98fc73 100644
--- a/tests/baselines/reference/bestCommonTypeOfTuple2.types
+++ b/tests/baselines/reference/bestCommonTypeOfTuple2.types
@@ -69,8 +69,8 @@ var e11 = t1[4]; // base
 >t1 : [C, base]
 
 var e21 = t2[4]; // {}
->e21 : {}
->t2[4] : {}
+>e21 : C | D
+>t2[4] : C | D
 >t2 : [C, D]
 
 var e31 = t3[4]; // C1
@@ -84,7 +84,7 @@ var e41 = t4[2]; // base1
 >t4 : [base1, C1]
 
 var e51 = t5[2]; // {}
->e51 : {}
->t5[2] : {}
+>e51 : F | C1
+>t5[2] : F | C1
 >t5 : [C1, F]
 
diff --git a/tests/baselines/reference/castingTuple.errors.txt b/tests/baselines/reference/castingTuple.errors.txt
index 333cd22caec9c..c3079699a809e 100644
--- a/tests/baselines/reference/castingTuple.errors.txt
+++ b/tests/baselines/reference/castingTuple.errors.txt
@@ -1,3 +1,7 @@
+tests/cases/conformance/types/tuple/castingTuple.ts(13,23): error TS2353: Neither type '[number, string]' nor type '[number, string, boolean]' is assignable to the other:
+  Property '2' is missing in type '[number, string]'.
+tests/cases/conformance/types/tuple/castingTuple.ts(16,21): error TS2353: Neither type '[C, D]' nor type '[C, D, A]' is assignable to the other:
+  Property '2' is missing in type '[C, D]'.
 tests/cases/conformance/types/tuple/castingTuple.ts(24,10): error TS2353: Neither type '[number, string]' nor type '[number, number]' is assignable to the other:
   Types of property '1' are incompatible:
     Type 'string' is not assignable to type 'number'.
@@ -8,12 +12,13 @@ tests/cases/conformance/types/tuple/castingTuple.ts(25,10): error TS2353: Neithe
 tests/cases/conformance/types/tuple/castingTuple.ts(26,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(26,14): error TS2353: Neither type '[number, string]' nor type 'number[]' is assignable to the other:
   Types of property 'pop' are incompatible:
-    Type '() => {}' is not assignable to type '() => number':
-      Type '{}' is not assignable to type 'number'.
+    Type '() => string | number' is not assignable to type '() => number':
+      Type 'string | number' is not assignable to type 'number':
+        Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/types/tuple/castingTuple.ts(27,1): error TS2304: Cannot find name 't4'.
 
 
-==== tests/cases/conformance/types/tuple/castingTuple.ts (5 errors) ====
+==== tests/cases/conformance/types/tuple/castingTuple.ts (7 errors) ====
     interface I { }
     class A { a = 10; }
     class C implements I { c };
@@ -27,9 +32,15 @@ tests/cases/conformance/types/tuple/castingTuple.ts(27,1): error TS2304: Cannot
     var numStrTuple: [number, string] = [5, "foo"];
     var emptyObjTuple = <[{}, {}]>numStrTuple;
     var numStrBoolTuple = <[number, string, boolean]>numStrTuple;
+                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2353: Neither type '[number, string]' nor type '[number, string, boolean]' is assignable to the other:
+!!! error TS2353:   Property '2' is missing in type '[number, string]'.
     var classCDTuple: [C, D] = [new C(), new D()];
     var interfaceIITuple = <[I, I]>classCDTuple;
     var classCDATuple = <[C, D, A]>classCDTuple;
+                        ~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2353: Neither type '[C, D]' nor type '[C, D, A]' is assignable to the other:
+!!! error TS2353:   Property '2' is missing in type '[C, D]'.
     var eleFromCDA1 = classCDATuple[2]; // A
     var eleFromCDA2 = classCDATuple[5]; // {}
     var t10: [E1, E2] = [E1.one, E2.one];
@@ -54,8 +65,9 @@ tests/cases/conformance/types/tuple/castingTuple.ts(27,1): error TS2304: Cannot
                  ~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2353: Neither type '[number, string]' nor type 'number[]' is assignable to the other:
 !!! error TS2353:   Types of property 'pop' are incompatible:
-!!! error TS2353:     Type '() => {}' is not assignable to type '() => number':
-!!! error TS2353:       Type '{}' is not assignable to type 'number'.
+!!! error TS2353:     Type '() => string | number' is not assignable to type '() => number':
+!!! error TS2353:       Type 'string | number' is not assignable to type 'number':
+!!! error TS2353:         Type 'string' is not assignable to type 'number'.
     t4[2] = 10;
     ~~
 !!! error TS2304: Cannot find name 't4'.
\ No newline at end of file
diff --git a/tests/baselines/reference/conditionalExpression1.errors.txt b/tests/baselines/reference/conditionalExpression1.errors.txt
index 542b660ba4238..30703c7169e9d 100644
--- a/tests/baselines/reference/conditionalExpression1.errors.txt
+++ b/tests/baselines/reference/conditionalExpression1.errors.txt
@@ -1,10 +1,9 @@
-tests/cases/compiler/conditionalExpression1.ts(1,5): error TS2323: Type '{}' is not assignable to type 'boolean'.
-tests/cases/compiler/conditionalExpression1.ts(1,19): error TS2367: No best common type exists between 'number' and 'string'.
+tests/cases/compiler/conditionalExpression1.ts(1,5): error TS2322: Type 'string | number' is not assignable to type 'boolean':
+  Type 'string' is not assignable to type 'boolean'.
 
 
-==== tests/cases/compiler/conditionalExpression1.ts (2 errors) ====
+==== tests/cases/compiler/conditionalExpression1.ts (1 errors) ====
     var x: boolean = (true ? 1 : ""); // should be an error
         ~
-!!! error TS2323: Type '{}' is not assignable to type 'boolean'.
-                      ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'number' and 'string'.
\ No newline at end of file
+!!! error TS2322: Type 'string | number' is not assignable to type 'boolean':
+!!! error TS2322:   Type 'string' is not assignable to type 'boolean'.
\ No newline at end of file
diff --git a/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.types b/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.types
index 8ad918936d2e0..edef88acfc306 100644
--- a/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.types
+++ b/tests/baselines/reference/conditionalOperatorWithIdenticalBCT.types
@@ -80,7 +80,7 @@ var result4: (t: A) => any = true ? (m) => m.propertyX : (n) => n.propertyA;
 >result4 : (t: A) => any
 >t : A
 >A : A
->true ? (m) => m.propertyX : (n) => n.propertyA : (t: A) => any
+>true ? (m) => m.propertyX : (n) => n.propertyA : (m: A) => any
 >(m) => m.propertyX : (m: A) => any
 >m : A
 >m.propertyX : any
@@ -144,7 +144,7 @@ var result8: (t: A) => any = true ? (m) => m.propertyA : (n) => n.propertyX;
 >result8 : (t: A) => any
 >t : A
 >A : A
->true ? (m) => m.propertyA : (n) => n.propertyX : (t: A) => any
+>true ? (m) => m.propertyA : (n) => n.propertyX : (n: A) => any
 >(m) => m.propertyA : (m: A) => number
 >m : A
 >m.propertyA : number
@@ -161,7 +161,7 @@ var result8: (t: A) => any = true ? (m) => m.propertyA : (n) => n.propertyX;
 var resultIsX3: X = true ? a : b;
 >resultIsX3 : X
 >X : X
->true ? a : b : X
+>true ? a : b : A | B
 >a : A
 >b : B
 
@@ -169,7 +169,7 @@ var result10: (t: X) => any = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
 >result10 : (t: X) => any
 >t : X
 >X : X
->true ? (m) => m.propertyX1 : (n) => n.propertyX2 : (t: X) => any
+>true ? (m) => m.propertyX1 : (n) => n.propertyX2 : { (m: X): number; } | { (n: X): string; }
 >(m) => m.propertyX1 : (m: X) => number
 >m : X
 >m.propertyX1 : number
@@ -184,5 +184,5 @@ var result10: (t: X) => any = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
 //Expr1 and Expr2 are literals
 var result11: any = true ? 1 : 'string';
 >result11 : any
->true ? 1 : 'string' : any
+>true ? 1 : 'string' : string | number
 
diff --git a/tests/baselines/reference/conditionalOperatorWithoutIdenticalBCT.errors.txt b/tests/baselines/reference/conditionalOperatorWithoutIdenticalBCT.errors.txt
index 7db921cbe1a1a..fb2c02d1c28d1 100644
--- a/tests/baselines/reference/conditionalOperatorWithoutIdenticalBCT.errors.txt
+++ b/tests/baselines/reference/conditionalOperatorWithoutIdenticalBCT.errors.txt
@@ -1,20 +1,21 @@
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(12,1): error TS2367: No best common type exists between 'A' and 'B'.
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(13,15): error TS2367: No best common type exists between 'A' and 'B'.
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(16,5): error TS2322: Type '{}' is not assignable to type 'A':
-  Property 'propertyA' is missing in type '{}'.
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(16,18): error TS2366: No best common type exists between 'A', 'A', and 'B'.
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(17,5): error TS2322: Type '{}' is not assignable to type 'B':
-  Property 'propertyB' is missing in type '{}'.
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(17,18): error TS2366: No best common type exists between 'B', 'A', and 'B'.
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(19,5): error TS2323: Type '{}' is not assignable to type '(t: X) => number'.
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(19,33): error TS2366: No best common type exists between '(t: X) => number', '(m: X) => number', and '(n: X) => string'.
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(20,5): error TS2323: Type '{}' is not assignable to type '(t: X) => string'.
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(20,33): error TS2366: No best common type exists between '(t: X) => string', '(m: X) => number', and '(n: X) => string'.
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(21,5): error TS2323: Type '{}' is not assignable to type '(t: X) => boolean'.
-tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(21,34): error TS2366: No best common type exists between '(t: X) => boolean', '(m: X) => number', and '(n: X) => string'.
+tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(15,5): error TS2322: Type 'A | B' is not assignable to type 'A':
+  Type 'B' is not assignable to type 'A':
+    Property 'propertyA' is missing in type 'B'.
+tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(16,5): error TS2322: Type 'A | B' is not assignable to type 'B':
+  Type 'A' is not assignable to type 'B':
+    Property 'propertyB' is missing in type 'A'.
+tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(18,5): error TS2322: Type '{ (m: X): number; } | { (n: X): string; }' is not assignable to type '(t: X) => number':
+  Type '(n: X) => string' is not assignable to type '(t: X) => number':
+    Type 'string' is not assignable to type 'number'.
+tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(19,5): error TS2322: Type '{ (m: X): number; } | { (n: X): string; }' is not assignable to type '(t: X) => string':
+  Type '(m: X) => number' is not assignable to type '(t: X) => string':
+    Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts(20,5): error TS2322: Type '{ (m: X): number; } | { (n: X): string; }' is not assignable to type '(t: X) => boolean':
+  Type '(m: X) => number' is not assignable to type '(t: X) => boolean':
+    Type 'number' is not assignable to type 'boolean'.
 
 
-==== tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts (12 errors) ====
+==== tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts (5 errors) ====
     //Cond ? Expr1 : Expr2,  Expr1 and Expr2 have no identical best common type
     class X { propertyX: any; propertyX1: number; propertyX2: string };
     class A extends X { propertyA: number };
@@ -24,41 +25,34 @@ tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithou
     var a: A;
     var b: B;
     
-    //Expect to have compiler errors
-    //Be not contextually typed
+    // No errors anymore, uses union types
     true ? a : b;
-    ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'A' and 'B'.
     var result1 = true ? a : b;
-                  ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'A' and 'B'.
     
-    //Be contextually typed and and bct is not identical
+    //Be contextually typed and and bct is not identical, results in errors that union type is not assignable to target
     var result2: A = true ? a : b;
         ~~~~~~~
-!!! error TS2322: Type '{}' is not assignable to type 'A':
-!!! error TS2322:   Property 'propertyA' is missing in type '{}'.
-                     ~~~~~~~~~~~~
-!!! error TS2366: No best common type exists between 'A', 'A', and 'B'.
+!!! error TS2322: Type 'A | B' is not assignable to type 'A':
+!!! error TS2322:   Type 'B' is not assignable to type 'A':
+!!! error TS2322:     Property 'propertyA' is missing in type 'B'.
     var result3: B = true ? a : b;
         ~~~~~~~
-!!! error TS2322: Type '{}' is not assignable to type 'B':
-!!! error TS2322:   Property 'propertyB' is missing in type '{}'.
-                     ~~~~~~~~~~~~
-!!! error TS2366: No best common type exists between 'B', 'A', and 'B'.
+!!! error TS2322: Type 'A | B' is not assignable to type 'B':
+!!! error TS2322:   Type 'A' is not assignable to type 'B':
+!!! error TS2322:     Property 'propertyB' is missing in type 'A'.
     
     var result4: (t: X) => number = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
         ~~~~~~~
-!!! error TS2323: Type '{}' is not assignable to type '(t: X) => number'.
-                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2366: No best common type exists between '(t: X) => number', '(m: X) => number', and '(n: X) => string'.
+!!! error TS2322: Type '{ (m: X): number; } | { (n: X): string; }' is not assignable to type '(t: X) => number':
+!!! error TS2322:   Type '(n: X) => string' is not assignable to type '(t: X) => number':
+!!! error TS2322:     Type 'string' is not assignable to type 'number'.
     var result5: (t: X) => string = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
         ~~~~~~~
-!!! error TS2323: Type '{}' is not assignable to type '(t: X) => string'.
-                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2366: No best common type exists between '(t: X) => string', '(m: X) => number', and '(n: X) => string'.
+!!! error TS2322: Type '{ (m: X): number; } | { (n: X): string; }' is not assignable to type '(t: X) => string':
+!!! error TS2322:   Type '(m: X) => number' is not assignable to type '(t: X) => string':
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.
     var result6: (t: X) => boolean = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
         ~~~~~~~
-!!! error TS2323: Type '{}' is not assignable to type '(t: X) => boolean'.
-                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2366: No best common type exists between '(t: X) => boolean', '(m: X) => number', and '(n: X) => string'.
\ No newline at end of file
+!!! error TS2322: Type '{ (m: X): number; } | { (n: X): string; }' is not assignable to type '(t: X) => boolean':
+!!! error TS2322:   Type '(m: X) => number' is not assignable to type '(t: X) => boolean':
+!!! error TS2322:     Type 'number' is not assignable to type 'boolean'.
\ No newline at end of file
diff --git a/tests/baselines/reference/conditionalOperatorWithoutIdenticalBCT.js b/tests/baselines/reference/conditionalOperatorWithoutIdenticalBCT.js
index 90125d4ebf6d2..b6376dd781fdf 100644
--- a/tests/baselines/reference/conditionalOperatorWithoutIdenticalBCT.js
+++ b/tests/baselines/reference/conditionalOperatorWithoutIdenticalBCT.js
@@ -8,12 +8,11 @@ var x: X;
 var a: A;
 var b: B;
 
-//Expect to have compiler errors
-//Be not contextually typed
+// No errors anymore, uses union types
 true ? a : b;
 var result1 = true ? a : b;
 
-//Be contextually typed and and bct is not identical
+//Be contextually typed and and bct is not identical, results in errors that union type is not assignable to target
 var result2: A = true ? a : b;
 var result3: B = true ? a : b;
 
@@ -54,11 +53,10 @@ var B = (function (_super) {
 var x;
 var a;
 var b;
-//Expect to have compiler errors
-//Be not contextually typed
+// No errors anymore, uses union types
 true ? a : b;
 var result1 = true ? a : b;
-//Be contextually typed and and bct is not identical
+//Be contextually typed and and bct is not identical, results in errors that union type is not assignable to target
 var result2 = true ? a : b;
 var result3 = true ? a : b;
 var result4 = true ? function (m) { return m.propertyX1; } : function (n) { return n.propertyX2; };
diff --git a/tests/baselines/reference/contextualTypeArrayReturnType.types b/tests/baselines/reference/contextualTypeArrayReturnType.types
index b0cd03f8510ae..ceb7aa53f67be 100644
--- a/tests/baselines/reference/contextualTypeArrayReturnType.types
+++ b/tests/baselines/reference/contextualTypeArrayReturnType.types
@@ -26,18 +26,18 @@ interface Transform3D {
 var style: IBookStyle = {
 >style : IBookStyle
 >IBookStyle : IBookStyle
->{    initialLeftPageTransforms: (width: number) => {        return [            {'ry': null }        ];    }} : { initialLeftPageTransforms: (width: number) => NamedTransform[]; }
+>{    initialLeftPageTransforms: (width: number) => {        return [            {'ry': null }        ];    }} : { initialLeftPageTransforms: (width: number) => { [x: string]: any; 'ry': any; }[]; }
 
     initialLeftPageTransforms: (width: number) => {
->initialLeftPageTransforms : (width: number) => NamedTransform[]
->(width: number) => {        return [            {'ry': null }        ];    } : (width: number) => NamedTransform[]
+>initialLeftPageTransforms : (width: number) => { [x: string]: any; 'ry': any; }[]
+>(width: number) => {        return [            {'ry': null }        ];    } : (width: number) => { [x: string]: any; 'ry': any; }[]
 >width : number
 
         return [
->[            {'ry': null }        ] : NamedTransform[]
+>[            {'ry': null }        ] : { [x: string]: null; 'ry': null; }[]
 
             {'ry': null }
->{'ry': null } : { [x: string]: Transform3D; 'ry': null; }
+>{'ry': null } : { [x: string]: null; 'ry': null; }
 
         ];
     }
diff --git a/tests/baselines/reference/contextualTypeWithTuple.errors.txt b/tests/baselines/reference/contextualTypeWithTuple.errors.txt
index f2f77277c5ec1..bd1aa15566102 100644
--- a/tests/baselines/reference/contextualTypeWithTuple.errors.txt
+++ b/tests/baselines/reference/contextualTypeWithTuple.errors.txt
@@ -1,3 +1,10 @@
+tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(3,5): error TS2322: Type '[number, string, boolean]' is not assignable to type '[number, string]':
+  Types of property 'pop' are incompatible:
+    Type '() => string | number | boolean' is not assignable to type '() => string | number':
+      Type 'string | number | boolean' is not assignable to type 'string | number':
+        Type 'boolean' is not assignable to type 'string | number':
+          Type 'boolean' is not assignable to type 'number'.
+tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(8,1): error TS2323: Type '[number, string, boolean]' is not assignable to type '[number, string]'.
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(11,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; }':
@@ -6,19 +13,29 @@ tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(12,1): error TS23
   Property '2' is missing in type '[number, string]'.
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(13,5): error TS2322: Type '[string, string, number]' is not assignable to type '[string, string]':
   Types of property 'pop' are incompatible:
-    Type '() => {}' is not assignable to type '() => string':
-      Type '{}' is not assignable to type 'string'.
+    Type '() => string | 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 (3 errors) ====
+==== tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts (5 errors) ====
     // no error
     var numStrTuple: [number, string] = [5, "hello"];
     var numStrTuple2: [number, string] = [5, "foo", true];
+        ~~~~~~~~~~~~
+!!! error TS2322: Type '[number, string, boolean]' is not assignable to type '[number, string]':
+!!! error TS2322:   Types of property 'pop' are incompatible:
+!!! error TS2322:     Type '() => string | number | boolean' is not assignable to type '() => string | number':
+!!! error TS2322:       Type 'string | number | boolean' is not assignable to type 'string | number':
+!!! error TS2322:         Type 'boolean' is not assignable to type 'string | number':
+!!! error TS2322:           Type 'boolean' is not assignable to type 'number'.
     var numStrBoolTuple: [number, string, boolean] = [5, "foo", true];
     var objNumTuple: [{ a: string }, number] = [{ a: "world" }, 5];
     var strTupleTuple: [string, [number, {}]] = ["bar", [5, { x: 1, y: 1 }]];
     numStrTuple = numStrTuple2;
     numStrTuple = numStrBoolTuple;
+    ~~~~~~~~~~~
+!!! error TS2323: Type '[number, string, boolean]' is not assignable to type '[number, string]'.
     
     // error
     objNumTuple = [ {}, 5];
@@ -35,6 +52,7 @@ tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(13,5): error TS23
         ~~~~~~~~~~~
 !!! error TS2322: Type '[string, string, number]' is not assignable to type '[string, string]':
 !!! error TS2322:   Types of property 'pop' are incompatible:
-!!! error TS2322:     Type '() => {}' is not assignable to type '() => string':
-!!! error TS2322:       Type '{}' is not assignable to type 'string'.
+!!! error TS2322:     Type '() => string | number' is not assignable to type '() => string':
+!!! error TS2322:       Type 'string | number' is not assignable to type 'string':
+!!! error TS2322:         Type 'number' is not assignable to type 'string'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/contextualTyping21.errors.txt b/tests/baselines/reference/contextualTyping21.errors.txt
index 999cfcbd7691a..620b0635d1210 100644
--- a/tests/baselines/reference/contextualTyping21.errors.txt
+++ b/tests/baselines/reference/contextualTyping21.errors.txt
@@ -1,11 +1,13 @@
-tests/cases/compiler/contextualTyping21.ts(1,36): error TS2322: Type '{}[]' is not assignable to type '{ id: number; }[]':
-  Type '{}' is not assignable to type '{ id: number; }':
-    Property 'id' is missing in type '{}'.
+tests/cases/compiler/contextualTyping21.ts(1,36): error TS2322: Type 'Array<number | { id: number; }>' is not assignable to type '{ id: number; }[]':
+  Type 'number | { id: number; }' is not assignable to type '{ id: number; }':
+    Type 'number' is not assignable to type '{ id: number; }':
+      Property 'id' is missing in type 'Number'.
 
 
 ==== tests/cases/compiler/contextualTyping21.ts (1 errors) ====
     var foo:{id:number;}[] = [{id:1}]; foo = [{id:1}, 1];
                                        ~~~
-!!! error TS2322: Type '{}[]' is not assignable to type '{ id: number; }[]':
-!!! error TS2322:   Type '{}' is not assignable to type '{ id: number; }':
-!!! error TS2322:     Property 'id' is missing in type '{}'.
\ No newline at end of file
+!!! error TS2322: Type 'Array<number | { id: number; }>' is not assignable to type '{ id: number; }[]':
+!!! error TS2322:   Type 'number | { id: number; }' is not assignable to type '{ id: number; }':
+!!! error TS2322:     Type 'number' is not assignable to type '{ id: number; }':
+!!! error TS2322:       Property 'id' is missing in type 'Number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/contextualTyping30.errors.txt b/tests/baselines/reference/contextualTyping30.errors.txt
index 3b2fbc8aac697..4c8d87d41b6a3 100644
--- a/tests/baselines/reference/contextualTyping30.errors.txt
+++ b/tests/baselines/reference/contextualTyping30.errors.txt
@@ -1,9 +1,11 @@
-tests/cases/compiler/contextualTyping30.ts(1,37): error TS2345: Argument of type '{}[]' is not assignable to parameter of type 'number[]'.
-  Type '{}' is not assignable to type 'number'.
+tests/cases/compiler/contextualTyping30.ts(1,37): error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+  Type 'string | number' is not assignable to type 'number':
+    Type 'string' is not assignable to type 'number'.
 
 
 ==== tests/cases/compiler/contextualTyping30.ts (1 errors) ====
     function foo(param:number[]){}; foo([1, "a"]);
                                         ~~~~~~~~
-!!! error TS2345: Argument of type '{}[]' is not assignable to parameter of type 'number[]'.
-!!! error TS2345:   Type '{}' is not assignable to type 'number'.
\ No newline at end of file
+!!! error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+!!! error TS2345:   Type 'string | number' is not assignable to type 'number':
+!!! error TS2345:     Type 'string' is not assignable to type 'number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/contextualTyping32.types b/tests/baselines/reference/contextualTyping32.types
index a9d41405b9312..383615aec3c60 100644
--- a/tests/baselines/reference/contextualTyping32.types
+++ b/tests/baselines/reference/contextualTyping32.types
@@ -5,7 +5,7 @@ function foo(param: {():number; (i:number):number; }[]) { }; foo([function(){ret
 >i : number
 >foo([function(){return 1;}, function(){return 4}]) : void
 >foo : (param: { (): number; (i: number): number; }[]) => void
->[function(){return 1;}, function(){return 4}] : { (): number; (i: number): number; }[]
+>[function(){return 1;}, function(){return 4}] : { (): number; }[]
 >function(){return 1;} : () => number
 >function(){return 4} : () => number
 
diff --git a/tests/baselines/reference/contextualTyping33.errors.txt b/tests/baselines/reference/contextualTyping33.errors.txt
index 8f83fc37ab1e4..82799037ec6fe 100644
--- a/tests/baselines/reference/contextualTyping33.errors.txt
+++ b/tests/baselines/reference/contextualTyping33.errors.txt
@@ -1,9 +1,11 @@
-tests/cases/compiler/contextualTyping33.ts(1,66): error TS2345: Argument of type '{}[]' is not assignable to parameter of type '{ (): number; (i: number): number; }[]'.
-  Type '{}' is not assignable to type '{ (): number; (i: number): number; }'.
+tests/cases/compiler/contextualTyping33.ts(1,66): error TS2345: Argument of type 'Array<{ (): number; } | { (): string; }>' is not assignable to parameter of type '{ (): number; (i: number): number; }[]'.
+  Type '{ (): number; } | { (): string; }' is not assignable to type '{ (): number; (i: number): number; }':
+    Type '() => string' is not assignable to type '{ (): number; (i: number): number; }'.
 
 
 ==== tests/cases/compiler/contextualTyping33.ts (1 errors) ====
     function foo(param: {():number; (i:number):number; }[]) { }; foo([function(){return 1;}, function(){return "foo"}]);
                                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2345: Argument of type '{}[]' is not assignable to parameter of type '{ (): number; (i: number): number; }[]'.
-!!! error TS2345:   Type '{}' is not assignable to type '{ (): number; (i: number): number; }'.
\ No newline at end of file
+!!! error TS2345: Argument of type 'Array<{ (): number; } | { (): string; }>' is not assignable to parameter of type '{ (): number; (i: number): number; }[]'.
+!!! error TS2345:   Type '{ (): number; } | { (): string; }' is not assignable to type '{ (): number; (i: number): number; }':
+!!! error TS2345:     Type '() => string' is not assignable to type '{ (): number; (i: number): number; }'.
\ No newline at end of file
diff --git a/tests/baselines/reference/contextualTypingOfArrayLiterals1.errors.txt b/tests/baselines/reference/contextualTypingOfArrayLiterals1.errors.txt
index 0f9fc64536b24..cb3b439681ea2 100644
--- a/tests/baselines/reference/contextualTypingOfArrayLiterals1.errors.txt
+++ b/tests/baselines/reference/contextualTypingOfArrayLiterals1.errors.txt
@@ -1,7 +1,8 @@
-tests/cases/compiler/contextualTypingOfArrayLiterals1.ts(5,5): error TS2322: Type '{}[]' is not assignable to type 'I':
+tests/cases/compiler/contextualTypingOfArrayLiterals1.ts(5,5): error TS2322: Type 'Array<number | Date>' is not assignable to type 'I':
   Index signatures are incompatible:
-    Type '{}' is not assignable to type 'Date':
-      Property 'toDateString' is missing in type '{}'.
+    Type 'number | Date' is not assignable to type 'Date':
+      Type 'number' is not assignable to type 'Date':
+        Property 'toDateString' is missing in type 'Number'.
 
 
 ==== tests/cases/compiler/contextualTypingOfArrayLiterals1.ts (1 errors) ====
@@ -11,10 +12,11 @@ tests/cases/compiler/contextualTypingOfArrayLiterals1.ts(5,5): error TS2322: Typ
     
     var x3: I = [new Date(), 1]; 
         ~~
-!!! error TS2322: Type '{}[]' is not assignable to type 'I':
+!!! error TS2322: Type 'Array<number | Date>' is not assignable to type 'I':
 !!! error TS2322:   Index signatures are incompatible:
-!!! error TS2322:     Type '{}' is not assignable to type 'Date':
-!!! error TS2322:       Property 'toDateString' is missing in type '{}'.
+!!! error TS2322:     Type 'number | Date' is not assignable to type 'Date':
+!!! error TS2322:       Type 'number' is not assignable to type 'Date':
+!!! error TS2322:         Property 'toDateString' is missing in type 'Number'.
     var r2 = x3[1]; 
     r2.getDate(); 
     
\ No newline at end of file
diff --git a/tests/baselines/reference/contextualTypingOfConditionalExpression.types b/tests/baselines/reference/contextualTypingOfConditionalExpression.types
index 6c6f9b04457ad..2cd2b671b4054 100644
--- a/tests/baselines/reference/contextualTypingOfConditionalExpression.types
+++ b/tests/baselines/reference/contextualTypingOfConditionalExpression.types
@@ -2,7 +2,7 @@
 var x: (a: number) => void = true ? (a) => a.toExponential() : (b) => b.toFixed();
 >x : (a: number) => void
 >a : number
->true ? (a) => a.toExponential() : (b) => b.toFixed() : (a: number) => void
+>true ? (a) => a.toExponential() : (b) => b.toFixed() : (a: number) => string
 >(a) => a.toExponential() : (a: number) => string
 >a : number
 >a.toExponential() : string
@@ -41,7 +41,7 @@ var x2: (a: A) => void = true ? (a) => a.foo : (b) => b.foo;
 >x2 : (a: A) => void
 >a : A
 >A : A
->true ? (a) => a.foo : (b) => b.foo : (a: A) => void
+>true ? (a) => a.foo : (b) => b.foo : (a: A) => number
 >(a) => a.foo : (a: A) => number
 >a : A
 >a.foo : number
diff --git a/tests/baselines/reference/contextualTypingOfConditionalExpression2.errors.txt b/tests/baselines/reference/contextualTypingOfConditionalExpression2.errors.txt
index c433bd1d8ca98..574e25c6f4551 100644
--- a/tests/baselines/reference/contextualTypingOfConditionalExpression2.errors.txt
+++ b/tests/baselines/reference/contextualTypingOfConditionalExpression2.errors.txt
@@ -1,8 +1,11 @@
-tests/cases/compiler/contextualTypingOfConditionalExpression2.ts(11,5): error TS2323: Type '{}' is not assignable to type '(a: A) => void'.
-tests/cases/compiler/contextualTypingOfConditionalExpression2.ts(11,26): error TS2366: No best common type exists between '(a: A) => void', '(a: C) => number', and '(b: number) => void'.
+tests/cases/compiler/contextualTypingOfConditionalExpression2.ts(11,5): error TS2322: Type '{ (a: C): number; } | { (b: number): void; }' is not assignable to type '(a: A) => void':
+  Type '(b: number) => void' is not assignable to type '(a: A) => void':
+    Types of parameters 'b' and 'a' are incompatible:
+      Type 'number' is not assignable to type 'A':
+        Property 'foo' is missing in type 'Number'.
 
 
-==== tests/cases/compiler/contextualTypingOfConditionalExpression2.ts (2 errors) ====
+==== tests/cases/compiler/contextualTypingOfConditionalExpression2.ts (1 errors) ====
     class A {
         foo: number;
     }
@@ -15,7 +18,9 @@ tests/cases/compiler/contextualTypingOfConditionalExpression2.ts(11,26): error T
     
     var x2: (a: A) => void = true ? (a: C) => a.foo : (b: number) => { };
         ~~
-!!! error TS2323: Type '{}' is not assignable to type '(a: A) => void'.
-                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2366: No best common type exists between '(a: A) => void', '(a: C) => number', and '(b: number) => void'.
+!!! error TS2322: Type '{ (a: C): number; } | { (b: number): void; }' is not assignable to type '(a: A) => void':
+!!! error TS2322:   Type '(b: number) => void' is not assignable to type '(a: A) => void':
+!!! error TS2322:     Types of parameters 'b' and 'a' are incompatible:
+!!! error TS2322:       Type 'number' is not assignable to type 'A':
+!!! error TS2322:         Property 'foo' is missing in type 'Number'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/contextualTypingWithFixedTypeParameters1.errors.txt b/tests/baselines/reference/contextualTypingWithFixedTypeParameters1.errors.txt
index e4d8a82c47ef0..a524fd3be313f 100644
--- a/tests/baselines/reference/contextualTypingWithFixedTypeParameters1.errors.txt
+++ b/tests/baselines/reference/contextualTypingWithFixedTypeParameters1.errors.txt
@@ -1,9 +1,12 @@
 tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts(2,22): error TS2339: Property 'foo' does not exist on type 'string'.
+tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts(3,10): error TS2346: Supplied parameters do not match any signature of call target.
 
 
-==== tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts (1 errors) ====
+==== tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts (2 errors) ====
     var f10: <T>(x: T, b: () => (a: T) => void, y: T) => T;
-    f10('', () => a => a.foo, ''); // a is string, fixed by first parameter
+    f10('', () => a => a.foo, ''); // a is string
                          ~~~
 !!! error TS2339: Property 'foo' does not exist on type 'string'.
-    var r9 = f10('', () => (a => a.foo), 1); // now a should be any
\ No newline at end of file
+    var r9 = f10('', () => (a => a.foo), 1); // error
+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
\ No newline at end of file
diff --git a/tests/baselines/reference/contextualTypingWithFixedTypeParameters1.js b/tests/baselines/reference/contextualTypingWithFixedTypeParameters1.js
index cf7274db8a031..55f7580b3f880 100644
--- a/tests/baselines/reference/contextualTypingWithFixedTypeParameters1.js
+++ b/tests/baselines/reference/contextualTypingWithFixedTypeParameters1.js
@@ -1,9 +1,9 @@
 //// [contextualTypingWithFixedTypeParameters1.ts]
 var f10: <T>(x: T, b: () => (a: T) => void, y: T) => T;
-f10('', () => a => a.foo, ''); // a is string, fixed by first parameter
-var r9 = f10('', () => (a => a.foo), 1); // now a should be any
+f10('', () => a => a.foo, ''); // a is string
+var r9 = f10('', () => (a => a.foo), 1); // error
 
 //// [contextualTypingWithFixedTypeParameters1.js]
 var f10;
-f10('', function () { return function (a) { return a.foo; }; }, ''); // a is string, fixed by first parameter
-var r9 = f10('', function () { return (function (a) { return a.foo; }); }, 1); // now a should be any
+f10('', function () { return function (a) { return a.foo; }; }, ''); // a is string
+var r9 = f10('', function () { return (function (a) { return a.foo; }); }, 1); // error
diff --git a/tests/baselines/reference/contextuallyTypingOrOperator.types b/tests/baselines/reference/contextuallyTypingOrOperator.types
index ee1ac4b0bba04..4b47ea763bcf4 100644
--- a/tests/baselines/reference/contextuallyTypingOrOperator.types
+++ b/tests/baselines/reference/contextuallyTypingOrOperator.types
@@ -3,7 +3,7 @@ var v: { a: (_: string) => number } = { a: s => s.length } || { a: s => 1 };
 >v : { a: (_: string) => number; }
 >a : (_: string) => number
 >_ : string
->{ a: s => s.length } || { a: s => 1 } : { a: (_: string) => number; }
+>{ a: s => s.length } || { a: s => 1 } : { a: (s: string) => number; }
 >{ a: s => s.length } : { a: (s: string) => number; }
 >a : (s: string) => number
 >s => s.length : (s: string) => number
@@ -17,10 +17,10 @@ var v: { a: (_: string) => number } = { a: s => s.length } || { a: s => 1 };
 >s : string
 
 var v2 = (s: string) => s.length || function (s) { s.length };
->v2 : (s: string) => {}
->(s: string) => s.length || function (s) { s.length } : (s: string) => {}
+>v2 : (s: string) => number | { (s: any): void; }
+>(s: string) => s.length || function (s) { s.length } : (s: string) => number | { (s: any): void; }
 >s : string
->s.length || function (s) { s.length } : {}
+>s.length || function (s) { s.length } : number | { (s: any): void; }
 >s.length : number
 >s : string
 >length : number
@@ -31,10 +31,10 @@ var v2 = (s: string) => s.length || function (s) { s.length };
 >length : any
 
 var v3 = (s: string) => s.length || function (s: number) { return 1 };
->v3 : (s: string) => {}
->(s: string) => s.length || function (s: number) { return 1 } : (s: string) => {}
+>v3 : (s: string) => number | { (s: number): number; }
+>(s: string) => s.length || function (s: number) { return 1 } : (s: string) => number | { (s: number): number; }
 >s : string
->s.length || function (s: number) { return 1 } : {}
+>s.length || function (s: number) { return 1 } : number | { (s: number): number; }
 >s.length : number
 >s : string
 >length : number
@@ -42,10 +42,10 @@ var v3 = (s: string) => s.length || function (s: number) { return 1 };
 >s : number
 
 var v4 = (s: number) => 1 || function (s: string) { return s.length };
->v4 : (s: number) => {}
->(s: number) => 1 || function (s: string) { return s.length } : (s: number) => {}
+>v4 : (s: number) => number | { (s: string): number; }
+>(s: number) => 1 || function (s: string) { return s.length } : (s: number) => number | { (s: string): number; }
 >s : number
->1 || function (s: string) { return s.length } : {}
+>1 || function (s: string) { return s.length } : number | { (s: string): number; }
 >function (s: string) { return s.length } : (s: string) => number
 >s : string
 >s.length : number
diff --git a/tests/baselines/reference/contextuallyTypingOrOperator2.types b/tests/baselines/reference/contextuallyTypingOrOperator2.types
index 57c9992436d0f..c233066d6dcc4 100644
--- a/tests/baselines/reference/contextuallyTypingOrOperator2.types
+++ b/tests/baselines/reference/contextuallyTypingOrOperator2.types
@@ -3,7 +3,7 @@ var v: { a: (_: string) => number } = { a: s => s.length } || { a: s => 1 };
 >v : { a: (_: string) => number; }
 >a : (_: string) => number
 >_ : string
->{ a: s => s.length } || { a: s => 1 } : { a: (_: string) => number; }
+>{ a: s => s.length } || { a: s => 1 } : { a: (s: string) => number; }
 >{ a: s => s.length } : { a: (s: string) => number; }
 >a : (s: string) => number
 >s => s.length : (s: string) => number
@@ -17,10 +17,10 @@ var v: { a: (_: string) => number } = { a: s => s.length } || { a: s => 1 };
 >s : string
 
 var v2 = (s: string) => s.length || function (s) { s.aaa };
->v2 : (s: string) => {}
->(s: string) => s.length || function (s) { s.aaa } : (s: string) => {}
+>v2 : (s: string) => number | { (s: any): void; }
+>(s: string) => s.length || function (s) { s.aaa } : (s: string) => number | { (s: any): void; }
 >s : string
->s.length || function (s) { s.aaa } : {}
+>s.length || function (s) { s.aaa } : number | { (s: any): void; }
 >s.length : number
 >s : string
 >length : number
diff --git a/tests/baselines/reference/declFileGenericType2.types b/tests/baselines/reference/declFileGenericType2.types
index a6b6546326ca3..f9345b5ff114c 100644
--- a/tests/baselines/reference/declFileGenericType2.types
+++ b/tests/baselines/reference/declFileGenericType2.types
@@ -131,11 +131,11 @@ module templa.dom.mvc.composite {
 >super : typeof AbstractElementController
 
             this._controllers = [];
->this._controllers = [] : templa.mvc.IController<templa.mvc.IModel>[]
+>this._controllers = [] : undefined[]
 >this._controllers : templa.mvc.IController<templa.mvc.IModel>[]
 >this : AbstractCompositeElementController<ModelType>
 >_controllers : templa.mvc.IController<templa.mvc.IModel>[]
->[] : templa.mvc.IController<templa.mvc.IModel>[]
+>[] : undefined[]
         }
     }
 }
diff --git a/tests/baselines/reference/decrementOperatorWithAnyOtherType.types b/tests/baselines/reference/decrementOperatorWithAnyOtherType.types
index 4e8387f906638..ab21dd9db5cf8 100644
--- a/tests/baselines/reference/decrementOperatorWithAnyOtherType.types
+++ b/tests/baselines/reference/decrementOperatorWithAnyOtherType.types
@@ -9,7 +9,7 @@ var ANY1;
 
 var ANY2: any[] = ["", ""];
 >ANY2 : any[]
->["", ""] : any[]
+>["", ""] : string[]
 
 var obj = {x:1,y:null};
 >obj : { x: number; y: any; }
diff --git a/tests/baselines/reference/decrementOperatorWithEnumType.errors.txt b/tests/baselines/reference/decrementOperatorWithEnumType.errors.txt
index d43515e84ef6e..a0c30e9dc93fa 100644
--- a/tests/baselines/reference/decrementOperatorWithEnumType.errors.txt
+++ b/tests/baselines/reference/decrementOperatorWithEnumType.errors.txt
@@ -1,24 +1,24 @@
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(7,23): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(12,1): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(12,7): error TS2304: Cannot find name 'A'.
-
-
-==== tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts (3 errors) ====
-    // -- operator on enum type
-    
-    enum ENUM1 { A, B, "" };
-    
-    // expression
-    var ResultIsNumber1 = --ENUM1["A"];
-    var ResultIsNumber2 = ENUM1.A--;
-                          ~~~~~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-    
-    // miss assignment operator
-    --ENUM1["A"];
-    
-    ENUM1[A]--;
-    ~~~~~~~~
-!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
-          ~
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(7,23): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(12,1): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(12,7): error TS2304: Cannot find name 'A'.
+
+
+==== tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts (3 errors) ====
+    // -- operator on enum type
+    
+    enum ENUM1 { A, B, "" };
+    
+    // expression
+    var ResultIsNumber1 = --ENUM1["A"];
+    var ResultIsNumber2 = ENUM1.A--;
+                          ~~~~~~~
+!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+    
+    // miss assignment operator
+    --ENUM1["A"];
+    
+    ENUM1[A]--;
+    ~~~~~~~~
+!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+          ~
 !!! error TS2304: Cannot find name 'A'.
\ No newline at end of file
diff --git a/tests/baselines/reference/defaultBestCommonTypesHaveDecls.errors.txt b/tests/baselines/reference/defaultBestCommonTypesHaveDecls.errors.txt
index ada7f83af3d72..21296783f28a1 100644
--- a/tests/baselines/reference/defaultBestCommonTypesHaveDecls.errors.txt
+++ b/tests/baselines/reference/defaultBestCommonTypesHaveDecls.errors.txt
@@ -1,31 +1,27 @@
-tests/cases/compiler/defaultBestCommonTypesHaveDecls.ts(4,6): error TS2339: Property 'length' does not exist on type '{}'.
-tests/cases/compiler/defaultBestCommonTypesHaveDecls.ts(10,6): error TS2339: Property 'length' does not exist on type 'Object'.
-tests/cases/compiler/defaultBestCommonTypesHaveDecls.ts(18,27): error TS2339: Property 'length' does not exist on type '{}'.
+tests/cases/compiler/defaultBestCommonTypesHaveDecls.ts(2,6): error TS2339: Property 'length' does not exist on type '{}'.
+tests/cases/compiler/defaultBestCommonTypesHaveDecls.ts(5,6): error TS2339: Property 'length' does not exist on type 'Object'.
+tests/cases/compiler/defaultBestCommonTypesHaveDecls.ts(8,14): error TS2346: Supplied parameters do not match any signature of call target.
 
 
 ==== tests/cases/compiler/defaultBestCommonTypesHaveDecls.ts (3 errors) ====
-    
     var obj1: {};
-    
     obj1.length;
          ~~~~~~
 !!! error TS2339: Property 'length' does not exist on type '{}'.
-     
-     
     
     var obj2: Object;
-    
     obj2.length;
          ~~~~~~
 !!! error TS2339: Property 'length' does not exist on type 'Object'.
-     
-     
     
     function concat<T>(x: T, y: T): T { return null; }
+    var result = concat(1, ""); // error
+                 ~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    var elementCount = result.length; 
     
-    var result = concat(1, "");
+    function concat2<T, U>(x: T, y: U) { return null; }
+    var result2 = concat2(1, ""); // result2 will be number|string
+    var elementCount2 = result.length; 
     
-    var elementCount = result.length; // would like to get an error by now
-                              ~~~~~~
-!!! error TS2339: Property 'length' does not exist on type '{}'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/defaultBestCommonTypesHaveDecls.js b/tests/baselines/reference/defaultBestCommonTypesHaveDecls.js
index 59935cc53affc..98e135cc712a3 100644
--- a/tests/baselines/reference/defaultBestCommonTypesHaveDecls.js
+++ b/tests/baselines/reference/defaultBestCommonTypesHaveDecls.js
@@ -1,22 +1,18 @@
 //// [defaultBestCommonTypesHaveDecls.ts]
-
 var obj1: {};
-
 obj1.length;
- 
- 
 
 var obj2: Object;
-
 obj2.length;
- 
- 
 
 function concat<T>(x: T, y: T): T { return null; }
+var result = concat(1, ""); // error
+var elementCount = result.length; 
 
-var result = concat(1, "");
+function concat2<T, U>(x: T, y: U) { return null; }
+var result2 = concat2(1, ""); // result2 will be number|string
+var elementCount2 = result.length; 
 
-var elementCount = result.length; // would like to get an error by now
 
 
 //// [defaultBestCommonTypesHaveDecls.js]
@@ -27,5 +23,10 @@ obj2.length;
 function concat(x, y) {
     return null;
 }
-var result = concat(1, "");
-var elementCount = result.length; // would like to get an error by now
+var result = concat(1, ""); // error
+var elementCount = result.length;
+function concat2(x, y) {
+    return null;
+}
+var result2 = concat2(1, ""); // result2 will be number|string
+var elementCount2 = result.length;
diff --git a/tests/baselines/reference/derivedTypeDoesNotRequireExtendsClause.types b/tests/baselines/reference/derivedTypeDoesNotRequireExtendsClause.types
index 9821ff9112318..47b7ed95dc654 100644
--- a/tests/baselines/reference/derivedTypeDoesNotRequireExtendsClause.types
+++ b/tests/baselines/reference/derivedTypeDoesNotRequireExtendsClause.types
@@ -49,7 +49,7 @@ b = d2;
 var r: Base[] = [d1, d2];
 >r : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived | Derived2>
 >d1 : Derived
 >d2 : Derived2
 
diff --git a/tests/baselines/reference/doNotWidenAtObjectLiteralPropertyAssignment.types b/tests/baselines/reference/doNotWidenAtObjectLiteralPropertyAssignment.types
index 225bca8de637c..cd8c03fd6a68a 100644
--- a/tests/baselines/reference/doNotWidenAtObjectLiteralPropertyAssignment.types
+++ b/tests/baselines/reference/doNotWidenAtObjectLiteralPropertyAssignment.types
@@ -21,7 +21,7 @@ interface IIntervalTreeNode {
 var test: IIntervalTreeNode[] = [{ interval: { begin: 0 }, children: null }]; // was error here because best common type is {}
 >test : IIntervalTreeNode[]
 >IIntervalTreeNode : IIntervalTreeNode
->[{ interval: { begin: 0 }, children: null }] : IIntervalTreeNode[]
+>[{ interval: { begin: 0 }, children: null }] : { interval: { begin: number; }; children: null; }[]
 >{ interval: { begin: 0 }, children: null } : { interval: { begin: number; }; children: null; }
 >interval : { begin: number; }
 >{ begin: 0 } : { begin: number; }
diff --git a/tests/baselines/reference/enumBasics.types b/tests/baselines/reference/enumBasics.types
index f775295891abd..696e68eded2bd 100644
--- a/tests/baselines/reference/enumBasics.types
+++ b/tests/baselines/reference/enumBasics.types
@@ -157,8 +157,8 @@ enum E9 {
 // (refer to .js to validate)
 // Enum constant members are propagated
 var doNotPropagate = [
->doNotPropagate : {}[]
->[    E8.B, E7.A, E4.Z, E3.X, E3.Y, E3.Z] : {}[]
+>doNotPropagate : Array<E3 | E4 | E7 | E8>
+>[    E8.B, E7.A, E4.Z, E3.X, E3.Y, E3.Z] : Array<E3 | E4 | E7 | E8>
 
     E8.B, E7.A, E4.Z, E3.X, E3.Y, E3.Z
 >E8.B : E8
@@ -183,8 +183,8 @@ var doNotPropagate = [
 ];
 // Enum computed members are not propagated
 var doPropagate = [
->doPropagate : {}[]
->[    E9.A, E9.B, E6.B, E6.C, E6.A, E5.A, E5.B, E5.C] : {}[]
+>doPropagate : Array<E5 | E6 | E9>
+>[    E9.A, E9.B, E6.B, E6.C, E6.A, E5.A, E5.B, E5.C] : Array<E5 | E6 | E9>
 
     E9.A, E9.B, E6.B, E6.C, E6.A, E5.A, E5.B, E5.C
 >E9.A : E9
diff --git a/tests/baselines/reference/enumIdentifierLiterals.errors.txt b/tests/baselines/reference/enumIdentifierLiterals.errors.txt
index 721a6bd29ff11..6327e40289ac0 100644
--- a/tests/baselines/reference/enumIdentifierLiterals.errors.txt
+++ b/tests/baselines/reference/enumIdentifierLiterals.errors.txt
@@ -1,25 +1,25 @@
-tests/cases/compiler/enumIdentifierLiterals.ts(2,5): error TS1151: An enum member cannot have a numeric name.
-tests/cases/compiler/enumIdentifierLiterals.ts(3,5): error TS1151: An enum member cannot have a numeric name.
-tests/cases/compiler/enumIdentifierLiterals.ts(4,5): error TS1151: An enum member cannot have a numeric name.
-tests/cases/compiler/enumIdentifierLiterals.ts(5,5): error TS1151: An enum member cannot have a numeric name.
-tests/cases/compiler/enumIdentifierLiterals.ts(6,5): error TS1151: An enum member cannot have a numeric name.
-
-
-==== tests/cases/compiler/enumIdentifierLiterals.ts (5 errors) ====
-    enum Nums {
-        1.0,
-        ~~~
-!!! error TS1151: An enum member cannot have a numeric name.
-        11e-1,
-        ~~~~~
-!!! error TS1151: An enum member cannot have a numeric name.
-        0.12e1,
-        ~~~~~~
-!!! error TS1151: An enum member cannot have a numeric name.
-        "13e-1",
-        ~~~~~~~
-!!! error TS1151: An enum member cannot have a numeric name.
-        0xF00D
-        ~~~~~~
-!!! error TS1151: An enum member cannot have a numeric name.
+tests/cases/compiler/enumIdentifierLiterals.ts(2,5): error TS1151: An enum member cannot have a numeric name.
+tests/cases/compiler/enumIdentifierLiterals.ts(3,5): error TS1151: An enum member cannot have a numeric name.
+tests/cases/compiler/enumIdentifierLiterals.ts(4,5): error TS1151: An enum member cannot have a numeric name.
+tests/cases/compiler/enumIdentifierLiterals.ts(5,5): error TS1151: An enum member cannot have a numeric name.
+tests/cases/compiler/enumIdentifierLiterals.ts(6,5): error TS1151: An enum member cannot have a numeric name.
+
+
+==== tests/cases/compiler/enumIdentifierLiterals.ts (5 errors) ====
+    enum Nums {
+        1.0,
+        ~~~
+!!! error TS1151: An enum member cannot have a numeric name.
+        11e-1,
+        ~~~~~
+!!! error TS1151: An enum member cannot have a numeric name.
+        0.12e1,
+        ~~~~~~
+!!! error TS1151: An enum member cannot have a numeric name.
+        "13e-1",
+        ~~~~~~~
+!!! error TS1151: An enum member cannot have a numeric name.
+        0xF00D
+        ~~~~~~
+!!! error TS1151: An enum member cannot have a numeric name.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/enumIdentifierLiterals.js b/tests/baselines/reference/enumIdentifierLiterals.js
index 06cb76dd21d83..72a8a56570c8b 100644
--- a/tests/baselines/reference/enumIdentifierLiterals.js
+++ b/tests/baselines/reference/enumIdentifierLiterals.js
@@ -1,18 +1,18 @@
-//// [enumIdentifierLiterals.ts]
+//// [enumIdentifierLiterals.ts]
 enum Nums {
     1.0,
     11e-1,
     0.12e1,
     "13e-1",
     0xF00D
-}
-
-//// [enumIdentifierLiterals.js]
-var Nums;
-(function (Nums) {
-    Nums[Nums["1"] = 0] = "1";
-    Nums[Nums["1.1"] = 1] = "1.1";
-    Nums[Nums["1.2"] = 2] = "1.2";
-    Nums[Nums["13e-1"] = 3] = "13e-1";
-    Nums[Nums["61453"] = 4] = "61453";
-})(Nums || (Nums = {}));
+}
+
+//// [enumIdentifierLiterals.js]
+var Nums;
+(function (Nums) {
+    Nums[Nums["1"] = 0] = "1";
+    Nums[Nums["1.1"] = 1] = "1.1";
+    Nums[Nums["1.2"] = 2] = "1.2";
+    Nums[Nums["13e-1"] = 3] = "13e-1";
+    Nums[Nums["61453"] = 4] = "61453";
+})(Nums || (Nums = {}));
diff --git a/tests/baselines/reference/extendingClassFromAliasAndUsageInIndexer.types b/tests/baselines/reference/extendingClassFromAliasAndUsageInIndexer.types
index fefa692b5095e..991d324e822a0 100644
--- a/tests/baselines/reference/extendingClassFromAliasAndUsageInIndexer.types
+++ b/tests/baselines/reference/extendingClassFromAliasAndUsageInIndexer.types
@@ -25,7 +25,7 @@ var moduleMap: { [key: string]: IHasVisualizationModel } = {
 >moduleMap : { [x: string]: IHasVisualizationModel; }
 >key : string
 >IHasVisualizationModel : IHasVisualizationModel
->{    "moduleA": moduleA,    "moduleB": moduleB} : { [x: string]: IHasVisualizationModel; "moduleA": typeof moduleA; "moduleB": typeof moduleB; }
+>{    "moduleA": moduleA,    "moduleB": moduleB} : { [x: string]: typeof moduleA; "moduleA": typeof moduleA; "moduleB": typeof moduleB; }
 
     "moduleA": moduleA,
 >moduleA : typeof moduleA
diff --git a/tests/baselines/reference/fixTypeParameterInSignatureWithRestParameters.errors.txt b/tests/baselines/reference/fixTypeParameterInSignatureWithRestParameters.errors.txt
new file mode 100644
index 0000000000000..d9416eb4c2524
--- /dev/null
+++ b/tests/baselines/reference/fixTypeParameterInSignatureWithRestParameters.errors.txt
@@ -0,0 +1,8 @@
+tests/cases/compiler/fixTypeParameterInSignatureWithRestParameters.ts(2,1): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/compiler/fixTypeParameterInSignatureWithRestParameters.ts (1 errors) ====
+    function bar<T>(item1: T, item2: T) { }
+    bar(1, ""); // Should be ok
+    ~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
\ No newline at end of file
diff --git a/tests/baselines/reference/fixTypeParameterInSignatureWithRestParameters.types b/tests/baselines/reference/fixTypeParameterInSignatureWithRestParameters.types
deleted file mode 100644
index 95214571df9d8..0000000000000
--- a/tests/baselines/reference/fixTypeParameterInSignatureWithRestParameters.types
+++ /dev/null
@@ -1,13 +0,0 @@
-=== tests/cases/compiler/fixTypeParameterInSignatureWithRestParameters.ts ===
-function bar<T>(item1: T, item2: T) { }
->bar : <T>(item1: T, item2: T) => void
->T : T
->item1 : T
->T : T
->item2 : T
->T : T
-
-bar(1, ""); // Should be ok
->bar(1, "") : void
->bar : <T>(item1: T, item2: T) => void
-
diff --git a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
index b653bc01f5599..66e8a2a66dfc5 100644
--- a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
+++ b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt
@@ -7,7 +7,7 @@ tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDec
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(40,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'b' must be of type 'I', but here has type 'C2'.
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(43,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'.
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(46,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
-tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '{}[]'.
+tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'Array<C | D<string>>'.
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(50,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr2' must be of type 'D<string>[]', but here has type 'D<number>[]'.
 tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(53,10): error TS2403: Subsequent variable declarations must have the same type.  Variable 'm' must be of type 'typeof M', but here has type 'typeof A'.
 
@@ -79,7 +79,7 @@ tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDec
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
     for( var arr = [new C(), new C2(), new D<string>()];;){}
              ~~~
-!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '{}[]'.
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'Array<C | D<string>>'.
     
     for(var arr2 = [new D<string>()];;){}
     for( var arr2 = new Array<D<number>>();;){}
diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.types b/tests/baselines/reference/forStatementsMultipleValidDecl.types
index 2f3bfd70cea19..c2458a306c778 100644
--- a/tests/baselines/reference/forStatementsMultipleValidDecl.types
+++ b/tests/baselines/reference/forStatementsMultipleValidDecl.types
@@ -109,11 +109,11 @@ for (var a = ['a', 'b']; ;) { }
 for (var a = <string[]>[]; ;) { }
 >a : string[]
 ><string[]>[] : string[]
->[] : string[]
+>[] : undefined[]
 
 for (var a: string[] = []; ;) { }
 >a : string[]
->[] : string[]
+>[] : undefined[]
 
 for (var a = new Array<string>(); ;) { }
 >a : string[]
diff --git a/tests/baselines/reference/functionCall3.types b/tests/baselines/reference/functionCall3.types
index a9b8e46069c4a..ea47de3e6d93d 100644
--- a/tests/baselines/reference/functionCall3.types
+++ b/tests/baselines/reference/functionCall3.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/functionCall3.ts ===
 function foo():any[]{return [1];} 
 >foo : () => any[]
->[1] : any[]
+>[1] : number[]
 
 var x = foo();
 >x : any[]
diff --git a/tests/baselines/reference/functionOverloads42.types b/tests/baselines/reference/functionOverloads42.types
index dec6a04144072..6641a28c87a47 100644
--- a/tests/baselines/reference/functionOverloads42.types
+++ b/tests/baselines/reference/functionOverloads42.types
@@ -19,7 +19,7 @@ var x = foo([{a:'s'}]);
 >x : number
 >foo([{a:'s'}]) : number
 >foo : { (bar: { a: number; }[]): string; (bar: { a: any; }[]): number; }
->[{a:'s'}] : { a: any; }[]
+>[{a:'s'}] : { a: string; }[]
 >{a:'s'} : { a: string; }
 >a : string
 
diff --git a/tests/baselines/reference/functionSubtypingOfVarArgs2.types b/tests/baselines/reference/functionSubtypingOfVarArgs2.types
index 2fef933594dd0..2f81898c7ded9 100644
--- a/tests/baselines/reference/functionSubtypingOfVarArgs2.types
+++ b/tests/baselines/reference/functionSubtypingOfVarArgs2.types
@@ -5,7 +5,7 @@ class EventBase {
     private _listeners: { (...args: any[]): void; }[] = [];
 >_listeners : { (...args: any[]): void; }[]
 >args : any[]
->[] : { (...args: any[]): void; }[]
+>[] : undefined[]
 
     add(listener: (...args: any[]) => void): void {
 >add : (listener: (...args: any[]) => void) => void
diff --git a/tests/baselines/reference/generatedContextualTyping.types b/tests/baselines/reference/generatedContextualTyping.types
index 57b5408eabe1f..78fc6f6cfeff2 100644
--- a/tests/baselines/reference/generatedContextualTyping.types
+++ b/tests/baselines/reference/generatedContextualTyping.types
@@ -34,57 +34,57 @@ var b = new Base(), d1 = new Derived1(), d2 = new Derived2();
 var x1: () => Base[] = () => [d1, d2];
 >x1 : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x2: () => Base[] = function() { return [d1, d2] };
 >x2 : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x3: () => Base[] = function named() { return [d1, d2] };
 >x3 : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x4: { (): Base[]; } = () => [d1, d2];
 >x4 : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x5: { (): Base[]; } = function() { return [d1, d2] };
 >x5 : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x6: { (): Base[]; } = function named() { return [d1, d2] };
 >x6 : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x7: Base[] = [d1, d2];
 >x7 : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -92,7 +92,7 @@ var x8: Array<Base> = [d1, d2];
 >x8 : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -100,7 +100,7 @@ var x9: { [n: number]: Base; } = [d1, d2];
 >x9 : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -108,9 +108,9 @@ var x10: {n: Base[]; }  = { n: [d1, d2] };
 >x10 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -127,11 +127,11 @@ var x12: Genric<Base> = { func: n => { return [d1, d2]; } };
 >x12 : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -139,8 +139,8 @@ class x13 { member: () => Base[] = () => [d1, d2] }
 >x13 : x13
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -148,8 +148,8 @@ class x14 { member: () => Base[] = function() { return [d1, d2] } }
 >x14 : x14
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -157,9 +157,9 @@ class x15 { member: () => Base[] = function named() { return [d1, d2] } }
 >x15 : x15
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -167,8 +167,8 @@ class x16 { member: { (): Base[]; } = () => [d1, d2] }
 >x16 : x16
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -176,8 +176,8 @@ class x17 { member: { (): Base[]; } = function() { return [d1, d2] } }
 >x17 : x17
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -185,9 +185,9 @@ class x18 { member: { (): Base[]; } = function named() { return [d1, d2] } }
 >x18 : x18
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -195,7 +195,7 @@ class x19 { member: Base[] = [d1, d2] }
 >x19 : x19
 >member : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -204,7 +204,7 @@ class x20 { member: Array<Base> = [d1, d2] }
 >member : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -213,7 +213,7 @@ class x21 { member: { [n: number]: Base; } = [d1, d2] }
 >member : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -222,9 +222,9 @@ class x22 { member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -243,11 +243,11 @@ class x24 { member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -255,8 +255,8 @@ class x25 { private member: () => Base[] = () => [d1, d2] }
 >x25 : x25
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -264,8 +264,8 @@ class x26 { private member: () => Base[] = function() { return [d1, d2] } }
 >x26 : x26
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -273,9 +273,9 @@ class x27 { private member: () => Base[] = function named() { return [d1, d2] }
 >x27 : x27
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -283,8 +283,8 @@ class x28 { private member: { (): Base[]; } = () => [d1, d2] }
 >x28 : x28
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -292,8 +292,8 @@ class x29 { private member: { (): Base[]; } = function() { return [d1, d2] } }
 >x29 : x29
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -301,9 +301,9 @@ class x30 { private member: { (): Base[]; } = function named() { return [d1, d2]
 >x30 : x30
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -311,7 +311,7 @@ class x31 { private member: Base[] = [d1, d2] }
 >x31 : x31
 >member : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -320,7 +320,7 @@ class x32 { private member: Array<Base> = [d1, d2] }
 >member : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -329,7 +329,7 @@ class x33 { private member: { [n: number]: Base; } = [d1, d2] }
 >member : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -338,9 +338,9 @@ class x34 { private member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -359,11 +359,11 @@ class x36 { private member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -371,8 +371,8 @@ class x37 { public member: () => Base[] = () => [d1, d2] }
 >x37 : x37
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -380,8 +380,8 @@ class x38 { public member: () => Base[] = function() { return [d1, d2] } }
 >x38 : x38
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -389,9 +389,9 @@ class x39 { public member: () => Base[] = function named() { return [d1, d2] } }
 >x39 : x39
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -399,8 +399,8 @@ class x40 { public member: { (): Base[]; } = () => [d1, d2] }
 >x40 : x40
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -408,8 +408,8 @@ class x41 { public member: { (): Base[]; } = function() { return [d1, d2] } }
 >x41 : x41
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -417,9 +417,9 @@ class x42 { public member: { (): Base[]; } = function named() { return [d1, d2]
 >x42 : x42
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -427,7 +427,7 @@ class x43 { public member: Base[] = [d1, d2] }
 >x43 : x43
 >member : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -436,7 +436,7 @@ class x44 { public member: Array<Base> = [d1, d2] }
 >member : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -445,7 +445,7 @@ class x45 { public member: { [n: number]: Base; } = [d1, d2] }
 >member : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -454,9 +454,9 @@ class x46 { public member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -475,11 +475,11 @@ class x48 { public member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -487,8 +487,8 @@ class x49 { static member: () => Base[] = () => [d1, d2] }
 >x49 : x49
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -496,8 +496,8 @@ class x50 { static member: () => Base[] = function() { return [d1, d2] } }
 >x50 : x50
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -505,9 +505,9 @@ class x51 { static member: () => Base[] = function named() { return [d1, d2] } }
 >x51 : x51
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -515,8 +515,8 @@ class x52 { static member: { (): Base[]; } = () => [d1, d2] }
 >x52 : x52
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -524,8 +524,8 @@ class x53 { static member: { (): Base[]; } = function() { return [d1, d2] } }
 >x53 : x53
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -533,9 +533,9 @@ class x54 { static member: { (): Base[]; } = function named() { return [d1, d2]
 >x54 : x54
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -543,7 +543,7 @@ class x55 { static member: Base[] = [d1, d2] }
 >x55 : x55
 >member : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -552,7 +552,7 @@ class x56 { static member: Array<Base> = [d1, d2] }
 >member : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -561,7 +561,7 @@ class x57 { static member: { [n: number]: Base; } = [d1, d2] }
 >member : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -570,9 +570,9 @@ class x58 { static member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -591,11 +591,11 @@ class x60 { static member: Genric<Base> = { func: n => { return [d1, d2]; } } }
 >member : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -603,8 +603,8 @@ class x61 { private static member: () => Base[] = () => [d1, d2] }
 >x61 : x61
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -612,8 +612,8 @@ class x62 { private static member: () => Base[] = function() { return [d1, d2] }
 >x62 : x62
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -621,9 +621,9 @@ class x63 { private static member: () => Base[] = function named() { return [d1,
 >x63 : x63
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -631,8 +631,8 @@ class x64 { private static member: { (): Base[]; } = () => [d1, d2] }
 >x64 : x64
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -640,8 +640,8 @@ class x65 { private static member: { (): Base[]; } = function() { return [d1, d2
 >x65 : x65
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -649,9 +649,9 @@ class x66 { private static member: { (): Base[]; } = function named() { return [
 >x66 : x66
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -659,7 +659,7 @@ class x67 { private static member: Base[] = [d1, d2] }
 >x67 : x67
 >member : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -668,7 +668,7 @@ class x68 { private static member: Array<Base> = [d1, d2] }
 >member : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -677,7 +677,7 @@ class x69 { private static member: { [n: number]: Base; } = [d1, d2] }
 >member : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -686,9 +686,9 @@ class x70 { private static member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -707,11 +707,11 @@ class x72 { private static member: Genric<Base> = { func: n => { return [d1, d2]
 >member : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -719,8 +719,8 @@ class x73 { public static member: () => Base[] = () => [d1, d2] }
 >x73 : x73
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -728,8 +728,8 @@ class x74 { public static member: () => Base[] = function() { return [d1, d2] }
 >x74 : x74
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -737,9 +737,9 @@ class x75 { public static member: () => Base[] = function named() { return [d1,
 >x75 : x75
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -747,8 +747,8 @@ class x76 { public static member: { (): Base[]; } = () => [d1, d2] }
 >x76 : x76
 >member : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -756,8 +756,8 @@ class x77 { public static member: { (): Base[]; } = function() { return [d1, d2]
 >x77 : x77
 >member : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -765,9 +765,9 @@ class x78 { public static member: { (): Base[]; } = function named() { return [d
 >x78 : x78
 >member : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -775,7 +775,7 @@ class x79 { public static member: Base[] = [d1, d2] }
 >x79 : x79
 >member : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -784,7 +784,7 @@ class x80 { public static member: Array<Base> = [d1, d2] }
 >member : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -793,7 +793,7 @@ class x81 { public static member: { [n: number]: Base; } = [d1, d2] }
 >member : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -802,9 +802,9 @@ class x82 { public static member: {n: Base[]; }  = { n: [d1, d2] } }
 >member : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -823,11 +823,11 @@ class x84 { public static member: Genric<Base> = { func: n => { return [d1, d2];
 >member : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -835,8 +835,8 @@ class x85 { constructor(parm: () => Base[] = () => [d1, d2]) { } }
 >x85 : x85
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -844,8 +844,8 @@ class x86 { constructor(parm: () => Base[] = function() { return [d1, d2] }) { }
 >x86 : x86
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -853,9 +853,9 @@ class x87 { constructor(parm: () => Base[] = function named() { return [d1, d2]
 >x87 : x87
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -863,8 +863,8 @@ class x88 { constructor(parm: { (): Base[]; } = () => [d1, d2]) { } }
 >x88 : x88
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -872,8 +872,8 @@ class x89 { constructor(parm: { (): Base[]; } = function() { return [d1, d2] })
 >x89 : x89
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -881,9 +881,9 @@ class x90 { constructor(parm: { (): Base[]; } = function named() { return [d1, d
 >x90 : x90
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -891,7 +891,7 @@ class x91 { constructor(parm: Base[] = [d1, d2]) { } }
 >x91 : x91
 >parm : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -900,7 +900,7 @@ class x92 { constructor(parm: Array<Base> = [d1, d2]) { } }
 >parm : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -909,7 +909,7 @@ class x93 { constructor(parm: { [n: number]: Base; } = [d1, d2]) { } }
 >parm : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -918,9 +918,9 @@ class x94 { constructor(parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
 >parm : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -939,11 +939,11 @@ class x96 { constructor(parm: Genric<Base> = { func: n => { return [d1, d2]; } }
 >parm : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -951,8 +951,8 @@ class x97 { constructor(public parm: () => Base[] = () => [d1, d2]) { } }
 >x97 : x97
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -960,8 +960,8 @@ class x98 { constructor(public parm: () => Base[] = function() { return [d1, d2]
 >x98 : x98
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -969,9 +969,9 @@ class x99 { constructor(public parm: () => Base[] = function named() { return [d
 >x99 : x99
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -979,8 +979,8 @@ class x100 { constructor(public parm: { (): Base[]; } = () => [d1, d2]) { } }
 >x100 : x100
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -988,8 +988,8 @@ class x101 { constructor(public parm: { (): Base[]; } = function() { return [d1,
 >x101 : x101
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -997,9 +997,9 @@ class x102 { constructor(public parm: { (): Base[]; } = function named() { retur
 >x102 : x102
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1007,7 +1007,7 @@ class x103 { constructor(public parm: Base[] = [d1, d2]) { } }
 >x103 : x103
 >parm : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1016,7 +1016,7 @@ class x104 { constructor(public parm: Array<Base> = [d1, d2]) { } }
 >parm : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1025,7 +1025,7 @@ class x105 { constructor(public parm: { [n: number]: Base; } = [d1, d2]) { } }
 >parm : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1034,9 +1034,9 @@ class x106 { constructor(public parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
 >parm : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1055,11 +1055,11 @@ class x108 { constructor(public parm: Genric<Base> = { func: n => { return [d1,
 >parm : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1067,8 +1067,8 @@ class x109 { constructor(private parm: () => Base[] = () => [d1, d2]) { } }
 >x109 : x109
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1076,8 +1076,8 @@ class x110 { constructor(private parm: () => Base[] = function() { return [d1, d
 >x110 : x110
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1085,9 +1085,9 @@ class x111 { constructor(private parm: () => Base[] = function named() { return
 >x111 : x111
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1095,8 +1095,8 @@ class x112 { constructor(private parm: { (): Base[]; } = () => [d1, d2]) { } }
 >x112 : x112
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1104,8 +1104,8 @@ class x113 { constructor(private parm: { (): Base[]; } = function() { return [d1
 >x113 : x113
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1113,9 +1113,9 @@ class x114 { constructor(private parm: { (): Base[]; } = function named() { retu
 >x114 : x114
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1123,7 +1123,7 @@ class x115 { constructor(private parm: Base[] = [d1, d2]) { } }
 >x115 : x115
 >parm : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1132,7 +1132,7 @@ class x116 { constructor(private parm: Array<Base> = [d1, d2]) { } }
 >parm : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1141,7 +1141,7 @@ class x117 { constructor(private parm: { [n: number]: Base; } = [d1, d2]) { } }
 >parm : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1150,9 +1150,9 @@ class x118 { constructor(private parm: {n: Base[]; }  = { n: [d1, d2] }) { } }
 >parm : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1171,11 +1171,11 @@ class x120 { constructor(private parm: Genric<Base> = { func: n => { return [d1,
 >parm : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1183,8 +1183,8 @@ function x121(parm: () => Base[] = () => [d1, d2]) { }
 >x121 : (parm?: () => Base[]) => void
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1192,8 +1192,8 @@ function x122(parm: () => Base[] = function() { return [d1, d2] }) { }
 >x122 : (parm?: () => Base[]) => void
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1201,9 +1201,9 @@ function x123(parm: () => Base[] = function named() { return [d1, d2] }) { }
 >x123 : (parm?: () => Base[]) => void
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1211,8 +1211,8 @@ function x124(parm: { (): Base[]; } = () => [d1, d2]) { }
 >x124 : (parm?: () => Base[]) => void
 >parm : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1220,8 +1220,8 @@ function x125(parm: { (): Base[]; } = function() { return [d1, d2] }) { }
 >x125 : (parm?: () => Base[]) => void
 >parm : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1229,9 +1229,9 @@ function x126(parm: { (): Base[]; } = function named() { return [d1, d2] }) { }
 >x126 : (parm?: () => Base[]) => void
 >parm : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1239,7 +1239,7 @@ function x127(parm: Base[] = [d1, d2]) { }
 >x127 : (parm?: Base[]) => void
 >parm : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1248,7 +1248,7 @@ function x128(parm: Array<Base> = [d1, d2]) { }
 >parm : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1257,7 +1257,7 @@ function x129(parm: { [n: number]: Base; } = [d1, d2]) { }
 >parm : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1266,9 +1266,9 @@ function x130(parm: {n: Base[]; }  = { n: [d1, d2] }) { }
 >parm : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1287,68 +1287,68 @@ function x132(parm: Genric<Base> = { func: n => { return [d1, d2]; } }) { }
 >parm : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 function x133(): () => Base[] { return () => [d1, d2]; }
 >x133 : () => () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 function x134(): () => Base[] { return function() { return [d1, d2] }; }
 >x134 : () => () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 function x135(): () => Base[] { return function named() { return [d1, d2] }; }
 >x135 : () => () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 function x136(): { (): Base[]; } { return () => [d1, d2]; }
 >x136 : () => () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 function x137(): { (): Base[]; } { return function() { return [d1, d2] }; }
 >x137 : () => () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 function x138(): { (): Base[]; } { return function named() { return [d1, d2] }; }
 >x138 : () => () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 function x139(): Base[] { return [d1, d2]; }
 >x139 : () => Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1356,7 +1356,7 @@ function x140(): Array<Base> { return [d1, d2]; }
 >x140 : () => Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1364,7 +1364,7 @@ function x141(): { [n: number]: Base; } { return [d1, d2]; }
 >x141 : () => { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1372,9 +1372,9 @@ function x142(): {n: Base[]; }  { return { n: [d1, d2] }; }
 >x142 : () => { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1391,97 +1391,97 @@ function x144(): Genric<Base> { return { func: n => { return [d1, d2]; } }; }
 >x144 : () => Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 function x145(): () => Base[] { return () => [d1, d2]; return () => [d1, d2]; }
 >x145 : () => () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 function x146(): () => Base[] { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
 >x146 : () => () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 function x147(): () => Base[] { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
 >x147 : () => () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 function x148(): { (): Base[]; } { return () => [d1, d2]; return () => [d1, d2]; }
 >x148 : () => () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 function x149(): { (): Base[]; } { return function() { return [d1, d2] }; return function() { return [d1, d2] }; }
 >x149 : () => () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 function x150(): { (): Base[]; } { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; }
 >x150 : () => () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 function x151(): Base[] { return [d1, d2]; return [d1, d2]; }
 >x151 : () => Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1489,10 +1489,10 @@ function x152(): Array<Base> { return [d1, d2]; return [d1, d2]; }
 >x152 : () => Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1500,10 +1500,10 @@ function x153(): { [n: number]: Base; } { return [d1, d2]; return [d1, d2]; }
 >x153 : () => { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1511,14 +1511,14 @@ function x154(): {n: Base[]; }  { return { n: [d1, d2] }; return { n: [d1, d2] }
 >x154 : () => { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1539,82 +1539,82 @@ function x156(): Genric<Base> { return { func: n => { return [d1, d2]; } }; retu
 >x156 : () => Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x157: () => () => Base[] = () => { return () => [d1, d2]; };
 >x157 : () => () => Base[]
 >Base : Base
->() => { return () => [d1, d2]; } : () => () => Base[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => { return () => [d1, d2]; } : () => () => Array<Derived1 | Derived2>
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x158: () => () => Base[] = () => { return function() { return [d1, d2] }; };
 >x158 : () => () => Base[]
 >Base : Base
->() => { return function() { return [d1, d2] }; } : () => () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>() => { return function() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x159: () => () => Base[] = () => { return function named() { return [d1, d2] }; };
 >x159 : () => () => Base[]
 >Base : Base
->() => { return function named() { return [d1, d2] }; } : () => () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>() => { return function named() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x160: () => { (): Base[]; } = () => { return () => [d1, d2]; };
 >x160 : () => () => Base[]
 >Base : Base
->() => { return () => [d1, d2]; } : () => () => Base[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => { return () => [d1, d2]; } : () => () => Array<Derived1 | Derived2>
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x161: () => { (): Base[]; } = () => { return function() { return [d1, d2] }; };
 >x161 : () => () => Base[]
 >Base : Base
->() => { return function() { return [d1, d2] }; } : () => () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>() => { return function() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x162: () => { (): Base[]; } = () => { return function named() { return [d1, d2] }; };
 >x162 : () => () => Base[]
 >Base : Base
->() => { return function named() { return [d1, d2] }; } : () => () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>() => { return function named() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x163: () => Base[] = () => { return [d1, d2]; };
 >x163 : () => Base[]
 >Base : Base
->() => { return [d1, d2]; } : () => Base[]
->[d1, d2] : Base[]
+>() => { return [d1, d2]; } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1622,8 +1622,8 @@ var x164: () => Array<Base> = () => { return [d1, d2]; };
 >x164 : () => Base[]
 >Array : T[]
 >Base : Base
->() => { return [d1, d2]; } : () => Base[]
->[d1, d2] : Base[]
+>() => { return [d1, d2]; } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1631,8 +1631,8 @@ var x165: () => { [n: number]: Base; } = () => { return [d1, d2]; };
 >x165 : () => { [x: number]: Base; }
 >n : number
 >Base : Base
->() => { return [d1, d2]; } : () => Base[]
->[d1, d2] : Base[]
+>() => { return [d1, d2]; } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1640,10 +1640,10 @@ var x166: () => {n: Base[]; }  = () => { return { n: [d1, d2] }; };
 >x166 : () => { n: Base[]; }
 >n : Base[]
 >Base : Base
->() => { return { n: [d1, d2] }; } : () => { n: Base[]; }
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>() => { return { n: [d1, d2] }; } : () => { n: Array<Derived1 | Derived2>; }
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1661,76 +1661,76 @@ var x168: () => Genric<Base> = () => { return { func: n => { return [d1, d2]; }
 >x168 : () => Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->() => { return { func: n => { return [d1, d2]; } }; } : () => { func: (n: Base[]) => {}[]; }
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>() => { return { func: n => { return [d1, d2]; } }; } : () => { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x169: () => () => Base[] = function() { return () => [d1, d2]; };
 >x169 : () => () => Base[]
 >Base : Base
->function() { return () => [d1, d2]; } : () => () => Base[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>function() { return () => [d1, d2]; } : () => () => Array<Derived1 | Derived2>
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x170: () => () => Base[] = function() { return function() { return [d1, d2] }; };
 >x170 : () => () => Base[]
 >Base : Base
->function() { return function() { return [d1, d2] }; } : () => () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return function() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x171: () => () => Base[] = function() { return function named() { return [d1, d2] }; };
 >x171 : () => () => Base[]
 >Base : Base
->function() { return function named() { return [d1, d2] }; } : () => () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function() { return function named() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x172: () => { (): Base[]; } = function() { return () => [d1, d2]; };
 >x172 : () => () => Base[]
 >Base : Base
->function() { return () => [d1, d2]; } : () => () => Base[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>function() { return () => [d1, d2]; } : () => () => Array<Derived1 | Derived2>
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x173: () => { (): Base[]; } = function() { return function() { return [d1, d2] }; };
 >x173 : () => () => Base[]
 >Base : Base
->function() { return function() { return [d1, d2] }; } : () => () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return function() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x174: () => { (): Base[]; } = function() { return function named() { return [d1, d2] }; };
 >x174 : () => () => Base[]
 >Base : Base
->function() { return function named() { return [d1, d2] }; } : () => () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function() { return function named() { return [d1, d2] }; } : () => () => Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x175: () => Base[] = function() { return [d1, d2]; };
 >x175 : () => Base[]
 >Base : Base
->function() { return [d1, d2]; } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2]; } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1738,8 +1738,8 @@ var x176: () => Array<Base> = function() { return [d1, d2]; };
 >x176 : () => Base[]
 >Array : T[]
 >Base : Base
->function() { return [d1, d2]; } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2]; } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1747,8 +1747,8 @@ var x177: () => { [n: number]: Base; } = function() { return [d1, d2]; };
 >x177 : () => { [x: number]: Base; }
 >n : number
 >Base : Base
->function() { return [d1, d2]; } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2]; } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1756,10 +1756,10 @@ var x178: () => {n: Base[]; }  = function() { return { n: [d1, d2] }; };
 >x178 : () => { n: Base[]; }
 >n : Base[]
 >Base : Base
->function() { return { n: [d1, d2] }; } : () => { n: Base[]; }
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>function() { return { n: [d1, d2] }; } : () => { n: Array<Derived1 | Derived2>; }
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1777,12 +1777,12 @@ var x180: () => Genric<Base> = function() { return { func: n => { return [d1, d2
 >x180 : () => Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->function() { return { func: n => { return [d1, d2]; } }; } : () => { func: (n: Base[]) => {}[]; }
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>function() { return { func: n => { return [d1, d2]; } }; } : () => { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1790,8 +1790,8 @@ module x181 { var t: () => Base[] = () => [d1, d2]; }
 >x181 : typeof x181
 >t : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1799,8 +1799,8 @@ module x182 { var t: () => Base[] = function() { return [d1, d2] }; }
 >x182 : typeof x182
 >t : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1808,9 +1808,9 @@ module x183 { var t: () => Base[] = function named() { return [d1, d2] }; }
 >x183 : typeof x183
 >t : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1818,8 +1818,8 @@ module x184 { var t: { (): Base[]; } = () => [d1, d2]; }
 >x184 : typeof x184
 >t : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1827,8 +1827,8 @@ module x185 { var t: { (): Base[]; } = function() { return [d1, d2] }; }
 >x185 : typeof x185
 >t : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1836,9 +1836,9 @@ module x186 { var t: { (): Base[]; } = function named() { return [d1, d2] }; }
 >x186 : typeof x186
 >t : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1846,7 +1846,7 @@ module x187 { var t: Base[] = [d1, d2]; }
 >x187 : typeof x187
 >t : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1855,7 +1855,7 @@ module x188 { var t: Array<Base> = [d1, d2]; }
 >t : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1864,7 +1864,7 @@ module x189 { var t: { [n: number]: Base; } = [d1, d2]; }
 >t : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1873,9 +1873,9 @@ module x190 { var t: {n: Base[]; }  = { n: [d1, d2] }; }
 >t : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1894,11 +1894,11 @@ module x192 { var t: Genric<Base> = { func: n => { return [d1, d2]; } }; }
 >t : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1906,8 +1906,8 @@ module x193 { export var t: () => Base[] = () => [d1, d2]; }
 >x193 : typeof x193
 >t : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1915,8 +1915,8 @@ module x194 { export var t: () => Base[] = function() { return [d1, d2] }; }
 >x194 : typeof x194
 >t : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1924,9 +1924,9 @@ module x195 { export var t: () => Base[] = function named() { return [d1, d2] };
 >x195 : typeof x195
 >t : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1934,8 +1934,8 @@ module x196 { export var t: { (): Base[]; } = () => [d1, d2]; }
 >x196 : typeof x196
 >t : () => Base[]
 >Base : Base
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1943,8 +1943,8 @@ module x197 { export var t: { (): Base[]; } = function() { return [d1, d2] }; }
 >x197 : typeof x197
 >t : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1952,9 +1952,9 @@ module x198 { export var t: { (): Base[]; } = function named() { return [d1, d2]
 >x198 : typeof x198
 >t : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1962,7 +1962,7 @@ module x199 { export var t: Base[] = [d1, d2]; }
 >x199 : typeof x199
 >t : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1971,7 +1971,7 @@ module x200 { export var t: Array<Base> = [d1, d2]; }
 >t : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1980,7 +1980,7 @@ module x201 { export var t: { [n: number]: Base; } = [d1, d2]; }
 >t : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -1989,9 +1989,9 @@ module x202 { export var t: {n: Base[]; }  = { n: [d1, d2] }; }
 >t : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2010,11 +2010,11 @@ module x204 { export var t: Genric<Base> = { func: n => { return [d1, d2]; } };
 >t : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2022,8 +2022,8 @@ var x206 = <() => Base[]>function() { return [d1, d2] };
 >x206 : () => Base[]
 ><() => Base[]>function() { return [d1, d2] } : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2031,9 +2031,9 @@ var x207 = <() => Base[]>function named() { return [d1, d2] };
 >x207 : () => Base[]
 ><() => Base[]>function named() { return [d1, d2] } : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2041,8 +2041,8 @@ var x209 = <{ (): Base[]; }>function() { return [d1, d2] };
 >x209 : () => Base[]
 ><{ (): Base[]; }>function() { return [d1, d2] } : () => Base[]
 >Base : Base
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2050,9 +2050,9 @@ var x210 = <{ (): Base[]; }>function named() { return [d1, d2] };
 >x210 : () => Base[]
 ><{ (): Base[]; }>function named() { return [d1, d2] } : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2060,7 +2060,7 @@ var x211 = <Base[]>[d1, d2];
 >x211 : Base[]
 ><Base[]>[d1, d2] : Base[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2069,7 +2069,7 @@ var x212 = <Array<Base>>[d1, d2];
 ><Array<Base>>[d1, d2] : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2078,7 +2078,7 @@ var x213 = <{ [n: number]: Base; }>[d1, d2];
 ><{ [n: number]: Base; }>[d1, d2] : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2087,9 +2087,9 @@ var x214 = <{n: Base[]; } >{ n: [d1, d2] };
 ><{n: Base[]; } >{ n: [d1, d2] } : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2098,11 +2098,11 @@ var x216 = <Genric<Base>>{ func: n => { return [d1, d2]; } };
 ><Genric<Base>>{ func: n => { return [d1, d2]; } } : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2113,8 +2113,8 @@ var x217 = (<() => Base[]>undefined) || function() { return [d1, d2] };
 ><() => Base[]>undefined : () => Base[]
 >Base : Base
 >undefined : undefined
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2125,9 +2125,9 @@ var x218 = (<() => Base[]>undefined) || function named() { return [d1, d2] };
 ><() => Base[]>undefined : () => Base[]
 >Base : Base
 >undefined : undefined
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2138,8 +2138,8 @@ var x219 = (<{ (): Base[]; }>undefined) || function() { return [d1, d2] };
 ><{ (): Base[]; }>undefined : () => Base[]
 >Base : Base
 >undefined : undefined
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2150,9 +2150,9 @@ var x220 = (<{ (): Base[]; }>undefined) || function named() { return [d1, d2] };
 ><{ (): Base[]; }>undefined : () => Base[]
 >Base : Base
 >undefined : undefined
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2163,7 +2163,7 @@ var x221 = (<Base[]>undefined) || [d1, d2];
 ><Base[]>undefined : Base[]
 >Base : Base
 >undefined : undefined
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2175,7 +2175,7 @@ var x222 = (<Array<Base>>undefined) || [d1, d2];
 >Array : T[]
 >Base : Base
 >undefined : undefined
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2187,7 +2187,7 @@ var x223 = (<{ [n: number]: Base; }>undefined) || [d1, d2];
 >n : number
 >Base : Base
 >undefined : undefined
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2199,80 +2199,80 @@ var x224 = (<{n: Base[]; } >undefined) || { n: [d1, d2] };
 >n : Base[]
 >Base : Base
 >undefined : undefined
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x225: () => Base[]; x225 = () => [d1, d2];
 >x225 : () => Base[]
 >Base : Base
->x225 = () => [d1, d2] : () => Base[]
+>x225 = () => [d1, d2] : () => Array<Derived1 | Derived2>
 >x225 : () => Base[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x226: () => Base[]; x226 = function() { return [d1, d2] };
 >x226 : () => Base[]
 >Base : Base
->x226 = function() { return [d1, d2] } : () => Base[]
+>x226 = function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
 >x226 : () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x227: () => Base[]; x227 = function named() { return [d1, d2] };
 >x227 : () => Base[]
 >Base : Base
->x227 = function named() { return [d1, d2] } : () => Base[]
+>x227 = function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
 >x227 : () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x228: { (): Base[]; }; x228 = () => [d1, d2];
 >x228 : () => Base[]
 >Base : Base
->x228 = () => [d1, d2] : () => Base[]
+>x228 = () => [d1, d2] : () => Array<Derived1 | Derived2>
 >x228 : () => Base[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x229: { (): Base[]; }; x229 = function() { return [d1, d2] };
 >x229 : () => Base[]
 >Base : Base
->x229 = function() { return [d1, d2] } : () => Base[]
+>x229 = function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
 >x229 : () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x230: { (): Base[]; }; x230 = function named() { return [d1, d2] };
 >x230 : () => Base[]
 >Base : Base
->x230 = function named() { return [d1, d2] } : () => Base[]
+>x230 = function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
 >x230 : () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x231: Base[]; x231 = [d1, d2];
 >x231 : Base[]
 >Base : Base
->x231 = [d1, d2] : Base[]
+>x231 = [d1, d2] : Array<Derived1 | Derived2>
 >x231 : Base[]
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2280,9 +2280,9 @@ var x232: Array<Base>; x232 = [d1, d2];
 >x232 : Base[]
 >Array : T[]
 >Base : Base
->x232 = [d1, d2] : Base[]
+>x232 = [d1, d2] : Array<Derived1 | Derived2>
 >x232 : Base[]
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2290,9 +2290,9 @@ var x233: { [n: number]: Base; }; x233 = [d1, d2];
 >x233 : { [x: number]: Base; }
 >n : number
 >Base : Base
->x233 = [d1, d2] : Base[]
+>x233 = [d1, d2] : Array<Derived1 | Derived2>
 >x233 : { [x: number]: Base; }
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2300,11 +2300,11 @@ var x234: {n: Base[]; } ; x234 = { n: [d1, d2] };
 >x234 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->x234 = { n: [d1, d2] } : { n: Base[]; }
+>x234 = { n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
 >x234 : { n: Base[]; }
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2323,13 +2323,13 @@ var x236: Genric<Base>; x236 = { func: n => { return [d1, d2]; } };
 >x236 : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->x236 = { func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
+>x236 = { func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
 >x236 : Genric<Base>
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2337,10 +2337,10 @@ var x237: { n: () => Base[]; } = { n: () => [d1, d2] };
 >x237 : { n: () => Base[]; }
 >n : () => Base[]
 >Base : Base
->{ n: () => [d1, d2] } : { n: () => Base[]; }
->n : () => Base[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>{ n: () => [d1, d2] } : { n: () => Array<Derived1 | Derived2>; }
+>n : () => Array<Derived1 | Derived2>
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2348,10 +2348,10 @@ var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } };
 >x238 : { n: () => Base[]; }
 >n : () => Base[]
 >Base : Base
->{ n: function() { return [d1, d2] } } : { n: () => Base[]; }
->n : () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>{ n: function() { return [d1, d2] } } : { n: () => Array<Derived1 | Derived2>; }
+>n : () => Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2359,11 +2359,11 @@ var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } };
 >x239 : { n: () => Base[]; }
 >n : () => Base[]
 >Base : Base
->{ n: function named() { return [d1, d2] } } : { n: () => Base[]; }
->n : () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>{ n: function named() { return [d1, d2] } } : { n: () => Array<Derived1 | Derived2>; }
+>n : () => Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2371,10 +2371,10 @@ var x240: { n: { (): Base[]; }; } = { n: () => [d1, d2] };
 >x240 : { n: () => Base[]; }
 >n : () => Base[]
 >Base : Base
->{ n: () => [d1, d2] } : { n: () => Base[]; }
->n : () => Base[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>{ n: () => [d1, d2] } : { n: () => Array<Derived1 | Derived2>; }
+>n : () => Array<Derived1 | Derived2>
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2382,10 +2382,10 @@ var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } };
 >x241 : { n: () => Base[]; }
 >n : () => Base[]
 >Base : Base
->{ n: function() { return [d1, d2] } } : { n: () => Base[]; }
->n : () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>{ n: function() { return [d1, d2] } } : { n: () => Array<Derived1 | Derived2>; }
+>n : () => Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2393,11 +2393,11 @@ var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } };
 >x242 : { n: () => Base[]; }
 >n : () => Base[]
 >Base : Base
->{ n: function named() { return [d1, d2] } } : { n: () => Base[]; }
->n : () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>{ n: function named() { return [d1, d2] } } : { n: () => Array<Derived1 | Derived2>; }
+>n : () => Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2405,9 +2405,9 @@ var x243: { n: Base[]; } = { n: [d1, d2] };
 >x243 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2416,9 +2416,9 @@ var x244: { n: Array<Base>; } = { n: [d1, d2] };
 >n : Base[]
 >Array : T[]
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2427,9 +2427,9 @@ var x245: { n: { [n: number]: Base; }; } = { n: [d1, d2] };
 >n : { [x: number]: Base; }
 >n : number
 >Base : Base
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2438,11 +2438,11 @@ var x246: { n: {n: Base[]; } ; } = { n: { n: [d1, d2] } };
 >n : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: { n: [d1, d2] } } : { n: { n: Base[]; }; }
->n : { n: Base[]; }
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: { n: [d1, d2] } } : { n: { n: Array<Derived1 | Derived2>; }; }
+>n : { n: Array<Derived1 | Derived2>; }
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2463,49 +2463,49 @@ var x248: { n: Genric<Base>; } = { n: { func: n => { return [d1, d2]; } } };
 >n : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->{ n: { func: n => { return [d1, d2]; } } } : { n: { func: (n: Base[]) => {}[]; }; }
->n : { func: (n: Base[]) => {}[]; }
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ n: { func: n => { return [d1, d2]; } } } : { n: { func: (n: Base[]) => Array<Derived1 | Derived2>; }; }
+>n : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x252: { (): Base[]; }[] = [() => [d1, d2]];
 >x252 : { (): Base[]; }[]
 >Base : Base
->[() => [d1, d2]] : { (): Base[]; }[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>[() => [d1, d2]] : { (): Array<Derived1 | Derived2>; }[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x253: { (): Base[]; }[] = [function() { return [d1, d2] }];
 >x253 : { (): Base[]; }[]
 >Base : Base
->[function() { return [d1, d2] }] : { (): Base[]; }[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>[function() { return [d1, d2] }] : { (): Array<Derived1 | Derived2>; }[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x254: { (): Base[]; }[] = [function named() { return [d1, d2] }];
 >x254 : { (): Base[]; }[]
 >Base : Base
->[function named() { return [d1, d2] }] : { (): Base[]; }[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>[function named() { return [d1, d2] }] : { (): Array<Derived1 | Derived2>; }[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x255: Base[][] = [[d1, d2]];
 >x255 : Base[][]
 >Base : Base
->[[d1, d2]] : Base[][]
->[d1, d2] : Base[]
+>[[d1, d2]] : Array<Derived1 | Derived2>[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2513,8 +2513,8 @@ var x256: Array<Base>[] = [[d1, d2]];
 >x256 : Base[][]
 >Array : T[]
 >Base : Base
->[[d1, d2]] : Base[][]
->[d1, d2] : Base[]
+>[[d1, d2]] : Array<Derived1 | Derived2>[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2522,8 +2522,8 @@ var x257: { [n: number]: Base; }[] = [[d1, d2]];
 >x257 : { [x: number]: Base; }[]
 >n : number
 >Base : Base
->[[d1, d2]] : { [x: number]: Base; }[]
->[d1, d2] : Base[]
+>[[d1, d2]] : Array<Derived1 | Derived2>[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2531,10 +2531,10 @@ var x258: {n: Base[]; } [] = [{ n: [d1, d2] }];
 >x258 : { n: Base[]; }[]
 >n : Base[]
 >Base : Base
->[{ n: [d1, d2] }] : { n: Base[]; }[]
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>[{ n: [d1, d2] }] : { n: Array<Derived1 | Derived2>; }[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2542,21 +2542,21 @@ var x260: Genric<Base>[] = [{ func: n => { return [d1, d2]; } }];
 >x260 : Genric<Base>[]
 >Genric : Genric<T>
 >Base : Base
->[{ func: n => { return [d1, d2]; } }] : Genric<Base>[]
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>[{ func: n => { return [d1, d2]; } }] : { func: (n: Base[]) => Array<Derived1 | Derived2>; }[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x261: () => Base[] = function() { return [d1, d2] } || undefined;
 >x261 : () => Base[]
 >Base : Base
->function() { return [d1, d2] } || undefined : () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } || undefined : () => Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2564,10 +2564,10 @@ var x261: () => Base[] = function() { return [d1, d2] } || undefined;
 var x262: () => Base[] = function named() { return [d1, d2] } || undefined;
 >x262 : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } || undefined : () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } || undefined : () => Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2575,9 +2575,9 @@ var x262: () => Base[] = function named() { return [d1, d2] } || undefined;
 var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined;
 >x263 : () => Base[]
 >Base : Base
->function() { return [d1, d2] } || undefined : () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } || undefined : () => Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2585,10 +2585,10 @@ var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined;
 var x264: { (): Base[]; } = function named() { return [d1, d2] } || undefined;
 >x264 : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } || undefined : () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } || undefined : () => Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2596,8 +2596,8 @@ var x264: { (): Base[]; } = function named() { return [d1, d2] } || undefined;
 var x265: Base[] = [d1, d2] || undefined;
 >x265 : Base[]
 >Base : Base
->[d1, d2] || undefined : Base[]
->[d1, d2] : Base[]
+>[d1, d2] || undefined : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2606,8 +2606,8 @@ var x266: Array<Base> = [d1, d2] || undefined;
 >x266 : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] || undefined : Base[]
->[d1, d2] : Base[]
+>[d1, d2] || undefined : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2616,8 +2616,8 @@ var x267: { [n: number]: Base; } = [d1, d2] || undefined;
 >x267 : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] || undefined : { [x: number]: Base; }
->[d1, d2] : Base[]
+>[d1, d2] || undefined : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2626,10 +2626,10 @@ var x268: {n: Base[]; }  = { n: [d1, d2] } || undefined;
 >x268 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } || undefined : { n: Base[]; }
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } || undefined : { n: Array<Derived1 | Derived2>; }
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -2637,51 +2637,51 @@ var x268: {n: Base[]; }  = { n: [d1, d2] } || undefined;
 var x269: () => Base[] = undefined || function() { return [d1, d2] };
 >x269 : () => Base[]
 >Base : Base
->undefined || function() { return [d1, d2] } : () => Base[]
+>undefined || function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
 >undefined : undefined
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x270: () => Base[] = undefined || function named() { return [d1, d2] };
 >x270 : () => Base[]
 >Base : Base
->undefined || function named() { return [d1, d2] } : () => Base[]
+>undefined || function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
 >undefined : undefined
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x271: { (): Base[]; } = undefined || function() { return [d1, d2] };
 >x271 : () => Base[]
 >Base : Base
->undefined || function() { return [d1, d2] } : () => Base[]
+>undefined || function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
 >undefined : undefined
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x272: { (): Base[]; } = undefined || function named() { return [d1, d2] };
 >x272 : () => Base[]
 >Base : Base
->undefined || function named() { return [d1, d2] } : () => Base[]
+>undefined || function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
 >undefined : undefined
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x273: Base[] = undefined || [d1, d2];
 >x273 : Base[]
 >Base : Base
->undefined || [d1, d2] : Base[]
+>undefined || [d1, d2] : Array<Derived1 | Derived2>
 >undefined : undefined
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2689,9 +2689,9 @@ var x274: Array<Base> = undefined || [d1, d2];
 >x274 : Base[]
 >Array : T[]
 >Base : Base
->undefined || [d1, d2] : Base[]
+>undefined || [d1, d2] : Array<Derived1 | Derived2>
 >undefined : undefined
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2699,9 +2699,9 @@ var x275: { [n: number]: Base; } = undefined || [d1, d2];
 >x275 : { [x: number]: Base; }
 >n : number
 >Base : Base
->undefined || [d1, d2] : { [x: number]: Base; }
+>undefined || [d1, d2] : Array<Derived1 | Derived2>
 >undefined : undefined
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2709,78 +2709,78 @@ var x276: {n: Base[]; }  = undefined || { n: [d1, d2] };
 >x276 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->undefined || { n: [d1, d2] } : { n: Base[]; }
+>undefined || { n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
 >undefined : undefined
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x277: () => Base[] = function() { return [d1, d2] } || function() { return [d1, d2] };
 >x277 : () => Base[]
 >Base : Base
->function() { return [d1, d2] } || function() { return [d1, d2] } : () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } || function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x278: () => Base[] = function named() { return [d1, d2] } || function named() { return [d1, d2] };
 >x278 : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } || function named() { return [d1, d2] } : () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } || function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x279: { (): Base[]; } = function() { return [d1, d2] } || function() { return [d1, d2] };
 >x279 : () => Base[]
 >Base : Base
->function() { return [d1, d2] } || function() { return [d1, d2] } : () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } || function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x280: { (): Base[]; } = function named() { return [d1, d2] } || function named() { return [d1, d2] };
 >x280 : () => Base[]
 >Base : Base
->function named() { return [d1, d2] } || function named() { return [d1, d2] } : () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } || function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x281: Base[] = [d1, d2] || [d1, d2];
 >x281 : Base[]
 >Base : Base
->[d1, d2] || [d1, d2] : Base[]
->[d1, d2] : Base[]
+>[d1, d2] || [d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2788,11 +2788,11 @@ var x282: Array<Base> = [d1, d2] || [d1, d2];
 >x282 : Base[]
 >Array : T[]
 >Base : Base
->[d1, d2] || [d1, d2] : Base[]
->[d1, d2] : Base[]
+>[d1, d2] || [d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2800,11 +2800,11 @@ var x283: { [n: number]: Base; } = [d1, d2] || [d1, d2];
 >x283 : { [x: number]: Base; }
 >n : number
 >Base : Base
->[d1, d2] || [d1, d2] : { [x: number]: Base; }
->[d1, d2] : Base[]
+>[d1, d2] || [d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2812,108 +2812,108 @@ var x284: {n: Base[]; }  = { n: [d1, d2] } || { n: [d1, d2] };
 >x284 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->{ n: [d1, d2] } || { n: [d1, d2] } : { n: Base[]; }
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } || { n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x285: () => Base[] = true ? () => [d1, d2] : () => [d1, d2];
 >x285 : () => Base[]
 >Base : Base
->true ? () => [d1, d2] : () => [d1, d2] : () => Base[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>true ? () => [d1, d2] : () => [d1, d2] : () => Array<Derived1 | Derived2>
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x286: () => Base[] = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
 >x286 : () => Base[]
 >Base : Base
->true ? function() { return [d1, d2] } : function() { return [d1, d2] } : () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>true ? function() { return [d1, d2] } : function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x287: () => Base[] = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
 >x287 : () => Base[]
 >Base : Base
->true ? function named() { return [d1, d2] } : function named() { return [d1, d2] } : () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>true ? function named() { return [d1, d2] } : function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x288: { (): Base[]; } = true ? () => [d1, d2] : () => [d1, d2];
 >x288 : () => Base[]
 >Base : Base
->true ? () => [d1, d2] : () => [d1, d2] : () => Base[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>true ? () => [d1, d2] : () => [d1, d2] : () => Array<Derived1 | Derived2>
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x289: { (): Base[]; } = true ? function() { return [d1, d2] } : function() { return [d1, d2] };
 >x289 : () => Base[]
 >Base : Base
->true ? function() { return [d1, d2] } : function() { return [d1, d2] } : () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>true ? function() { return [d1, d2] } : function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x290: { (): Base[]; } = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] };
 >x290 : () => Base[]
 >Base : Base
->true ? function named() { return [d1, d2] } : function named() { return [d1, d2] } : () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>true ? function named() { return [d1, d2] } : function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x291: Base[] = true ? [d1, d2] : [d1, d2];
 >x291 : Base[]
 >Base : Base
->true ? [d1, d2] : [d1, d2] : Base[]
->[d1, d2] : Base[]
+>true ? [d1, d2] : [d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2921,11 +2921,11 @@ var x292: Array<Base> = true ? [d1, d2] : [d1, d2];
 >x292 : Base[]
 >Array : T[]
 >Base : Base
->true ? [d1, d2] : [d1, d2] : Base[]
->[d1, d2] : Base[]
+>true ? [d1, d2] : [d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2933,11 +2933,11 @@ var x293: { [n: number]: Base; } = true ? [d1, d2] : [d1, d2];
 >x293 : { [x: number]: Base; }
 >n : number
 >Base : Base
->true ? [d1, d2] : [d1, d2] : { [x: number]: Base; }
->[d1, d2] : Base[]
+>true ? [d1, d2] : [d1, d2] : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2945,15 +2945,15 @@ var x294: {n: Base[]; }  = true ? { n: [d1, d2] } : { n: [d1, d2] };
 >x294 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->true ? { n: [d1, d2] } : { n: [d1, d2] } : { n: Base[]; }
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>true ? { n: [d1, d2] } : { n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -2961,7 +2961,7 @@ var x295: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : n =
 >x295 : (s: Base[]) => any
 >s : Base[]
 >Base : Base
->true ? n => { var n: Base[]; return null; } : n => { var n: Base[]; return null; } : (s: Base[]) => any
+>true ? n => { var n: Base[]; return null; } : n => { var n: Base[]; return null; } : (n: Base[]) => any
 >n => { var n: Base[]; return null; } : (n: Base[]) => any
 >n : Base[]
 >n : Base[]
@@ -2975,90 +2975,90 @@ var x296: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : { func: n
 >x296 : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->true ? { func: n => { return [d1, d2]; } } : { func: n => { return [d1, d2]; } } : Genric<Base>
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>true ? { func: n => { return [d1, d2]; } } : { func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x297: () => Base[] = true ? undefined : () => [d1, d2];
 >x297 : () => Base[]
 >Base : Base
->true ? undefined : () => [d1, d2] : () => Base[]
+>true ? undefined : () => [d1, d2] : () => Array<Derived1 | Derived2>
 >undefined : undefined
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x298: () => Base[] = true ? undefined : function() { return [d1, d2] };
 >x298 : () => Base[]
 >Base : Base
->true ? undefined : function() { return [d1, d2] } : () => Base[]
+>true ? undefined : function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
 >undefined : undefined
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x299: () => Base[] = true ? undefined : function named() { return [d1, d2] };
 >x299 : () => Base[]
 >Base : Base
->true ? undefined : function named() { return [d1, d2] } : () => Base[]
+>true ? undefined : function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
 >undefined : undefined
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x300: { (): Base[]; } = true ? undefined : () => [d1, d2];
 >x300 : () => Base[]
 >Base : Base
->true ? undefined : () => [d1, d2] : () => Base[]
+>true ? undefined : () => [d1, d2] : () => Array<Derived1 | Derived2>
 >undefined : undefined
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x301: { (): Base[]; } = true ? undefined : function() { return [d1, d2] };
 >x301 : () => Base[]
 >Base : Base
->true ? undefined : function() { return [d1, d2] } : () => Base[]
+>true ? undefined : function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
 >undefined : undefined
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x302: { (): Base[]; } = true ? undefined : function named() { return [d1, d2] };
 >x302 : () => Base[]
 >Base : Base
->true ? undefined : function named() { return [d1, d2] } : () => Base[]
+>true ? undefined : function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
 >undefined : undefined
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x303: Base[] = true ? undefined : [d1, d2];
 >x303 : Base[]
 >Base : Base
->true ? undefined : [d1, d2] : Base[]
+>true ? undefined : [d1, d2] : Array<Derived1 | Derived2>
 >undefined : undefined
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3066,9 +3066,9 @@ var x304: Array<Base> = true ? undefined : [d1, d2];
 >x304 : Base[]
 >Array : T[]
 >Base : Base
->true ? undefined : [d1, d2] : Base[]
+>true ? undefined : [d1, d2] : Array<Derived1 | Derived2>
 >undefined : undefined
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3076,9 +3076,9 @@ var x305: { [n: number]: Base; } = true ? undefined : [d1, d2];
 >x305 : { [x: number]: Base; }
 >n : number
 >Base : Base
->true ? undefined : [d1, d2] : { [x: number]: Base; }
+>true ? undefined : [d1, d2] : Array<Derived1 | Derived2>
 >undefined : undefined
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3086,11 +3086,11 @@ var x306: {n: Base[]; }  = true ? undefined : { n: [d1, d2] };
 >x306 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->true ? undefined : { n: [d1, d2] } : { n: Base[]; }
+>true ? undefined : { n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
 >undefined : undefined
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3098,7 +3098,7 @@ var x307: (s: Base[]) => any = true ? undefined : n => { var n: Base[]; return n
 >x307 : (s: Base[]) => any
 >s : Base[]
 >Base : Base
->true ? undefined : n => { var n: Base[]; return null; } : (s: Base[]) => any
+>true ? undefined : n => { var n: Base[]; return null; } : (n: Base[]) => any
 >undefined : undefined
 >n => { var n: Base[]; return null; } : (n: Base[]) => any
 >n : Base[]
@@ -3109,22 +3109,22 @@ var x308: Genric<Base> = true ? undefined : { func: n => { return [d1, d2]; } };
 >x308 : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->true ? undefined : { func: n => { return [d1, d2]; } } : Genric<Base>
+>true ? undefined : { func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
 >undefined : undefined
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
 var x309: () => Base[] = true ? () => [d1, d2] : undefined;
 >x309 : () => Base[]
 >Base : Base
->true ? () => [d1, d2] : undefined : () => Base[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>true ? () => [d1, d2] : undefined : () => Array<Derived1 | Derived2>
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3132,9 +3132,9 @@ var x309: () => Base[] = true ? () => [d1, d2] : undefined;
 var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined;
 >x310 : () => Base[]
 >Base : Base
->true ? function() { return [d1, d2] } : undefined : () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>true ? function() { return [d1, d2] } : undefined : () => Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3142,10 +3142,10 @@ var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined;
 var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined;
 >x311 : () => Base[]
 >Base : Base
->true ? function named() { return [d1, d2] } : undefined : () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>true ? function named() { return [d1, d2] } : undefined : () => Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3153,9 +3153,9 @@ var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined
 var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined;
 >x312 : () => Base[]
 >Base : Base
->true ? () => [d1, d2] : undefined : () => Base[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>true ? () => [d1, d2] : undefined : () => Array<Derived1 | Derived2>
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3163,9 +3163,9 @@ var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined;
 var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined;
 >x313 : () => Base[]
 >Base : Base
->true ? function() { return [d1, d2] } : undefined : () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>true ? function() { return [d1, d2] } : undefined : () => Array<Derived1 | Derived2>
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3173,10 +3173,10 @@ var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined;
 var x314: { (): Base[]; } = true ? function named() { return [d1, d2] } : undefined;
 >x314 : () => Base[]
 >Base : Base
->true ? function named() { return [d1, d2] } : undefined : () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>true ? function named() { return [d1, d2] } : undefined : () => Array<Derived1 | Derived2>
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3184,8 +3184,8 @@ var x314: { (): Base[]; } = true ? function named() { return [d1, d2] } : undefi
 var x315: Base[] = true ? [d1, d2] : undefined;
 >x315 : Base[]
 >Base : Base
->true ? [d1, d2] : undefined : Base[]
->[d1, d2] : Base[]
+>true ? [d1, d2] : undefined : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3194,8 +3194,8 @@ var x316: Array<Base> = true ? [d1, d2] : undefined;
 >x316 : Base[]
 >Array : T[]
 >Base : Base
->true ? [d1, d2] : undefined : Base[]
->[d1, d2] : Base[]
+>true ? [d1, d2] : undefined : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3204,8 +3204,8 @@ var x317: { [n: number]: Base; } = true ? [d1, d2] : undefined;
 >x317 : { [x: number]: Base; }
 >n : number
 >Base : Base
->true ? [d1, d2] : undefined : { [x: number]: Base; }
->[d1, d2] : Base[]
+>true ? [d1, d2] : undefined : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3214,10 +3214,10 @@ var x318: {n: Base[]; }  = true ? { n: [d1, d2] } : undefined;
 >x318 : { n: Base[]; }
 >n : Base[]
 >Base : Base
->true ? { n: [d1, d2] } : undefined : { n: Base[]; }
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>true ? { n: [d1, d2] } : undefined : { n: Array<Derived1 | Derived2>; }
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3226,7 +3226,7 @@ var x319: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : und
 >x319 : (s: Base[]) => any
 >s : Base[]
 >Base : Base
->true ? n => { var n: Base[]; return null; } : undefined : (s: Base[]) => any
+>true ? n => { var n: Base[]; return null; } : undefined : (n: Base[]) => any
 >n => { var n: Base[]; return null; } : (n: Base[]) => any
 >n : Base[]
 >n : Base[]
@@ -3237,12 +3237,12 @@ var x320: Genric<Base> = true ? { func: n => { return [d1, d2]; } } : undefined;
 >x320 : Genric<Base>
 >Genric : Genric<T>
 >Base : Base
->true ? { func: n => { return [d1, d2]; } } : undefined : Genric<Base>
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>true ? { func: n => { return [d1, d2]; } } : undefined : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 >undefined : undefined
@@ -3253,8 +3253,8 @@ function x321(n: () => Base[]) { }; x321(() => [d1, d2]);
 >Base : Base
 >x321(() => [d1, d2]) : void
 >x321 : (n: () => Base[]) => void
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3264,8 +3264,8 @@ function x322(n: () => Base[]) { }; x322(function() { return [d1, d2] });
 >Base : Base
 >x322(function() { return [d1, d2] }) : void
 >x322 : (n: () => Base[]) => void
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3275,9 +3275,9 @@ function x323(n: () => Base[]) { }; x323(function named() { return [d1, d2] });
 >Base : Base
 >x323(function named() { return [d1, d2] }) : void
 >x323 : (n: () => Base[]) => void
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3287,8 +3287,8 @@ function x324(n: { (): Base[]; }) { }; x324(() => [d1, d2]);
 >Base : Base
 >x324(() => [d1, d2]) : void
 >x324 : (n: () => Base[]) => void
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3298,8 +3298,8 @@ function x325(n: { (): Base[]; }) { }; x325(function() { return [d1, d2] });
 >Base : Base
 >x325(function() { return [d1, d2] }) : void
 >x325 : (n: () => Base[]) => void
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3309,9 +3309,9 @@ function x326(n: { (): Base[]; }) { }; x326(function named() { return [d1, d2] }
 >Base : Base
 >x326(function named() { return [d1, d2] }) : void
 >x326 : (n: () => Base[]) => void
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3321,7 +3321,7 @@ function x327(n: Base[]) { }; x327([d1, d2]);
 >Base : Base
 >x327([d1, d2]) : void
 >x327 : (n: Base[]) => void
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3332,7 +3332,7 @@ function x328(n: Array<Base>) { }; x328([d1, d2]);
 >Base : Base
 >x328([d1, d2]) : void
 >x328 : (n: Base[]) => void
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3343,7 +3343,7 @@ function x329(n: { [n: number]: Base; }) { }; x329([d1, d2]);
 >Base : Base
 >x329([d1, d2]) : void
 >x329 : (n: { [x: number]: Base; }) => void
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3354,9 +3354,9 @@ function x330(n: {n: Base[]; } ) { }; x330({ n: [d1, d2] });
 >Base : Base
 >x330({ n: [d1, d2] }) : void
 >x330 : (n: { n: Base[]; }) => void
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3379,11 +3379,11 @@ function x332(n: Genric<Base>) { }; x332({ func: n => { return [d1, d2]; } });
 >Base : Base
 >x332({ func: n => { return [d1, d2]; } }) : void
 >x332 : (n: Genric<Base>) => void
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3395,8 +3395,8 @@ var x333 = (n: () => Base[]) => n; x333(() => [d1, d2]);
 >n : () => Base[]
 >x333(() => [d1, d2]) : () => Base[]
 >x333 : (n: () => Base[]) => () => Base[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3408,8 +3408,8 @@ var x334 = (n: () => Base[]) => n; x334(function() { return [d1, d2] });
 >n : () => Base[]
 >x334(function() { return [d1, d2] }) : () => Base[]
 >x334 : (n: () => Base[]) => () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3421,9 +3421,9 @@ var x335 = (n: () => Base[]) => n; x335(function named() { return [d1, d2] });
 >n : () => Base[]
 >x335(function named() { return [d1, d2] }) : () => Base[]
 >x335 : (n: () => Base[]) => () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3435,8 +3435,8 @@ var x336 = (n: { (): Base[]; }) => n; x336(() => [d1, d2]);
 >n : () => Base[]
 >x336(() => [d1, d2]) : () => Base[]
 >x336 : (n: () => Base[]) => () => Base[]
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3448,8 +3448,8 @@ var x337 = (n: { (): Base[]; }) => n; x337(function() { return [d1, d2] });
 >n : () => Base[]
 >x337(function() { return [d1, d2] }) : () => Base[]
 >x337 : (n: () => Base[]) => () => Base[]
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3461,9 +3461,9 @@ var x338 = (n: { (): Base[]; }) => n; x338(function named() { return [d1, d2] })
 >n : () => Base[]
 >x338(function named() { return [d1, d2] }) : () => Base[]
 >x338 : (n: () => Base[]) => () => Base[]
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3475,7 +3475,7 @@ var x339 = (n: Base[]) => n; x339([d1, d2]);
 >n : Base[]
 >x339([d1, d2]) : Base[]
 >x339 : (n: Base[]) => Base[]
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3488,7 +3488,7 @@ var x340 = (n: Array<Base>) => n; x340([d1, d2]);
 >n : Base[]
 >x340([d1, d2]) : Base[]
 >x340 : (n: Base[]) => Base[]
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3501,7 +3501,7 @@ var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]);
 >n : { [x: number]: Base; }
 >x341([d1, d2]) : { [x: number]: Base; }
 >x341 : (n: { [x: number]: Base; }) => { [x: number]: Base; }
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3514,9 +3514,9 @@ var x342 = (n: {n: Base[]; } ) => n; x342({ n: [d1, d2] });
 >n : { n: Base[]; }
 >x342({ n: [d1, d2] }) : { n: Base[]; }
 >x342 : (n: { n: Base[]; }) => { n: Base[]; }
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3543,11 +3543,11 @@ var x344 = (n: Genric<Base>) => n; x344({ func: n => { return [d1, d2]; } });
 >n : Genric<Base>
 >x344({ func: n => { return [d1, d2]; } }) : Genric<Base>
 >x344 : (n: Genric<Base>) => Genric<Base>
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3558,8 +3558,8 @@ var x345 = function(n: () => Base[]) { }; x345(() => [d1, d2]);
 >Base : Base
 >x345(() => [d1, d2]) : void
 >x345 : (n: () => Base[]) => void
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3570,8 +3570,8 @@ var x346 = function(n: () => Base[]) { }; x346(function() { return [d1, d2] });
 >Base : Base
 >x346(function() { return [d1, d2] }) : void
 >x346 : (n: () => Base[]) => void
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3582,9 +3582,9 @@ var x347 = function(n: () => Base[]) { }; x347(function named() { return [d1, d2
 >Base : Base
 >x347(function named() { return [d1, d2] }) : void
 >x347 : (n: () => Base[]) => void
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3595,8 +3595,8 @@ var x348 = function(n: { (): Base[]; }) { }; x348(() => [d1, d2]);
 >Base : Base
 >x348(() => [d1, d2]) : void
 >x348 : (n: () => Base[]) => void
->() => [d1, d2] : () => Base[]
->[d1, d2] : Base[]
+>() => [d1, d2] : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3607,8 +3607,8 @@ var x349 = function(n: { (): Base[]; }) { }; x349(function() { return [d1, d2] }
 >Base : Base
 >x349(function() { return [d1, d2] }) : void
 >x349 : (n: () => Base[]) => void
->function() { return [d1, d2] } : () => Base[]
->[d1, d2] : Base[]
+>function() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3619,9 +3619,9 @@ var x350 = function(n: { (): Base[]; }) { }; x350(function named() { return [d1,
 >Base : Base
 >x350(function named() { return [d1, d2] }) : void
 >x350 : (n: () => Base[]) => void
->function named() { return [d1, d2] } : () => Base[]
->named : () => Base[]
->[d1, d2] : Base[]
+>function named() { return [d1, d2] } : () => Array<Derived1 | Derived2>
+>named : () => Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3632,7 +3632,7 @@ var x351 = function(n: Base[]) { }; x351([d1, d2]);
 >Base : Base
 >x351([d1, d2]) : void
 >x351 : (n: Base[]) => void
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3644,7 +3644,7 @@ var x352 = function(n: Array<Base>) { }; x352([d1, d2]);
 >Base : Base
 >x352([d1, d2]) : void
 >x352 : (n: Base[]) => void
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3656,7 +3656,7 @@ var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]);
 >Base : Base
 >x353([d1, d2]) : void
 >x353 : (n: { [x: number]: Base; }) => void
->[d1, d2] : Base[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3668,9 +3668,9 @@ var x354 = function(n: {n: Base[]; } ) { }; x354({ n: [d1, d2] });
 >Base : Base
 >x354({ n: [d1, d2] }) : void
 >x354 : (n: { n: Base[]; }) => void
->{ n: [d1, d2] } : { n: Base[]; }
->n : Base[]
->[d1, d2] : Base[]
+>{ n: [d1, d2] } : { n: Array<Derived1 | Derived2>; }
+>n : Array<Derived1 | Derived2>
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
@@ -3695,11 +3695,11 @@ var x356 = function(n: Genric<Base>) { }; x356({ func: n => { return [d1, d2]; }
 >Base : Base
 >x356({ func: n => { return [d1, d2]; } }) : void
 >x356 : (n: Genric<Base>) => void
->{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => {}[]; }
->func : (n: Base[]) => {}[]
->n => { return [d1, d2]; } : (n: Base[]) => {}[]
+>{ func: n => { return [d1, d2]; } } : { func: (n: Base[]) => Array<Derived1 | Derived2>; }
+>func : (n: Base[]) => Array<Derived1 | Derived2>
+>n => { return [d1, d2]; } : (n: Base[]) => Array<Derived1 | Derived2>
 >n : Base[]
->[d1, d2] : {}[]
+>[d1, d2] : Array<Derived1 | Derived2>
 >d1 : Derived1
 >d2 : Derived2
 
diff --git a/tests/baselines/reference/genericArgumentCallSigAssignmentCompat.types b/tests/baselines/reference/genericArgumentCallSigAssignmentCompat.types
index 2ac2483c405fc..f16e747d41eee 100644
--- a/tests/baselines/reference/genericArgumentCallSigAssignmentCompat.types
+++ b/tests/baselines/reference/genericArgumentCallSigAssignmentCompat.types
@@ -49,7 +49,7 @@ _.all([true, 1, null, 'yes'], _.identity);
 >_.all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => boolean
 >_ : Underscore.Static
 >all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => boolean
->[true, 1, null, 'yes'] : {}[]
+>[true, 1, null, 'yes'] : Array<string | number | boolean>
 >_.identity : <T>(value: T) => T
 >_ : Underscore.Static
 >identity : <T>(value: T) => T
diff --git a/tests/baselines/reference/genericArray0.types b/tests/baselines/reference/genericArray0.types
index 80a9d5199bde3..bf0155bb9ba66 100644
--- a/tests/baselines/reference/genericArray0.types
+++ b/tests/baselines/reference/genericArray0.types
@@ -16,6 +16,6 @@ function map<U>() {
     var ys: U[] = [];
 >ys : U[]
 >U : U
->[] : U[]
+>[] : undefined[]
 }
 
diff --git a/tests/baselines/reference/genericBaseClassLiteralProperty2.types b/tests/baselines/reference/genericBaseClassLiteralProperty2.types
index b2d156e3c16c5..9caa45b8b8f71 100644
--- a/tests/baselines/reference/genericBaseClassLiteralProperty2.types
+++ b/tests/baselines/reference/genericBaseClassLiteralProperty2.types
@@ -14,11 +14,11 @@ class BaseCollection2<TItem extends CollectionItem2> {
 
     constructor() {
         this._itemsByKey = {};
->this._itemsByKey = {} : { [x: string]: TItem; }
+>this._itemsByKey = {} : { [x: string]: undefined; }
 >this._itemsByKey : { [x: string]: TItem; }
 >this : BaseCollection2<TItem>
 >_itemsByKey : { [x: string]: TItem; }
->{} : { [x: string]: TItem; }
+>{} : { [x: string]: undefined; }
     }
 }
 
diff --git a/tests/baselines/reference/genericCallWithArrayLiteralArgs.types b/tests/baselines/reference/genericCallWithArrayLiteralArgs.types
index c79efb0792caa..84082a68ebd90 100644
--- a/tests/baselines/reference/genericCallWithArrayLiteralArgs.types
+++ b/tests/baselines/reference/genericCallWithArrayLiteralArgs.types
@@ -25,36 +25,36 @@ var ra = foo<any[]>([1, 2]); // any[]
 >ra : any[]
 >foo<any[]>([1, 2]) : any[]
 >foo : <T>(t: T) => T
->[1, 2] : any[]
+>[1, 2] : number[]
 
 var r2 = foo([]); // any[]
 >r2 : any[]
 >foo([]) : any[]
 >foo : <T>(t: T) => T
->[] : any[]
+>[] : undefined[]
 
 var r3 = foo<number[]>([]); // number[]
 >r3 : number[]
 >foo<number[]>([]) : number[]
 >foo : <T>(t: T) => T
->[] : number[]
+>[] : undefined[]
 
 var r4 = foo([1, '']); // {}[]
->r4 : {}[]
->foo([1, '']) : {}[]
+>r4 : Array<string | number>
+>foo([1, '']) : Array<string | number>
 >foo : <T>(t: T) => T
->[1, ''] : {}[]
+>[1, ''] : Array<string | number>
 
 var r5 = foo<any[]>([1, '']); // any[]
 >r5 : any[]
 >foo<any[]>([1, '']) : any[]
 >foo : <T>(t: T) => T
->[1, ''] : any[]
+>[1, ''] : Array<string | number>
 
 var r6 = foo<Object[]>([1, '']); // Object[]
 >r6 : Object[]
 >foo<Object[]>([1, '']) : Object[]
 >foo : <T>(t: T) => T
 >Object : Object
->[1, ''] : Object[]
+>[1, ''] : Array<string | number>
 
diff --git a/tests/baselines/reference/genericCallWithFunctionTypedArguments.errors.txt b/tests/baselines/reference/genericCallWithFunctionTypedArguments.errors.txt
new file mode 100644
index 0000000000000..36a228683331a
--- /dev/null
+++ b/tests/baselines/reference/genericCallWithFunctionTypedArguments.errors.txt
@@ -0,0 +1,58 @@
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments.ts(26,18): error TS2345: Argument of type '(a: number) => string' is not assignable to parameter of type '(a: number) => number'.
+  Type 'string' is not assignable to type 'number'.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments.ts(30,15): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments.ts(33,15): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments.ts(34,16): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments.ts(35,23): error TS2345: Argument of type '(a: number) => string' is not assignable to parameter of type '(a: number) => number'.
+  Type 'string' is not assignable to type 'number'.
+
+
+==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments.ts (5 errors) ====
+    // Generic functions used as arguments for function typed parameters are not used to make inferences from
+    // Using function arguments, no errors expected
+    
+    function foo<T>(x: (a: T) => T) {
+        return x(null);
+    }
+    
+    var r = foo(<U>(x: U) => ''); // {}
+    var r2 = foo<string>(<U>(x: U) => ''); // string 
+    var r3 = foo(x => ''); // {}
+    
+    function foo2<T, U>(x: T, cb: (a: T) => U) {
+        return cb(x);
+    }
+    
+    var r4 = foo2(1, function <Z>(a: Z) { return '' }); // string, contextual signature instantiation is applied to generic functions
+    var r5 = foo2(1, (a) => ''); // string
+    var r6 = foo2<string, number>('', <Z>(a: Z) => 1);
+    
+    function foo3<T, U>(x: T, cb: (a: T) => U, y: U) {
+        return cb(x);
+    }
+    
+    var r7 = foo3(1, <Z>(a: Z) => '', ''); // string
+    
+    var r8 = foo3(1, function (a) { return '' }, 1); // error
+                     ~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '(a: number) => string' is not assignable to parameter of type '(a: number) => number'.
+!!! error TS2345:   Type 'string' is not assignable to type 'number'.
+    var r9 = foo3<number, string>(1, (a) => '', ''); // string
+    
+    function other<T, U>(t: T, u: U) {
+        var r10 = foo2(1, (x: T) => ''); // error
+                  ~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+        var r10 = foo2(1, (x) => ''); // string
+    
+        var r11 = foo3(1, (x: T) => '', ''); // error
+                  ~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+        var r11b = foo3(1, (x: T) => '', 1); // error
+                   ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+        var r12 = foo3(1, function (a) { return '' }, 1); // error
+                          ~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '(a: number) => string' is not assignable to parameter of type '(a: number) => number'.
+!!! error TS2345:   Type 'string' is not assignable to type 'number'.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/genericCallWithFunctionTypedArguments.js b/tests/baselines/reference/genericCallWithFunctionTypedArguments.js
index 8e844cfbc5a6a..fed1d4ca990c5 100644
--- a/tests/baselines/reference/genericCallWithFunctionTypedArguments.js
+++ b/tests/baselines/reference/genericCallWithFunctionTypedArguments.js
@@ -24,16 +24,16 @@ function foo3<T, U>(x: T, cb: (a: T) => U, y: U) {
 
 var r7 = foo3(1, <Z>(a: Z) => '', ''); // string
 
-var r8 = foo3(1, function (a) { return '' }, 1); // {}
+var r8 = foo3(1, function (a) { return '' }, 1); // error
 var r9 = foo3<number, string>(1, (a) => '', ''); // string
 
 function other<T, U>(t: T, u: U) {
-    var r10 = foo2(1, (x: T) => ''); // string, non-generic signature allows inferences to be made
+    var r10 = foo2(1, (x: T) => ''); // error
     var r10 = foo2(1, (x) => ''); // string
 
-    var r11 = foo3(1, (x: T) => '', ''); // string
-    var r11b = foo3(1, (x: T) => '', 1); // {}
-    var r12 = foo3(1, function (a) { return '' }, 1); // {}
+    var r11 = foo3(1, (x: T) => '', ''); // error
+    var r11b = foo3(1, (x: T) => '', 1); // error
+    var r12 = foo3(1, function (a) { return '' }, 1); // error
 }
 
 //// [genericCallWithFunctionTypedArguments.js]
@@ -59,14 +59,14 @@ function foo3(x, cb, y) {
 var r7 = foo3(1, function (a) { return ''; }, ''); // string
 var r8 = foo3(1, function (a) {
     return '';
-}, 1); // {}
+}, 1); // error
 var r9 = foo3(1, function (a) { return ''; }, ''); // string
 function other(t, u) {
-    var r10 = foo2(1, function (x) { return ''; }); // string, non-generic signature allows inferences to be made
+    var r10 = foo2(1, function (x) { return ''; }); // error
     var r10 = foo2(1, function (x) { return ''; }); // string
-    var r11 = foo3(1, function (x) { return ''; }, ''); // string
-    var r11b = foo3(1, function (x) { return ''; }, 1); // {}
+    var r11 = foo3(1, function (x) { return ''; }, ''); // error
+    var r11b = foo3(1, function (x) { return ''; }, 1); // error
     var r12 = foo3(1, function (a) {
         return '';
-    }, 1); // {}
+    }, 1); // error
 }
diff --git a/tests/baselines/reference/genericCallWithFunctionTypedArguments.types b/tests/baselines/reference/genericCallWithFunctionTypedArguments.types
deleted file mode 100644
index 2d3b234d0e19a..0000000000000
--- a/tests/baselines/reference/genericCallWithFunctionTypedArguments.types
+++ /dev/null
@@ -1,173 +0,0 @@
-=== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments.ts ===
-// Generic functions used as arguments for function typed parameters are not used to make inferences from
-// Using function arguments, no errors expected
-
-function foo<T>(x: (a: T) => T) {
->foo : <T>(x: (a: T) => T) => T
->T : T
->x : (a: T) => T
->a : T
->T : T
->T : T
-
-    return x(null);
->x(null) : T
->x : (a: T) => T
-}
-
-var r = foo(<U>(x: U) => ''); // {}
->r : {}
->foo(<U>(x: U) => '') : {}
->foo : <T>(x: (a: T) => T) => T
-><U>(x: U) => '' : <U>(x: U) => string
->U : U
->x : U
->U : U
-
-var r2 = foo<string>(<U>(x: U) => ''); // string 
->r2 : string
->foo<string>(<U>(x: U) => '') : string
->foo : <T>(x: (a: T) => T) => T
-><U>(x: U) => '' : <U>(x: U) => string
->U : U
->x : U
->U : U
-
-var r3 = foo(x => ''); // {}
->r3 : {}
->foo(x => '') : {}
->foo : <T>(x: (a: T) => T) => T
->x => '' : (x: {}) => string
->x : {}
-
-function foo2<T, U>(x: T, cb: (a: T) => U) {
->foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->T : T
->U : U
->x : T
->T : T
->cb : (a: T) => U
->a : T
->T : T
->U : U
-
-    return cb(x);
->cb(x) : U
->cb : (a: T) => U
->x : T
-}
-
-var r4 = foo2(1, function <Z>(a: Z) { return '' }); // string, contextual signature instantiation is applied to generic functions
->r4 : string
->foo2(1, function <Z>(a: Z) { return '' }) : string
->foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->function <Z>(a: Z) { return '' } : <Z>(a: Z) => string
->Z : Z
->a : Z
->Z : Z
-
-var r5 = foo2(1, (a) => ''); // string
->r5 : string
->foo2(1, (a) => '') : string
->foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->(a) => '' : (a: number) => string
->a : number
-
-var r6 = foo2<string, number>('', <Z>(a: Z) => 1);
->r6 : number
->foo2<string, number>('', <Z>(a: Z) => 1) : number
->foo2 : <T, U>(x: T, cb: (a: T) => U) => U
-><Z>(a: Z) => 1 : <Z>(a: Z) => number
->Z : Z
->a : Z
->Z : Z
-
-function foo3<T, U>(x: T, cb: (a: T) => U, y: U) {
->foo3 : <T, U>(x: T, cb: (a: T) => U, y: U) => U
->T : T
->U : U
->x : T
->T : T
->cb : (a: T) => U
->a : T
->T : T
->U : U
->y : U
->U : U
-
-    return cb(x);
->cb(x) : U
->cb : (a: T) => U
->x : T
-}
-
-var r7 = foo3(1, <Z>(a: Z) => '', ''); // string
->r7 : string
->foo3(1, <Z>(a: Z) => '', '') : string
->foo3 : <T, U>(x: T, cb: (a: T) => U, y: U) => U
-><Z>(a: Z) => '' : <Z>(a: Z) => string
->Z : Z
->a : Z
->Z : Z
-
-var r8 = foo3(1, function (a) { return '' }, 1); // {}
->r8 : {}
->foo3(1, function (a) { return '' }, 1) : {}
->foo3 : <T, U>(x: T, cb: (a: T) => U, y: U) => U
->function (a) { return '' } : (a: number) => string
->a : number
-
-var r9 = foo3<number, string>(1, (a) => '', ''); // string
->r9 : string
->foo3<number, string>(1, (a) => '', '') : string
->foo3 : <T, U>(x: T, cb: (a: T) => U, y: U) => U
->(a) => '' : (a: number) => string
->a : number
-
-function other<T, U>(t: T, u: U) {
->other : <T, U>(t: T, u: U) => void
->T : T
->U : U
->t : T
->T : T
->u : U
->U : U
-
-    var r10 = foo2(1, (x: T) => ''); // string, non-generic signature allows inferences to be made
->r10 : string
->foo2(1, (x: T) => '') : string
->foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->(x: T) => '' : (x: T) => string
->x : T
->T : T
-
-    var r10 = foo2(1, (x) => ''); // string
->r10 : string
->foo2(1, (x) => '') : string
->foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->(x) => '' : (x: number) => string
->x : number
-
-    var r11 = foo3(1, (x: T) => '', ''); // string
->r11 : string
->foo3(1, (x: T) => '', '') : string
->foo3 : <T, U>(x: T, cb: (a: T) => U, y: U) => U
->(x: T) => '' : (x: T) => string
->x : T
->T : T
-
-    var r11b = foo3(1, (x: T) => '', 1); // {}
->r11b : {}
->foo3(1, (x: T) => '', 1) : {}
->foo3 : <T, U>(x: T, cb: (a: T) => U, y: U) => U
->(x: T) => '' : (x: T) => string
->x : T
->T : T
-
-    var r12 = foo3(1, function (a) { return '' }, 1); // {}
->r12 : {}
->foo3(1, function (a) { return '' }, 1) : {}
->foo3 : <T, U>(x: T, cb: (a: T) => U, y: U) => U
->function (a) { return '' } : (a: number) => string
->a : number
-}
diff --git a/tests/baselines/reference/genericCallWithFunctionTypedArguments2.errors.txt b/tests/baselines/reference/genericCallWithFunctionTypedArguments2.errors.txt
new file mode 100644
index 0000000000000..083d197bbb40d
--- /dev/null
+++ b/tests/baselines/reference/genericCallWithFunctionTypedArguments2.errors.txt
@@ -0,0 +1,50 @@
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments2.ts(29,10): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments2.ts(40,10): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments2.ts (2 errors) ====
+    // Generic functions used as arguments for function typed parameters are not used to make inferences from
+    // Using construct signature arguments, no errors expected
+    
+    function foo<T>(x: new(a: T) => T) {
+        return new x(null);
+    }
+    
+    interface I {
+        new <T>(x: T): T;
+    }
+    interface I2<T> {
+        new (x: T): T;
+    }
+    var i: I;
+    var i2: I2<string>;
+    var a: {
+        new <T>(x: T): T;
+    }
+    
+    var r = foo(i); // any
+    var r2 = foo<string>(i); // string 
+    var r3 = foo(i2); // string
+    var r3b = foo(a); // any
+    
+    function foo2<T, U>(x: T, cb: new(a: T) => U) {
+        return new cb(x);
+    }
+    
+    var r4 = foo2(1, i2); // error
+             ~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    var r4b = foo2(1, a); // any
+    var r5 = foo2(1, i); // any
+    var r6 = foo2<string, string>('', i2); // string
+    
+    function foo3<T, U>(x: T, cb: new(a: T) => U, y: U) {
+        return new cb(x);
+    }
+    
+    var r7 = foo3(null, i, ''); // any
+    var r7b = foo3(null, a, ''); // any
+    var r8 = foo3(1, i2, 1); // error
+             ~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    var r9 = foo3<string, string>('', i2, ''); // string
\ No newline at end of file
diff --git a/tests/baselines/reference/genericCallWithFunctionTypedArguments2.js b/tests/baselines/reference/genericCallWithFunctionTypedArguments2.js
index ca9b79c3507ee..7e9b7886fb476 100644
--- a/tests/baselines/reference/genericCallWithFunctionTypedArguments2.js
+++ b/tests/baselines/reference/genericCallWithFunctionTypedArguments2.js
@@ -27,7 +27,7 @@ function foo2<T, U>(x: T, cb: new(a: T) => U) {
     return new cb(x);
 }
 
-var r4 = foo2(1, i2); // string, instantiated generic
+var r4 = foo2(1, i2); // error
 var r4b = foo2(1, a); // any
 var r5 = foo2(1, i); // any
 var r6 = foo2<string, string>('', i2); // string
@@ -38,7 +38,7 @@ function foo3<T, U>(x: T, cb: new(a: T) => U, y: U) {
 
 var r7 = foo3(null, i, ''); // any
 var r7b = foo3(null, a, ''); // any
-var r8 = foo3(1, i2, 1); // {}
+var r8 = foo3(1, i2, 1); // error
 var r9 = foo3<string, string>('', i2, ''); // string
 
 //// [genericCallWithFunctionTypedArguments2.js]
@@ -57,7 +57,7 @@ var r3b = foo(a); // any
 function foo2(x, cb) {
     return new cb(x);
 }
-var r4 = foo2(1, i2); // string, instantiated generic
+var r4 = foo2(1, i2); // error
 var r4b = foo2(1, a); // any
 var r5 = foo2(1, i); // any
 var r6 = foo2('', i2); // string
@@ -66,5 +66,5 @@ function foo3(x, cb, y) {
 }
 var r7 = foo3(null, i, ''); // any
 var r7b = foo3(null, a, ''); // any
-var r8 = foo3(1, i2, 1); // {}
+var r8 = foo3(1, i2, 1); // error
 var r9 = foo3('', i2, ''); // string
diff --git a/tests/baselines/reference/genericCallWithFunctionTypedArguments2.types b/tests/baselines/reference/genericCallWithFunctionTypedArguments2.types
deleted file mode 100644
index 89d7afd94e224..0000000000000
--- a/tests/baselines/reference/genericCallWithFunctionTypedArguments2.types
+++ /dev/null
@@ -1,161 +0,0 @@
-=== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments2.ts ===
-// Generic functions used as arguments for function typed parameters are not used to make inferences from
-// Using construct signature arguments, no errors expected
-
-function foo<T>(x: new(a: T) => T) {
->foo : <T>(x: new (a: T) => T) => T
->T : T
->x : new (a: T) => T
->a : T
->T : T
->T : T
-
-    return new x(null);
->new x(null) : T
->x : new (a: T) => T
-}
-
-interface I {
->I : I
-
-    new <T>(x: T): T;
->T : T
->x : T
->T : T
->T : T
-}
-interface I2<T> {
->I2 : I2<T>
->T : T
-
-    new (x: T): T;
->x : T
->T : T
->T : T
-}
-var i: I;
->i : I
->I : I
-
-var i2: I2<string>;
->i2 : I2<string>
->I2 : I2<T>
-
-var a: {
->a : new <T>(x: T) => T
-
-    new <T>(x: T): T;
->T : T
->x : T
->T : T
->T : T
-}
-
-var r = foo(i); // any
->r : any
->foo(i) : any
->foo : <T>(x: new (a: T) => T) => T
->i : I
-
-var r2 = foo<string>(i); // string 
->r2 : string
->foo<string>(i) : string
->foo : <T>(x: new (a: T) => T) => T
->i : I
-
-var r3 = foo(i2); // string
->r3 : string
->foo(i2) : string
->foo : <T>(x: new (a: T) => T) => T
->i2 : I2<string>
-
-var r3b = foo(a); // any
->r3b : any
->foo(a) : any
->foo : <T>(x: new (a: T) => T) => T
->a : new <T>(x: T) => T
-
-function foo2<T, U>(x: T, cb: new(a: T) => U) {
->foo2 : <T, U>(x: T, cb: new (a: T) => U) => U
->T : T
->U : U
->x : T
->T : T
->cb : new (a: T) => U
->a : T
->T : T
->U : U
-
-    return new cb(x);
->new cb(x) : U
->cb : new (a: T) => U
->x : T
-}
-
-var r4 = foo2(1, i2); // string, instantiated generic
->r4 : string
->foo2(1, i2) : string
->foo2 : <T, U>(x: T, cb: new (a: T) => U) => U
->i2 : I2<string>
-
-var r4b = foo2(1, a); // any
->r4b : any
->foo2(1, a) : any
->foo2 : <T, U>(x: T, cb: new (a: T) => U) => U
->a : new <T>(x: T) => T
-
-var r5 = foo2(1, i); // any
->r5 : any
->foo2(1, i) : any
->foo2 : <T, U>(x: T, cb: new (a: T) => U) => U
->i : I
-
-var r6 = foo2<string, string>('', i2); // string
->r6 : string
->foo2<string, string>('', i2) : string
->foo2 : <T, U>(x: T, cb: new (a: T) => U) => U
->i2 : I2<string>
-
-function foo3<T, U>(x: T, cb: new(a: T) => U, y: U) {
->foo3 : <T, U>(x: T, cb: new (a: T) => U, y: U) => U
->T : T
->U : U
->x : T
->T : T
->cb : new (a: T) => U
->a : T
->T : T
->U : U
->y : U
->U : U
-
-    return new cb(x);
->new cb(x) : U
->cb : new (a: T) => U
->x : T
-}
-
-var r7 = foo3(null, i, ''); // any
->r7 : any
->foo3(null, i, '') : any
->foo3 : <T, U>(x: T, cb: new (a: T) => U, y: U) => U
->i : I
-
-var r7b = foo3(null, a, ''); // any
->r7b : any
->foo3(null, a, '') : any
->foo3 : <T, U>(x: T, cb: new (a: T) => U, y: U) => U
->a : new <T>(x: T) => T
-
-var r8 = foo3(1, i2, 1); // {}
->r8 : {}
->foo3(1, i2, 1) : {}
->foo3 : <T, U>(x: T, cb: new (a: T) => U, y: U) => U
->i2 : I2<string>
-
-var r9 = foo3<string, string>('', i2, ''); // string
->r9 : string
->foo3<string, string>('', i2, '') : string
->foo3 : <T, U>(x: T, cb: new (a: T) => U, y: U) => U
->i2 : I2<string>
-
diff --git a/tests/baselines/reference/genericCallWithGenericSignatureArguments2.errors.txt b/tests/baselines/reference/genericCallWithGenericSignatureArguments2.errors.txt
index 7f4fa26aad132..55318f268bde1 100644
--- a/tests/baselines/reference/genericCallWithGenericSignatureArguments2.errors.txt
+++ b/tests/baselines/reference/genericCallWithGenericSignatureArguments2.errors.txt
@@ -1,51 +1,106 @@
-tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts(14,17): error TS2345: Argument of type 'Date' is not assignable to parameter of type 'T'.
-tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts(15,18): error TS2345: Argument of type 'number' is not assignable to parameter of type 'T'.
-tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts(24,19): error TS2345: Argument of type '(a: T) => T' is not assignable to parameter of type '(x: Date) => Date'.
-tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts(36,32): error TS2345: Argument of type '(x: E) => F' is not assignable to parameter of type '(x: E) => E'.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts(10,29): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts(15,21): error TS2345: Argument of type 'Date' is not assignable to parameter of type 'T'.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts(16,22): error TS2345: Argument of type 'number' is not assignable to parameter of type 'T'.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts(25,23): error TS2345: Argument of type '(a: T) => T' is not assignable to parameter of type '(x: Date) => Date'.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts(37,36): error TS2345: Argument of type '(x: E) => F' is not assignable to parameter of type '(x: E) => E'.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts(50,21): error TS2345: Argument of type 'Date' is not assignable to parameter of type 'T'.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts(51,22): error TS2345: Argument of type 'number' is not assignable to parameter of type 'T'.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts(60,23): error TS2345: Argument of type '(a: T) => T' is not assignable to parameter of type '(x: Date) => Date'.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts(67,51): error TS2304: Cannot find name 'U'.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts(67,57): error TS2304: Cannot find name 'U'.
 
 
-==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts (4 errors) ====
+==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts (10 errors) ====
     // When a function expression is inferentially typed (section 4.9.3) and a type assigned to a parameter in that expression references type parameters for which inferences are being made, 
     // the corresponding inferred type arguments to become fixed and no further candidate inferences are made for them.
     
-    function foo<T>(a: (x: T) => T, b: (x: T) => T) {
-        var r: (x: T) => T;
-        return r;
-    }
+    module onlyT {
+        function foo<T>(a: (x: T) => T, b: (x: T) => T) {
+            var r: (x: T) => T;
+            return r;
+        }
     
-    var r1: (x: {}) => {} = foo((x: number) => 1, (x: string) => '');
+        var r1: (x: {}) => {} = foo((x: number) => 1, (x: string) => '');
+                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     
-    function other2<T extends Date>(x: T) {
-        var r7 = foo((a: T) => a, (b: T) => b); // T => T
-        // BUG 835518
-        var r9 = r7(new Date()); // should be ok
-                    ~~~~~~~~~~
+        function other2<T extends Date>(x: T) {
+            var r7 = foo((a: T) => a, (b: T) => b); // T => T
+            // BUG 835518
+            var r9 = r7(new Date()); // should be ok
+                        ~~~~~~~~~~
 !!! error TS2345: Argument of type 'Date' is not assignable to parameter of type 'T'.
-        var r10 = r7(1); // error
-                     ~
+            var r10 = r7(1); // error
+                         ~
 !!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'T'.
-    }
+        }
     
-    function foo2<T extends Date>(a: (x: T) => T, b: (x: T) => T) {
-        var r: (x: T) => T;
-        return r;
-    }
+        function foo2<T extends Date>(a: (x: T) => T, b: (x: T) => T) {
+            var r: (x: T) => T;
+            return r;
+        }
     
-    function other3<T extends RegExp>(x: T) {
-        var r7 = foo2((a: T) => a, (b: T) => b); // error
-                      ~~~~~~~~~~~
+        function other3<T extends RegExp>(x: T) {
+            var r7 = foo2((a: T) => a, (b: T) => b); // error
+                          ~~~~~~~~~~~
 !!! error TS2345: Argument of type '(a: T) => T' is not assignable to parameter of type '(x: Date) => Date'.
-        var r7b = foo2((a) => a, (b) => b); // valid, T is inferred to be Date
-    }
+            var r7b = foo2((a) => a, (b) => b); // valid, T is inferred to be Date
+        }
     
-    enum E { A }
-    enum F { A }
+        enum E { A }
+        enum F { A }
     
-    function foo3<T>(x: T, a: (x: T) => T, b: (x: T) => T) {
-        var r: (x: T) => T;
-        return r;
+        function foo3<T>(x: T, a: (x: T) => T, b: (x: T) => T) {
+            var r: (x: T) => T;
+            return r;
+        }
+    
+        var r7 = foo3(E.A, (x) => E.A, (x) => F.A); // error
+                                       ~~~~~~~~~~
+!!! error TS2345: Argument of type '(x: E) => F' is not assignable to parameter of type '(x: E) => E'.
     }
     
-    var r7 = foo3(E.A, (x) => E.A, (x) => F.A); // error
-                                   ~~~~~~~~~~
-!!! error TS2345: Argument of type '(x: E) => F' is not assignable to parameter of type '(x: E) => E'.
\ No newline at end of file
+    module TU {
+        function foo<T, U>(a: (x: T) => T, b: (x: U) => U) {
+            var r: (x: T) => T;
+            return r;
+        }
+    
+        var r1: (x: {}) => {} = foo((x: number) => 1, (x: string) => '');
+    
+        function other2<T extends Date>(x: T) {
+            var r7 = foo((a: T) => a, (b: T) => b); 
+            var r9 = r7(new Date()); 
+                        ~~~~~~~~~~
+!!! error TS2345: Argument of type 'Date' is not assignable to parameter of type 'T'.
+            var r10 = r7(1); 
+                         ~
+!!! error TS2345: Argument of type 'number' is not assignable to parameter of type 'T'.
+        }
+    
+        function foo2<T extends Date, U extends Date>(a: (x: T) => T, b: (x: U) => U) {
+            var r: (x: T) => T;
+            return r;
+        }
+    
+        function other3<T extends RegExp>(x: T) {
+            var r7 = foo2((a: T) => a, (b: T) => b); 
+                          ~~~~~~~~~~~
+!!! error TS2345: Argument of type '(a: T) => T' is not assignable to parameter of type '(x: Date) => Date'.
+            var r7b = foo2((a) => a, (b) => b); 
+        }
+    
+        enum E { A }
+        enum F { A }
+    
+        function foo3<T>(x: T, a: (x: T) => T, b: (x: U) => U) {
+                                                      ~
+!!! error TS2304: Cannot find name 'U'.
+                                                            ~
+!!! error TS2304: Cannot find name 'U'.
+            var r: (x: T) => T;
+            return r;
+        }
+    
+        var r7 = foo3(E.A, (x) => E.A, (x) => F.A);
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/genericCallWithGenericSignatureArguments2.js b/tests/baselines/reference/genericCallWithGenericSignatureArguments2.js
index 7dc955b617255..7acdcc32536b3 100644
--- a/tests/baselines/reference/genericCallWithGenericSignatureArguments2.js
+++ b/tests/baselines/reference/genericCallWithGenericSignatureArguments2.js
@@ -2,72 +2,146 @@
 // When a function expression is inferentially typed (section 4.9.3) and a type assigned to a parameter in that expression references type parameters for which inferences are being made, 
 // the corresponding inferred type arguments to become fixed and no further candidate inferences are made for them.
 
-function foo<T>(a: (x: T) => T, b: (x: T) => T) {
-    var r: (x: T) => T;
-    return r;
-}
+module onlyT {
+    function foo<T>(a: (x: T) => T, b: (x: T) => T) {
+        var r: (x: T) => T;
+        return r;
+    }
 
-var r1: (x: {}) => {} = foo((x: number) => 1, (x: string) => '');
+    var r1: (x: {}) => {} = foo((x: number) => 1, (x: string) => '');
 
-function other2<T extends Date>(x: T) {
-    var r7 = foo((a: T) => a, (b: T) => b); // T => T
-    // BUG 835518
-    var r9 = r7(new Date()); // should be ok
-    var r10 = r7(1); // error
-}
+    function other2<T extends Date>(x: T) {
+        var r7 = foo((a: T) => a, (b: T) => b); // T => T
+        // BUG 835518
+        var r9 = r7(new Date()); // should be ok
+        var r10 = r7(1); // error
+    }
 
-function foo2<T extends Date>(a: (x: T) => T, b: (x: T) => T) {
-    var r: (x: T) => T;
-    return r;
-}
+    function foo2<T extends Date>(a: (x: T) => T, b: (x: T) => T) {
+        var r: (x: T) => T;
+        return r;
+    }
 
-function other3<T extends RegExp>(x: T) {
-    var r7 = foo2((a: T) => a, (b: T) => b); // error
-    var r7b = foo2((a) => a, (b) => b); // valid, T is inferred to be Date
-}
+    function other3<T extends RegExp>(x: T) {
+        var r7 = foo2((a: T) => a, (b: T) => b); // error
+        var r7b = foo2((a) => a, (b) => b); // valid, T is inferred to be Date
+    }
+
+    enum E { A }
+    enum F { A }
 
-enum E { A }
-enum F { A }
+    function foo3<T>(x: T, a: (x: T) => T, b: (x: T) => T) {
+        var r: (x: T) => T;
+        return r;
+    }
 
-function foo3<T>(x: T, a: (x: T) => T, b: (x: T) => T) {
-    var r: (x: T) => T;
-    return r;
+    var r7 = foo3(E.A, (x) => E.A, (x) => F.A); // error
 }
 
-var r7 = foo3(E.A, (x) => E.A, (x) => F.A); // error
+module TU {
+    function foo<T, U>(a: (x: T) => T, b: (x: U) => U) {
+        var r: (x: T) => T;
+        return r;
+    }
+
+    var r1: (x: {}) => {} = foo((x: number) => 1, (x: string) => '');
+
+    function other2<T extends Date>(x: T) {
+        var r7 = foo((a: T) => a, (b: T) => b); 
+        var r9 = r7(new Date()); 
+        var r10 = r7(1); 
+    }
+
+    function foo2<T extends Date, U extends Date>(a: (x: T) => T, b: (x: U) => U) {
+        var r: (x: T) => T;
+        return r;
+    }
+
+    function other3<T extends RegExp>(x: T) {
+        var r7 = foo2((a: T) => a, (b: T) => b); 
+        var r7b = foo2((a) => a, (b) => b); 
+    }
+
+    enum E { A }
+    enum F { A }
+
+    function foo3<T>(x: T, a: (x: T) => T, b: (x: U) => U) {
+        var r: (x: T) => T;
+        return r;
+    }
+
+    var r7 = foo3(E.A, (x) => E.A, (x) => F.A);
+}
 
 //// [genericCallWithGenericSignatureArguments2.js]
 // When a function expression is inferentially typed (section 4.9.3) and a type assigned to a parameter in that expression references type parameters for which inferences are being made, 
 // the corresponding inferred type arguments to become fixed and no further candidate inferences are made for them.
-function foo(a, b) {
-    var r;
-    return r;
-}
-var r1 = foo(function (x) { return 1; }, function (x) { return ''; });
-function other2(x) {
-    var r7 = foo(function (a) { return a; }, function (b) { return b; }); // T => T
-    // BUG 835518
-    var r9 = r7(new Date()); // should be ok
-    var r10 = r7(1); // error
-}
-function foo2(a, b) {
-    var r;
-    return r;
-}
-function other3(x) {
-    var r7 = foo2(function (a) { return a; }, function (b) { return b; }); // error
-    var r7b = foo2(function (a) { return a; }, function (b) { return b; }); // valid, T is inferred to be Date
-}
-var E;
-(function (E) {
-    E[E["A"] = 0] = "A";
-})(E || (E = {}));
-var F;
-(function (F) {
-    F[F["A"] = 0] = "A";
-})(F || (F = {}));
-function foo3(x, a, b) {
-    var r;
-    return r;
-}
-var r7 = foo3(0 /* A */, function (x) { return 0 /* A */; }, function (x) { return 0 /* A */; }); // error
+var onlyT;
+(function (onlyT) {
+    function foo(a, b) {
+        var r;
+        return r;
+    }
+    var r1 = foo(function (x) { return 1; }, function (x) { return ''; });
+    function other2(x) {
+        var r7 = foo(function (a) { return a; }, function (b) { return b; }); // T => T
+        // BUG 835518
+        var r9 = r7(new Date()); // should be ok
+        var r10 = r7(1); // error
+    }
+    function foo2(a, b) {
+        var r;
+        return r;
+    }
+    function other3(x) {
+        var r7 = foo2(function (a) { return a; }, function (b) { return b; }); // error
+        var r7b = foo2(function (a) { return a; }, function (b) { return b; }); // valid, T is inferred to be Date
+    }
+    var E;
+    (function (E) {
+        E[E["A"] = 0] = "A";
+    })(E || (E = {}));
+    var F;
+    (function (F) {
+        F[F["A"] = 0] = "A";
+    })(F || (F = {}));
+    function foo3(x, a, b) {
+        var r;
+        return r;
+    }
+    var r7 = foo3(0 /* A */, function (x) { return 0 /* A */; }, function (x) { return 0 /* A */; }); // error
+})(onlyT || (onlyT = {}));
+var TU;
+(function (TU) {
+    function foo(a, b) {
+        var r;
+        return r;
+    }
+    var r1 = foo(function (x) { return 1; }, function (x) { return ''; });
+    function other2(x) {
+        var r7 = foo(function (a) { return a; }, function (b) { return b; });
+        var r9 = r7(new Date());
+        var r10 = r7(1);
+    }
+    function foo2(a, b) {
+        var r;
+        return r;
+    }
+    function other3(x) {
+        var r7 = foo2(function (a) { return a; }, function (b) { return b; });
+        var r7b = foo2(function (a) { return a; }, function (b) { return b; });
+    }
+    var E;
+    (function (E) {
+        E[E["A"] = 0] = "A";
+    })(E || (E = {}));
+    var F;
+    (function (F) {
+        F[F["A"] = 0] = "A";
+    })(F || (F = {}));
+    function foo3(x, a, b) {
+        var r;
+        return r;
+    }
+    var r7 = foo3(0 /* A */, function (x) { return 0 /* A */; }, function (x) { return 0 /* A */; });
+})(TU || (TU = {}));
diff --git a/tests/baselines/reference/genericCallWithGenericSignatureArguments3.errors.txt b/tests/baselines/reference/genericCallWithGenericSignatureArguments3.errors.txt
new file mode 100644
index 0000000000000..0a42d94062584
--- /dev/null
+++ b/tests/baselines/reference/genericCallWithGenericSignatureArguments3.errors.txt
@@ -0,0 +1,42 @@
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments3.ts(32,11): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments3.ts(33,11): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments3.ts (2 errors) ====
+    // When a function expression is inferentially typed (section 4.9.3) and a type assigned to a parameter in that expression references type parameters for which inferences are being made, 
+    // the corresponding inferred type arguments to become fixed and no further candidate inferences are made for them.
+    
+    function foo<T>(x: T, a: (x: T) => T, b: (x: T) => T) {
+        var r: (x: T) => T;
+        return r;
+    }
+    
+    var r1 = foo('', (x: string) => '', (x: Object) => null); // any => any
+    var r1ii = foo('', (x) => '', (x) => null); // string => string
+    var r2 = foo('', (x: string) => '', (x: Object) => ''); // string => string
+    var r3 = foo(null, (x: Object) => '', (x: string) => ''); // Object => Object
+    var r4 = foo(null, (x) => '', (x) => ''); // any => any
+    var r5 = foo(new Object(), (x) => '', (x) => ''); // Object => Object
+    
+    enum E { A }
+    enum F { A }
+    
+    var r6 = foo(E.A, (x: number) => E.A, (x: F) => F.A); // number => number 
+    
+    
+    function foo2<T, U>(x: T, a: (x: T) => U, b: (x: T) => U) {
+        var r: (x: T) => U;
+        return r;
+    }
+    
+    var r8 = foo2('', (x) => '', (x) => null); // string => string
+    var r9 = foo2(null, (x) => '', (x) => ''); // any => any
+    var r10 = foo2(null, (x: Object) => '', (x: string) => ''); // Object => Object
+    
+    var x: (a: string) => boolean;
+    var r11 = foo2(x, (a1: (y: string) => string) => (n: Object) => 1, (a2: (z: string) => string) => 2); // error
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    var r12 = foo2(x, (a1: (y: string) => boolean) => (n: Object) => 1, (a2: (z: string) => boolean) => 2); // error
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
\ No newline at end of file
diff --git a/tests/baselines/reference/genericCallWithGenericSignatureArguments3.js b/tests/baselines/reference/genericCallWithGenericSignatureArguments3.js
index 8ffb4f9970be7..ca28878daa389 100644
--- a/tests/baselines/reference/genericCallWithGenericSignatureArguments3.js
+++ b/tests/baselines/reference/genericCallWithGenericSignatureArguments3.js
@@ -30,8 +30,8 @@ var r9 = foo2(null, (x) => '', (x) => ''); // any => any
 var r10 = foo2(null, (x: Object) => '', (x: string) => ''); // Object => Object
 
 var x: (a: string) => boolean;
-var r11 = foo2(x, (a1: (y: string) => string) => (n: Object) => 1, (a2: (z: string) => string) => 2); // {} => {}
-var r12 = foo2(x, (a1: (y: string) => boolean) => (n: Object) => 1, (a2: (z: string) => boolean) => 2); // (string => boolean) => {}
+var r11 = foo2(x, (a1: (y: string) => string) => (n: Object) => 1, (a2: (z: string) => string) => 2); // error
+var r12 = foo2(x, (a1: (y: string) => boolean) => (n: Object) => 1, (a2: (z: string) => boolean) => 2); // error
 
 //// [genericCallWithGenericSignatureArguments3.js]
 // When a function expression is inferentially typed (section 4.9.3) and a type assigned to a parameter in that expression references type parameters for which inferences are being made, 
@@ -63,5 +63,5 @@ var r8 = foo2('', function (x) { return ''; }, function (x) { return null; }); /
 var r9 = foo2(null, function (x) { return ''; }, function (x) { return ''; }); // any => any
 var r10 = foo2(null, function (x) { return ''; }, function (x) { return ''; }); // Object => Object
 var x;
-var r11 = foo2(x, function (a1) { return function (n) { return 1; }; }, function (a2) { return 2; }); // {} => {}
-var r12 = foo2(x, function (a1) { return function (n) { return 1; }; }, function (a2) { return 2; }); // (string => boolean) => {}
+var r11 = foo2(x, function (a1) { return function (n) { return 1; }; }, function (a2) { return 2; }); // error
+var r12 = foo2(x, function (a1) { return function (n) { return 1; }; }, function (a2) { return 2; }); // error
diff --git a/tests/baselines/reference/genericCallWithGenericSignatureArguments3.types b/tests/baselines/reference/genericCallWithGenericSignatureArguments3.types
deleted file mode 100644
index 2c0d21a5a07f3..0000000000000
--- a/tests/baselines/reference/genericCallWithGenericSignatureArguments3.types
+++ /dev/null
@@ -1,202 +0,0 @@
-=== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments3.ts ===
-// When a function expression is inferentially typed (section 4.9.3) and a type assigned to a parameter in that expression references type parameters for which inferences are being made, 
-// the corresponding inferred type arguments to become fixed and no further candidate inferences are made for them.
-
-function foo<T>(x: T, a: (x: T) => T, b: (x: T) => T) {
->foo : <T>(x: T, a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->T : T
->x : T
->T : T
->a : (x: T) => T
->x : T
->T : T
->T : T
->b : (x: T) => T
->x : T
->T : T
->T : T
-
-    var r: (x: T) => T;
->r : (x: T) => T
->x : T
->T : T
->T : T
-
-    return r;
->r : (x: T) => T
-}
-
-var r1 = foo('', (x: string) => '', (x: Object) => null); // any => any
->r1 : (x: any) => any
->foo('', (x: string) => '', (x: Object) => null) : (x: any) => any
->foo : <T>(x: T, a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(x: string) => '' : (x: string) => string
->x : string
->(x: Object) => null : (x: Object) => any
->x : Object
->Object : Object
-
-var r1ii = foo('', (x) => '', (x) => null); // string => string
->r1ii : (x: string) => string
->foo('', (x) => '', (x) => null) : (x: string) => string
->foo : <T>(x: T, a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(x) => '' : (x: string) => string
->x : string
->(x) => null : (x: string) => any
->x : string
-
-var r2 = foo('', (x: string) => '', (x: Object) => ''); // string => string
->r2 : (x: Object) => Object
->foo('', (x: string) => '', (x: Object) => '') : (x: Object) => Object
->foo : <T>(x: T, a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(x: string) => '' : (x: string) => string
->x : string
->(x: Object) => '' : (x: Object) => string
->x : Object
->Object : Object
-
-var r3 = foo(null, (x: Object) => '', (x: string) => ''); // Object => Object
->r3 : (x: Object) => Object
->foo(null, (x: Object) => '', (x: string) => '') : (x: Object) => Object
->foo : <T>(x: T, a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(x: Object) => '' : (x: Object) => string
->x : Object
->Object : Object
->(x: string) => '' : (x: string) => string
->x : string
-
-var r4 = foo(null, (x) => '', (x) => ''); // any => any
->r4 : (x: any) => any
->foo(null, (x) => '', (x) => '') : (x: any) => any
->foo : <T>(x: T, a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->(x) => '' : (x: any) => string
->x : any
->(x) => '' : (x: any) => string
->x : any
-
-var r5 = foo(new Object(), (x) => '', (x) => ''); // Object => Object
->r5 : (x: Object) => Object
->foo(new Object(), (x) => '', (x) => '') : (x: Object) => Object
->foo : <T>(x: T, a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->new Object() : Object
->Object : { (): any; (value: any): any; new (value?: any): Object; prototype: Object; getPrototypeOf(o: any): any; getOwnPropertyDescriptor(o: any, p: string): PropertyDescriptor; getOwnPropertyNames(o: any): string[]; create(o: any, properties?: PropertyDescriptorMap): any; defineProperty(o: any, p: string, attributes: PropertyDescriptor): any; defineProperties(o: any, properties: PropertyDescriptorMap): any; seal(o: any): any; freeze(o: any): any; preventExtensions(o: any): any; isSealed(o: any): boolean; isFrozen(o: any): boolean; isExtensible(o: any): boolean; keys(o: any): string[]; }
->(x) => '' : (x: Object) => string
->x : Object
->(x) => '' : (x: Object) => string
->x : Object
-
-enum E { A }
->E : E
->A : E
-
-enum F { A }
->F : F
->A : F
-
-var r6 = foo(E.A, (x: number) => E.A, (x: F) => F.A); // number => number 
->r6 : (x: number) => number
->foo(E.A, (x: number) => E.A, (x: F) => F.A) : (x: number) => number
->foo : <T>(x: T, a: (x: T) => T, b: (x: T) => T) => (x: T) => T
->E.A : E
->E : typeof E
->A : E
->(x: number) => E.A : (x: number) => E
->x : number
->E.A : E
->E : typeof E
->A : E
->(x: F) => F.A : (x: F) => F
->x : F
->F : F
->F.A : F
->F : typeof F
->A : F
-
-
-function foo2<T, U>(x: T, a: (x: T) => U, b: (x: T) => U) {
->foo2 : <T, U>(x: T, a: (x: T) => U, b: (x: T) => U) => (x: T) => U
->T : T
->U : U
->x : T
->T : T
->a : (x: T) => U
->x : T
->T : T
->U : U
->b : (x: T) => U
->x : T
->T : T
->U : U
-
-    var r: (x: T) => U;
->r : (x: T) => U
->x : T
->T : T
->U : U
-
-    return r;
->r : (x: T) => U
-}
-
-var r8 = foo2('', (x) => '', (x) => null); // string => string
->r8 : (x: string) => any
->foo2('', (x) => '', (x) => null) : (x: string) => any
->foo2 : <T, U>(x: T, a: (x: T) => U, b: (x: T) => U) => (x: T) => U
->(x) => '' : (x: string) => string
->x : string
->(x) => null : (x: string) => any
->x : string
-
-var r9 = foo2(null, (x) => '', (x) => ''); // any => any
->r9 : (x: any) => string
->foo2(null, (x) => '', (x) => '') : (x: any) => string
->foo2 : <T, U>(x: T, a: (x: T) => U, b: (x: T) => U) => (x: T) => U
->(x) => '' : (x: any) => string
->x : any
->(x) => '' : (x: any) => string
->x : any
-
-var r10 = foo2(null, (x: Object) => '', (x: string) => ''); // Object => Object
->r10 : (x: Object) => string
->foo2(null, (x: Object) => '', (x: string) => '') : (x: Object) => string
->foo2 : <T, U>(x: T, a: (x: T) => U, b: (x: T) => U) => (x: T) => U
->(x: Object) => '' : (x: Object) => string
->x : Object
->Object : Object
->(x: string) => '' : (x: string) => string
->x : string
-
-var x: (a: string) => boolean;
->x : (a: string) => boolean
->a : string
-
-var r11 = foo2(x, (a1: (y: string) => string) => (n: Object) => 1, (a2: (z: string) => string) => 2); // {} => {}
->r11 : (x: {}) => {}
->foo2(x, (a1: (y: string) => string) => (n: Object) => 1, (a2: (z: string) => string) => 2) : (x: {}) => {}
->foo2 : <T, U>(x: T, a: (x: T) => U, b: (x: T) => U) => (x: T) => U
->x : (a: string) => boolean
->(a1: (y: string) => string) => (n: Object) => 1 : (a1: (y: string) => string) => (n: Object) => number
->a1 : (y: string) => string
->y : string
->(n: Object) => 1 : (n: Object) => number
->n : Object
->Object : Object
->(a2: (z: string) => string) => 2 : (a2: (z: string) => string) => number
->a2 : (z: string) => string
->z : string
-
-var r12 = foo2(x, (a1: (y: string) => boolean) => (n: Object) => 1, (a2: (z: string) => boolean) => 2); // (string => boolean) => {}
->r12 : (x: (a: string) => boolean) => {}
->foo2(x, (a1: (y: string) => boolean) => (n: Object) => 1, (a2: (z: string) => boolean) => 2) : (x: (a: string) => boolean) => {}
->foo2 : <T, U>(x: T, a: (x: T) => U, b: (x: T) => U) => (x: T) => U
->x : (a: string) => boolean
->(a1: (y: string) => boolean) => (n: Object) => 1 : (a1: (y: string) => boolean) => (n: Object) => number
->a1 : (y: string) => boolean
->y : string
->(n: Object) => 1 : (n: Object) => number
->n : Object
->Object : Object
->(a2: (z: string) => boolean) => 2 : (a2: (z: string) => boolean) => number
->a2 : (z: string) => boolean
->z : string
-
diff --git a/tests/baselines/reference/genericCallWithObjectLiteralArgs.errors.txt b/tests/baselines/reference/genericCallWithObjectLiteralArgs.errors.txt
new file mode 100644
index 0000000000000..856f35a57f653
--- /dev/null
+++ b/tests/baselines/reference/genericCallWithObjectLiteralArgs.errors.txt
@@ -0,0 +1,14 @@
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObjectLiteralArgs.ts(5,9): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObjectLiteralArgs.ts (1 errors) ====
+    function foo<T>(x: { bar: T; baz: T }) {
+        return x;
+    }
+    
+    var r = foo({ bar: 1, baz: '' }); // error
+            ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    var r2 = foo({ bar: 1, baz: 1 }); // T = number
+    var r3 = foo({ bar: foo, baz: foo }); // T = typeof foo
+    var r4 = foo<Object>({ bar: 1, baz: '' }); // T = Object
\ No newline at end of file
diff --git a/tests/baselines/reference/genericCallWithObjectLiteralArgs.js b/tests/baselines/reference/genericCallWithObjectLiteralArgs.js
index 84a630425be58..2515bbef293a8 100644
--- a/tests/baselines/reference/genericCallWithObjectLiteralArgs.js
+++ b/tests/baselines/reference/genericCallWithObjectLiteralArgs.js
@@ -3,7 +3,7 @@ function foo<T>(x: { bar: T; baz: T }) {
     return x;
 }
 
-var r = foo({ bar: 1, baz: '' }); // T = {}
+var r = foo({ bar: 1, baz: '' }); // error
 var r2 = foo({ bar: 1, baz: 1 }); // T = number
 var r3 = foo({ bar: foo, baz: foo }); // T = typeof foo
 var r4 = foo<Object>({ bar: 1, baz: '' }); // T = Object
@@ -12,7 +12,7 @@ var r4 = foo<Object>({ bar: 1, baz: '' }); // T = Object
 function foo(x) {
     return x;
 }
-var r = foo({ bar: 1, baz: '' }); // T = {}
+var r = foo({ bar: 1, baz: '' }); // error
 var r2 = foo({ bar: 1, baz: 1 }); // T = number
 var r3 = foo({ bar: foo, baz: foo }); // T = typeof foo
 var r4 = foo({ bar: 1, baz: '' }); // T = Object
diff --git a/tests/baselines/reference/genericCallWithObjectLiteralArgs.types b/tests/baselines/reference/genericCallWithObjectLiteralArgs.types
deleted file mode 100644
index d23445ecbcafe..0000000000000
--- a/tests/baselines/reference/genericCallWithObjectLiteralArgs.types
+++ /dev/null
@@ -1,49 +0,0 @@
-=== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObjectLiteralArgs.ts ===
-function foo<T>(x: { bar: T; baz: T }) {
->foo : <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }
->T : T
->x : { bar: T; baz: T; }
->bar : T
->T : T
->baz : T
->T : T
-
-    return x;
->x : { bar: T; baz: T; }
-}
-
-var r = foo({ bar: 1, baz: '' }); // T = {}
->r : { bar: {}; baz: {}; }
->foo({ bar: 1, baz: '' }) : { bar: {}; baz: {}; }
->foo : <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }
->{ bar: 1, baz: '' } : { bar: number; baz: string; }
->bar : number
->baz : string
-
-var r2 = foo({ bar: 1, baz: 1 }); // T = number
->r2 : { bar: number; baz: number; }
->foo({ bar: 1, baz: 1 }) : { bar: number; baz: number; }
->foo : <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }
->{ bar: 1, baz: 1 } : { bar: number; baz: number; }
->bar : number
->baz : number
-
-var r3 = foo({ bar: foo, baz: foo }); // T = typeof foo
->r3 : { bar: <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }; baz: <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }; }
->foo({ bar: foo, baz: foo }) : { bar: <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }; baz: <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }; }
->foo : <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }
->{ bar: foo, baz: foo } : { bar: <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }; baz: <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }; }
->bar : <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }
->foo : <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }
->baz : <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }
->foo : <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }
-
-var r4 = foo<Object>({ bar: 1, baz: '' }); // T = Object
->r4 : { bar: Object; baz: Object; }
->foo<Object>({ bar: 1, baz: '' }) : { bar: Object; baz: Object; }
->foo : <T>(x: { bar: T; baz: T; }) => { bar: T; baz: T; }
->Object : Object
->{ bar: 1, baz: '' } : { bar: number; baz: string; }
->bar : number
->baz : string
-
diff --git a/tests/baselines/reference/genericCallWithObjectLiteralArguments1.errors.txt b/tests/baselines/reference/genericCallWithObjectLiteralArguments1.errors.txt
index 3b3f8d43ff924..4ac64500bd1f0 100644
--- a/tests/baselines/reference/genericCallWithObjectLiteralArguments1.errors.txt
+++ b/tests/baselines/reference/genericCallWithObjectLiteralArguments1.errors.txt
@@ -1,3 +1,4 @@
+tests/cases/compiler/genericCallWithObjectLiteralArguments1.ts(2,9): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/compiler/genericCallWithObjectLiteralArguments1.ts(4,22): error TS2345: Argument of type '{ x: number; y: string; }' is not assignable to parameter of type '{ x: number; y: number; }'.
   Types of property 'y' are incompatible:
     Type 'string' is not assignable to type 'number'.
@@ -12,9 +13,11 @@ tests/cases/compiler/genericCallWithObjectLiteralArguments1.ts(7,22): error TS23
     Type 'number' is not assignable to type 'string'.
 
 
-==== tests/cases/compiler/genericCallWithObjectLiteralArguments1.ts (4 errors) ====
+==== tests/cases/compiler/genericCallWithObjectLiteralArguments1.ts (5 errors) ====
     function foo<T>(n: { x: T; y: T }, m: T) { return m; }
     var x = foo({ x: 3, y: "" }, 4); // no error, x is Object, the best common type
+            ~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     // these are all errors
     var x2 = foo<number>({ x: 3, y: "" }, 4); 
                          ~~~~~~~~~~~~~~~
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgs.errors.txt b/tests/baselines/reference/genericCallWithObjectTypeArgs.errors.txt
new file mode 100644
index 0000000000000..dce9562a8f5c0
--- /dev/null
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgs.errors.txt
@@ -0,0 +1,27 @@
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObjectTypeArgs.ts(20,9): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObjectTypeArgs.ts (1 errors) ====
+    class C {
+        private x: string;
+    }
+    
+    class D {
+        private x: string;
+    }
+    
+    class X<T> {
+        x: T;
+    }
+    
+    function foo<T>(t: X<T>, t2: X<T>) {
+        var x: T;
+        return x;
+    }
+    
+    var c1 = new X<C>();
+    var d1 = new X<D>();
+    var r = foo(c1, d1); // error
+            ~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    var r2 = foo(c1, c1); // ok
\ No newline at end of file
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgs.types b/tests/baselines/reference/genericCallWithObjectTypeArgs.types
deleted file mode 100644
index ddbd7d83054f9..0000000000000
--- a/tests/baselines/reference/genericCallWithObjectTypeArgs.types
+++ /dev/null
@@ -1,68 +0,0 @@
-=== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObjectTypeArgs.ts ===
-class C {
->C : C
-
-    private x: string;
->x : string
-}
-
-class D {
->D : D
-
-    private x: string;
->x : string
-}
-
-class X<T> {
->X : X<T>
->T : T
-
-    x: T;
->x : T
->T : T
-}
-
-function foo<T>(t: X<T>, t2: X<T>) {
->foo : <T>(t: X<T>, t2: X<T>) => T
->T : T
->t : X<T>
->X : X<T>
->T : T
->t2 : X<T>
->X : X<T>
->T : T
-
-    var x: T;
->x : T
->T : T
-
-    return x;
->x : T
-}
-
-var c1 = new X<C>();
->c1 : X<C>
->new X<C>() : X<C>
->X : typeof X
->C : C
-
-var d1 = new X<D>();
->d1 : X<D>
->new X<D>() : X<D>
->X : typeof X
->D : D
-
-var r = foo(c1, d1); // error
->r : {}
->foo(c1, d1) : {}
->foo : <T>(t: X<T>, t2: X<T>) => T
->c1 : X<C>
->d1 : X<D>
-
-var r2 = foo(c1, c1); // ok
->r2 : C
->foo(c1, c1) : C
->foo : <T>(t: X<T>, t2: X<T>) => T
->c1 : X<C>
->c1 : X<C>
-
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgs2.types b/tests/baselines/reference/genericCallWithObjectTypeArgs2.types
index 0065811fdc129..aa1eeaf467067 100644
--- a/tests/baselines/reference/genericCallWithObjectTypeArgs2.types
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgs2.types
@@ -22,7 +22,7 @@ class Derived2 extends Base {
 
 // returns {}[]
 function f<T extends Base, U extends Base>(a: { x: T; y: U }) {
->f : <T extends Base, U extends Base>(a: { x: T; y: U; }) => {}[]
+>f : <T extends Base, U extends Base>(a: { x: T; y: U; }) => Array<T | U>
 >T : T
 >Base : Base
 >U : U
@@ -34,7 +34,7 @@ function f<T extends Base, U extends Base>(a: { x: T; y: U }) {
 >U : U
 
     return [a.x, a.y];
->[a.x, a.y] : {}[]
+>[a.x, a.y] : Array<T | U>
 >a.x : T
 >a : { x: T; y: U; }
 >x : T
@@ -44,9 +44,9 @@ function f<T extends Base, U extends Base>(a: { x: T; y: U }) {
 }
 
 var r = f({ x: new Derived(), y: new Derived2() }); // {}[]
->r : {}[]
->f({ x: new Derived(), y: new Derived2() }) : {}[]
->f : <T extends Base, U extends Base>(a: { x: T; y: U; }) => {}[]
+>r : Array<Derived | Derived2>
+>f({ x: new Derived(), y: new Derived2() }) : Array<Derived | Derived2>
+>f : <T extends Base, U extends Base>(a: { x: T; y: U; }) => Array<T | U>
 >{ x: new Derived(), y: new Derived2() } : { x: Derived; y: Derived2; }
 >x : Derived
 >new Derived() : Derived
@@ -56,9 +56,9 @@ var r = f({ x: new Derived(), y: new Derived2() }); // {}[]
 >Derived2 : typeof Derived2
 
 var r2 = f({ x: new Base(), y: new Derived2() }); // {}[]
->r2 : {}[]
->f({ x: new Base(), y: new Derived2() }) : {}[]
->f : <T extends Base, U extends Base>(a: { x: T; y: U; }) => {}[]
+>r2 : Base[]
+>f({ x: new Base(), y: new Derived2() }) : Array<Base | Derived2>
+>f : <T extends Base, U extends Base>(a: { x: T; y: U; }) => Array<T | U>
 >{ x: new Base(), y: new Derived2() } : { x: Base; y: Derived2; }
 >x : Base
 >new Base() : Base
diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints3.errors.txt b/tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints3.errors.txt
index c41ca0e8875cc..9cb190ddecda1 100644
--- a/tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints3.errors.txt
+++ b/tests/baselines/reference/genericCallWithObjectTypeArgsAndConstraints3.errors.txt
@@ -1,7 +1,8 @@
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObjectTypeArgsAndConstraints3.ts(18,10): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObjectTypeArgsAndConstraints3.ts(20,29): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
 
 
-==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObjectTypeArgsAndConstraints3.ts (1 errors) ====
+==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObjectTypeArgsAndConstraints3.ts (2 errors) ====
     // Generic call with constraints infering type parameter from object member properties
     
     class Base {
@@ -20,6 +21,8 @@ tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObj
     }
     
     var r1 = f({ x: new Derived(), y: new Derived2() }); // ok, both extend Base
+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     
     function f2<T extends Base, U extends { x: T; y: T }>(a: U) {
                                 ~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/tests/baselines/reference/genericCallWithOverloadedConstructorTypedArguments.errors.txt b/tests/baselines/reference/genericCallWithOverloadedConstructorTypedArguments.errors.txt
new file mode 100644
index 0000000000000..3ddb094970a15
--- /dev/null
+++ b/tests/baselines/reference/genericCallWithOverloadedConstructorTypedArguments.errors.txt
@@ -0,0 +1,54 @@
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithOverloadedConstructorTypedArguments.ts(36,14): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithOverloadedConstructorTypedArguments.ts (1 errors) ====
+    // Function typed arguments with multiple signatures must be passed an implementation that matches all of them
+    // Inferences are made quadratic-pairwise to and from these overload sets
+    
+    module NonGenericParameter {
+        var a: {
+            new(x: boolean): boolean;
+            new(x: string): string;
+        }
+    
+        function foo4(cb: typeof a) {
+            return new cb(null);
+        }
+    
+        var r = foo4(a);
+        var b: { new <T>(x: T): T };
+        var r2 = foo4(b);
+    }
+    
+    module GenericParameter {
+        function foo5<T>(cb: { new(x: T): string; new(x: number): T }) {
+            return cb;
+        }
+    
+        var a: {
+            new (x: boolean): string;
+            new (x: number): boolean;
+        }
+        var r5 = foo5(a); // new{} => string; new(x:number) => {}
+        var b: { new<T>(x: T): string; new<T>(x: number): T; }
+        var r7 = foo5(b); // new any => string; new(x:number) => any
+    
+        function foo6<T>(cb: { new(x: T): string; new(x: T, y?: T): string }) {
+            return cb;
+        }
+    
+        var r8 = foo6(a); // error
+                 ~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+        var r9 = foo6(b); // new any => string; new(x:any, y?:any) => string
+    
+        function foo7<T>(x:T, cb: { new(x: T): string; new(x: T, y?: T): string }) {
+            return cb;
+        }
+    
+        var r13 = foo7(1, b); // new any => string; new(x:any, y?:any) => string
+        var c: { new <T>(x: T): string; <T>(x: number): T; }
+        var c2: { new <T>(x: T): string; new<T>(x: number): T; }
+        var r14 = foo7(1, c); // new any => string; new(x:any, y?:any) => string
+        var r15 = foo7(1, c2); // new any => string; new(x:any, y?:any) => string
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/genericCallWithOverloadedConstructorTypedArguments.js b/tests/baselines/reference/genericCallWithOverloadedConstructorTypedArguments.js
index 9da34ebad8614..4f74b043bd9f3 100644
--- a/tests/baselines/reference/genericCallWithOverloadedConstructorTypedArguments.js
+++ b/tests/baselines/reference/genericCallWithOverloadedConstructorTypedArguments.js
@@ -34,7 +34,7 @@ module GenericParameter {
         return cb;
     }
 
-    var r8 = foo6(a); // new{} => string; new(x:{}, y?:{}) => string
+    var r8 = foo6(a); // error
     var r9 = foo6(b); // new any => string; new(x:any, y?:any) => string
 
     function foo7<T>(x:T, cb: { new(x: T): string; new(x: T, y?: T): string }) {
@@ -73,7 +73,7 @@ var GenericParameter;
     function foo6(cb) {
         return cb;
     }
-    var r8 = foo6(a); // new{} => string; new(x:{}, y?:{}) => string
+    var r8 = foo6(a); // error
     var r9 = foo6(b); // new any => string; new(x:any, y?:any) => string
     function foo7(x, cb) {
         return cb;
diff --git a/tests/baselines/reference/genericCallWithOverloadedConstructorTypedArguments.types b/tests/baselines/reference/genericCallWithOverloadedConstructorTypedArguments.types
deleted file mode 100644
index 6c16ad0259c20..0000000000000
--- a/tests/baselines/reference/genericCallWithOverloadedConstructorTypedArguments.types
+++ /dev/null
@@ -1,173 +0,0 @@
-=== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithOverloadedConstructorTypedArguments.ts ===
-// Function typed arguments with multiple signatures must be passed an implementation that matches all of them
-// Inferences are made quadratic-pairwise to and from these overload sets
-
-module NonGenericParameter {
->NonGenericParameter : typeof NonGenericParameter
-
-    var a: {
->a : { new (x: boolean): boolean; new (x: string): string; }
-
-        new(x: boolean): boolean;
->x : boolean
-
-        new(x: string): string;
->x : string
-    }
-
-    function foo4(cb: typeof a) {
->foo4 : (cb: { new (x: boolean): boolean; new (x: string): string; }) => boolean
->cb : { new (x: boolean): boolean; new (x: string): string; }
->a : { new (x: boolean): boolean; new (x: string): string; }
-
-        return new cb(null);
->new cb(null) : boolean
->cb : { new (x: boolean): boolean; new (x: string): string; }
-    }
-
-    var r = foo4(a);
->r : boolean
->foo4(a) : boolean
->foo4 : (cb: { new (x: boolean): boolean; new (x: string): string; }) => boolean
->a : { new (x: boolean): boolean; new (x: string): string; }
-
-    var b: { new <T>(x: T): T };
->b : new <T>(x: T) => T
->T : T
->x : T
->T : T
->T : T
-
-    var r2 = foo4(b);
->r2 : boolean
->foo4(b) : boolean
->foo4 : (cb: { new (x: boolean): boolean; new (x: string): string; }) => boolean
->b : new <T>(x: T) => T
-}
-
-module GenericParameter {
->GenericParameter : typeof GenericParameter
-
-    function foo5<T>(cb: { new(x: T): string; new(x: number): T }) {
->foo5 : <T>(cb: { new (x: T): string; new (x: number): T; }) => { new (x: T): string; new (x: number): T; }
->T : T
->cb : { new (x: T): string; new (x: number): T; }
->x : T
->T : T
->x : number
->T : T
-
-        return cb;
->cb : { new (x: T): string; new (x: number): T; }
-    }
-
-    var a: {
->a : { new (x: boolean): string; new (x: number): boolean; }
-
-        new (x: boolean): string;
->x : boolean
-
-        new (x: number): boolean;
->x : number
-    }
-    var r5 = foo5(a); // new{} => string; new(x:number) => {}
->r5 : { new (x: boolean): string; new (x: number): boolean; }
->foo5(a) : { new (x: boolean): string; new (x: number): boolean; }
->foo5 : <T>(cb: { new (x: T): string; new (x: number): T; }) => { new (x: T): string; new (x: number): T; }
->a : { new (x: boolean): string; new (x: number): boolean; }
-
-    var b: { new<T>(x: T): string; new<T>(x: number): T; }
->b : { new <T>(x: T): string; new <T>(x: number): T; }
->T : T
->x : T
->T : T
->T : T
->x : number
->T : T
-
-    var r7 = foo5(b); // new any => string; new(x:number) => any
->r7 : { new (x: any): string; new (x: number): any; }
->foo5(b) : { new (x: any): string; new (x: number): any; }
->foo5 : <T>(cb: { new (x: T): string; new (x: number): T; }) => { new (x: T): string; new (x: number): T; }
->b : { new <T>(x: T): string; new <T>(x: number): T; }
-
-    function foo6<T>(cb: { new(x: T): string; new(x: T, y?: T): string }) {
->foo6 : <T>(cb: { new (x: T): string; new (x: T, y?: T): string; }) => { new (x: T): string; new (x: T, y?: T): string; }
->T : T
->cb : { new (x: T): string; new (x: T, y?: T): string; }
->x : T
->T : T
->x : T
->T : T
->y : T
->T : T
-
-        return cb;
->cb : { new (x: T): string; new (x: T, y?: T): string; }
-    }
-
-    var r8 = foo6(a); // new{} => string; new(x:{}, y?:{}) => string
->r8 : { new (x: {}): string; new (x: {}, y?: {}): string; }
->foo6(a) : { new (x: {}): string; new (x: {}, y?: {}): string; }
->foo6 : <T>(cb: { new (x: T): string; new (x: T, y?: T): string; }) => { new (x: T): string; new (x: T, y?: T): string; }
->a : { new (x: boolean): string; new (x: number): boolean; }
-
-    var r9 = foo6(b); // new any => string; new(x:any, y?:any) => string
->r9 : { new (x: any): string; new (x: any, y?: any): string; }
->foo6(b) : { new (x: any): string; new (x: any, y?: any): string; }
->foo6 : <T>(cb: { new (x: T): string; new (x: T, y?: T): string; }) => { new (x: T): string; new (x: T, y?: T): string; }
->b : { new <T>(x: T): string; new <T>(x: number): T; }
-
-    function foo7<T>(x:T, cb: { new(x: T): string; new(x: T, y?: T): string }) {
->foo7 : <T>(x: T, cb: { new (x: T): string; new (x: T, y?: T): string; }) => { new (x: T): string; new (x: T, y?: T): string; }
->T : T
->x : T
->T : T
->cb : { new (x: T): string; new (x: T, y?: T): string; }
->x : T
->T : T
->x : T
->T : T
->y : T
->T : T
-
-        return cb;
->cb : { new (x: T): string; new (x: T, y?: T): string; }
-    }
-
-    var r13 = foo7(1, b); // new any => string; new(x:any, y?:any) => string
->r13 : { new (x: any): string; new (x: any, y?: any): string; }
->foo7(1, b) : { new (x: any): string; new (x: any, y?: any): string; }
->foo7 : <T>(x: T, cb: { new (x: T): string; new (x: T, y?: T): string; }) => { new (x: T): string; new (x: T, y?: T): string; }
->b : { new <T>(x: T): string; new <T>(x: number): T; }
-
-    var c: { new <T>(x: T): string; <T>(x: number): T; }
->c : { <T>(x: number): T; new <T>(x: T): string; }
->T : T
->x : T
->T : T
->T : T
->x : number
->T : T
-
-    var c2: { new <T>(x: T): string; new<T>(x: number): T; }
->c2 : { new <T>(x: T): string; new <T>(x: number): T; }
->T : T
->x : T
->T : T
->T : T
->x : number
->T : T
-
-    var r14 = foo7(1, c); // new any => string; new(x:any, y?:any) => string
->r14 : { new (x: any): string; new (x: any, y?: any): string; }
->foo7(1, c) : { new (x: any): string; new (x: any, y?: any): string; }
->foo7 : <T>(x: T, cb: { new (x: T): string; new (x: T, y?: T): string; }) => { new (x: T): string; new (x: T, y?: T): string; }
->c : { <T>(x: number): T; new <T>(x: T): string; }
-
-    var r15 = foo7(1, c2); // new any => string; new(x:any, y?:any) => string
->r15 : { new (x: any): string; new (x: any, y?: any): string; }
->foo7(1, c2) : { new (x: any): string; new (x: any, y?: any): string; }
->foo7 : <T>(x: T, cb: { new (x: T): string; new (x: T, y?: T): string; }) => { new (x: T): string; new (x: T, y?: T): string; }
->c2 : { new <T>(x: T): string; new <T>(x: number): T; }
-}
diff --git a/tests/baselines/reference/genericCallWithTupleType.errors.txt b/tests/baselines/reference/genericCallWithTupleType.errors.txt
index 8ddeb93435f3e..abfe5087131d1 100644
--- a/tests/baselines/reference/genericCallWithTupleType.errors.txt
+++ b/tests/baselines/reference/genericCallWithTupleType.errors.txt
@@ -1,3 +1,11 @@
+tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTupleType.ts(12,1): error TS2322: Type '[string, number, boolean, boolean]' is not assignable to type '[string, number]':
+  Types of property 'pop' are incompatible:
+    Type '() => string | number | boolean' is not assignable to type '() => string | number':
+      Type 'string | number | boolean' is not assignable to type 'string | number':
+        Type 'boolean' is not assignable to type 'string | number':
+          Type 'boolean' is not assignable to type 'number'.
+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'.
@@ -8,7 +16,7 @@ tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTup
   Property '1' is missing in type '[{}]'.
 
 
-==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTupleType.ts (3 errors) ====
+==== tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTupleType.ts (5 errors) ====
     interface I<T, U> {
         tuple1: [T, U];
     } 
@@ -21,8 +29,18 @@ tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithTup
     var e1 = i1.tuple1[0];  // string
     var e2 = i1.tuple1[1];  // number
     i1.tuple1 = ["foo", 5, false, true];
+    ~~~~~~~~~
+!!! error TS2322: Type '[string, number, boolean, boolean]' is not assignable to type '[string, number]':
+!!! error TS2322:   Types of property 'pop' are incompatible:
+!!! error TS2322:     Type '() => string | number | boolean' is not assignable to type '() => string | number':
+!!! error TS2322:       Type 'string | number | boolean' is not assignable to type 'string | number':
+!!! error TS2322:         Type 'boolean' is not assignable to type 'string | number':
+!!! error TS2322:           Type 'boolean' is not assignable to type 'number'.
     var e3 = i1.tuple1[2];  // {}
     i1.tuple1[3] = { a: "string" };
+    ~~~~~~~~~~~~
+!!! error TS2322: Type '{ a: string; }' is not assignable to type 'string | number':
+!!! error TS2322:   Type '{ a: string; }' is not assignable to type 'number'.
     var e4 = i1.tuple1[3];  // {}
     i2.tuple1 = ["foo", 5];
     i2.tuple1 = ["foo", "bar"];
diff --git a/tests/baselines/reference/genericClassWithFunctionTypedMemberArguments.errors.txt b/tests/baselines/reference/genericClassWithFunctionTypedMemberArguments.errors.txt
new file mode 100644
index 0000000000000..30ed4bc431f75
--- /dev/null
+++ b/tests/baselines/reference/genericClassWithFunctionTypedMemberArguments.errors.txt
@@ -0,0 +1,81 @@
+tests/cases/conformance/types/typeRelationships/typeInference/genericClassWithFunctionTypedMemberArguments.ts(57,19): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/typeRelationships/typeInference/genericClassWithFunctionTypedMemberArguments.ts(60,19): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/typeRelationships/typeInference/genericClassWithFunctionTypedMemberArguments.ts(61,20): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/typeRelationships/typeInference/genericClassWithFunctionTypedMemberArguments.ts(62,30): error TS2345: Argument of type '(a: number) => string' is not assignable to parameter of type '(a: number) => number'.
+  Type 'string' is not assignable to type 'number'.
+
+
+==== tests/cases/conformance/types/typeRelationships/typeInference/genericClassWithFunctionTypedMemberArguments.ts (4 errors) ====
+    // Generic functions used as arguments for function typed parameters are not used to make inferences from
+    // Using function arguments, no errors expected
+    
+    module ImmediatelyFix {
+        class C<T> {
+            foo<T>(x: (a: T) => T) {
+                return x(null);
+            }
+        }
+    
+        var c = new C<number>();
+        var r = c.foo(<U>(x: U) => ''); // {}
+        var r2 = c.foo<string>(<U>(x: U) => ''); // string 
+        var r3 = c.foo(x => ''); // {}
+    
+        class C2<T> {
+            foo(x: (a: T) => T) {
+                return x(null);
+            }
+        }
+    
+        var c2 = new C2<number>();
+        var ra = c2.foo(<U>(x: U) => 1); // number
+        var r3a = c2.foo(x => 1); // number
+    }
+    
+    module WithCandidates {
+        class C<T> {
+            foo2<T, U>(x: T, cb: (a: T) => U) {
+                return cb(x);
+            }
+        }
+    
+        var c: C<number>;
+        var r4 = c.foo2(1, function <Z>(a: Z) { return '' }); // string, contextual signature instantiation is applied to generic functions
+        var r5 = c.foo2(1, (a) => ''); // string
+        var r6 = c.foo2<string, number>('', <Z>(a: Z) => 1); // number
+    
+        class C2<T, U> {
+            foo3(x: T, cb: (a: T) => U, y: U) {
+                return cb(x);
+            }
+        }
+    
+        var c2: C2<number, string>;
+        var r7 = c2.foo3(1, <Z>(a: Z) => '', ''); // string
+        var r8 = c2.foo3(1, function (a) { return '' }, ''); // string
+    
+        class C3<T, U> {
+            foo3<T,U>(x: T, cb: (a: T) => U, y: U) {
+                return cb(x);
+            }
+        }
+        var c3: C3<number, string>;
+    
+        function other<T, U>(t: T, u: U) {
+            var r10 = c.foo2(1, (x: T) => ''); // error
+                      ~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+            var r10 = c.foo2(1, (x) => ''); // string
+    
+            var r11 = c3.foo3(1, (x: T) => '', ''); // error
+                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+            var r11b = c3.foo3(1, (x: T) => '', 1); // error
+                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+            var r12 = c3.foo3(1, function (a) { return '' }, 1); // error
+                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '(a: number) => string' is not assignable to parameter of type '(a: number) => number'.
+!!! error TS2345:   Type 'string' is not assignable to type 'number'.
+        }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/genericClassWithFunctionTypedMemberArguments.js b/tests/baselines/reference/genericClassWithFunctionTypedMemberArguments.js
index 1af5f0ea6e6e0..7ec25949534f6 100644
--- a/tests/baselines/reference/genericClassWithFunctionTypedMemberArguments.js
+++ b/tests/baselines/reference/genericClassWithFunctionTypedMemberArguments.js
@@ -55,12 +55,12 @@ module WithCandidates {
     var c3: C3<number, string>;
 
     function other<T, U>(t: T, u: U) {
-        var r10 = c.foo2(1, (x: T) => ''); // string, non-generic signature allows inferences to be made
+        var r10 = c.foo2(1, (x: T) => ''); // error
         var r10 = c.foo2(1, (x) => ''); // string
 
-        var r11 = c3.foo3(1, (x: T) => '', ''); // string
-        var r11b = c3.foo3(1, (x: T) => '', 1); // {}
-        var r12 = c3.foo3(1, function (a) { return '' }, 1); // {}
+        var r11 = c3.foo3(1, (x: T) => '', ''); // error
+        var r11b = c3.foo3(1, (x: T) => '', 1); // error
+        var r12 = c3.foo3(1, function (a) { return '' }, 1); // error
     }
 }
 
@@ -132,12 +132,12 @@ var WithCandidates;
     })();
     var c3;
     function other(t, u) {
-        var r10 = c.foo2(1, function (x) { return ''; }); // string, non-generic signature allows inferences to be made
+        var r10 = c.foo2(1, function (x) { return ''; }); // error
         var r10 = c.foo2(1, function (x) { return ''; }); // string
-        var r11 = c3.foo3(1, function (x) { return ''; }, ''); // string
-        var r11b = c3.foo3(1, function (x) { return ''; }, 1); // {}
+        var r11 = c3.foo3(1, function (x) { return ''; }, ''); // error
+        var r11b = c3.foo3(1, function (x) { return ''; }, 1); // error
         var r12 = c3.foo3(1, function (a) {
             return '';
-        }, 1); // {}
+        }, 1); // error
     }
 })(WithCandidates || (WithCandidates = {}));
diff --git a/tests/baselines/reference/genericClassWithFunctionTypedMemberArguments.types b/tests/baselines/reference/genericClassWithFunctionTypedMemberArguments.types
deleted file mode 100644
index 68b94d81d0212..0000000000000
--- a/tests/baselines/reference/genericClassWithFunctionTypedMemberArguments.types
+++ /dev/null
@@ -1,297 +0,0 @@
-=== tests/cases/conformance/types/typeRelationships/typeInference/genericClassWithFunctionTypedMemberArguments.ts ===
-// Generic functions used as arguments for function typed parameters are not used to make inferences from
-// Using function arguments, no errors expected
-
-module ImmediatelyFix {
->ImmediatelyFix : typeof ImmediatelyFix
-
-    class C<T> {
->C : C<T>
->T : T
-
-        foo<T>(x: (a: T) => T) {
->foo : <T>(x: (a: T) => T) => T
->T : T
->x : (a: T) => T
->a : T
->T : T
->T : T
-
-            return x(null);
->x(null) : T
->x : (a: T) => T
-        }
-    }
-
-    var c = new C<number>();
->c : C<number>
->new C<number>() : C<number>
->C : typeof C
-
-    var r = c.foo(<U>(x: U) => ''); // {}
->r : {}
->c.foo(<U>(x: U) => '') : {}
->c.foo : <T>(x: (a: T) => T) => T
->c : C<number>
->foo : <T>(x: (a: T) => T) => T
-><U>(x: U) => '' : <U>(x: U) => string
->U : U
->x : U
->U : U
-
-    var r2 = c.foo<string>(<U>(x: U) => ''); // string 
->r2 : string
->c.foo<string>(<U>(x: U) => '') : string
->c.foo : <T>(x: (a: T) => T) => T
->c : C<number>
->foo : <T>(x: (a: T) => T) => T
-><U>(x: U) => '' : <U>(x: U) => string
->U : U
->x : U
->U : U
-
-    var r3 = c.foo(x => ''); // {}
->r3 : {}
->c.foo(x => '') : {}
->c.foo : <T>(x: (a: T) => T) => T
->c : C<number>
->foo : <T>(x: (a: T) => T) => T
->x => '' : (x: {}) => string
->x : {}
-
-    class C2<T> {
->C2 : C2<T>
->T : T
-
-        foo(x: (a: T) => T) {
->foo : (x: (a: T) => T) => T
->x : (a: T) => T
->a : T
->T : T
->T : T
-
-            return x(null);
->x(null) : T
->x : (a: T) => T
-        }
-    }
-
-    var c2 = new C2<number>();
->c2 : C2<number>
->new C2<number>() : C2<number>
->C2 : typeof C2
-
-    var ra = c2.foo(<U>(x: U) => 1); // number
->ra : number
->c2.foo(<U>(x: U) => 1) : number
->c2.foo : (x: (a: number) => number) => number
->c2 : C2<number>
->foo : (x: (a: number) => number) => number
-><U>(x: U) => 1 : <U>(x: U) => number
->U : U
->x : U
->U : U
-
-    var r3a = c2.foo(x => 1); // number
->r3a : number
->c2.foo(x => 1) : number
->c2.foo : (x: (a: number) => number) => number
->c2 : C2<number>
->foo : (x: (a: number) => number) => number
->x => 1 : (x: number) => number
->x : number
-}
-
-module WithCandidates {
->WithCandidates : typeof WithCandidates
-
-    class C<T> {
->C : C<T>
->T : T
-
-        foo2<T, U>(x: T, cb: (a: T) => U) {
->foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->T : T
->U : U
->x : T
->T : T
->cb : (a: T) => U
->a : T
->T : T
->U : U
-
-            return cb(x);
->cb(x) : U
->cb : (a: T) => U
->x : T
-        }
-    }
-
-    var c: C<number>;
->c : C<number>
->C : C<T>
-
-    var r4 = c.foo2(1, function <Z>(a: Z) { return '' }); // string, contextual signature instantiation is applied to generic functions
->r4 : string
->c.foo2(1, function <Z>(a: Z) { return '' }) : string
->c.foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->c : C<number>
->foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->function <Z>(a: Z) { return '' } : <Z>(a: Z) => string
->Z : Z
->a : Z
->Z : Z
-
-    var r5 = c.foo2(1, (a) => ''); // string
->r5 : string
->c.foo2(1, (a) => '') : string
->c.foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->c : C<number>
->foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->(a) => '' : (a: number) => string
->a : number
-
-    var r6 = c.foo2<string, number>('', <Z>(a: Z) => 1); // number
->r6 : number
->c.foo2<string, number>('', <Z>(a: Z) => 1) : number
->c.foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->c : C<number>
->foo2 : <T, U>(x: T, cb: (a: T) => U) => U
-><Z>(a: Z) => 1 : <Z>(a: Z) => number
->Z : Z
->a : Z
->Z : Z
-
-    class C2<T, U> {
->C2 : C2<T, U>
->T : T
->U : U
-
-        foo3(x: T, cb: (a: T) => U, y: U) {
->foo3 : (x: T, cb: (a: T) => U, y: U) => U
->x : T
->T : T
->cb : (a: T) => U
->a : T
->T : T
->U : U
->y : U
->U : U
-
-            return cb(x);
->cb(x) : U
->cb : (a: T) => U
->x : T
-        }
-    }
-
-    var c2: C2<number, string>;
->c2 : C2<number, string>
->C2 : C2<T, U>
-
-    var r7 = c2.foo3(1, <Z>(a: Z) => '', ''); // string
->r7 : string
->c2.foo3(1, <Z>(a: Z) => '', '') : string
->c2.foo3 : (x: number, cb: (a: number) => string, y: string) => string
->c2 : C2<number, string>
->foo3 : (x: number, cb: (a: number) => string, y: string) => string
-><Z>(a: Z) => '' : <Z>(a: Z) => string
->Z : Z
->a : Z
->Z : Z
-
-    var r8 = c2.foo3(1, function (a) { return '' }, ''); // string
->r8 : string
->c2.foo3(1, function (a) { return '' }, '') : string
->c2.foo3 : (x: number, cb: (a: number) => string, y: string) => string
->c2 : C2<number, string>
->foo3 : (x: number, cb: (a: number) => string, y: string) => string
->function (a) { return '' } : (a: number) => string
->a : number
-
-    class C3<T, U> {
->C3 : C3<T, U>
->T : T
->U : U
-
-        foo3<T,U>(x: T, cb: (a: T) => U, y: U) {
->foo3 : <T, U>(x: T, cb: (a: T) => U, y: U) => U
->T : T
->U : U
->x : T
->T : T
->cb : (a: T) => U
->a : T
->T : T
->U : U
->y : U
->U : U
-
-            return cb(x);
->cb(x) : U
->cb : (a: T) => U
->x : T
-        }
-    }
-    var c3: C3<number, string>;
->c3 : C3<number, string>
->C3 : C3<T, U>
-
-    function other<T, U>(t: T, u: U) {
->other : <T, U>(t: T, u: U) => void
->T : T
->U : U
->t : T
->T : T
->u : U
->U : U
-
-        var r10 = c.foo2(1, (x: T) => ''); // string, non-generic signature allows inferences to be made
->r10 : string
->c.foo2(1, (x: T) => '') : string
->c.foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->c : C<number>
->foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->(x: T) => '' : (x: T) => string
->x : T
->T : T
-
-        var r10 = c.foo2(1, (x) => ''); // string
->r10 : string
->c.foo2(1, (x) => '') : string
->c.foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->c : C<number>
->foo2 : <T, U>(x: T, cb: (a: T) => U) => U
->(x) => '' : (x: number) => string
->x : number
-
-        var r11 = c3.foo3(1, (x: T) => '', ''); // string
->r11 : string
->c3.foo3(1, (x: T) => '', '') : string
->c3.foo3 : <T, U>(x: T, cb: (a: T) => U, y: U) => U
->c3 : C3<number, string>
->foo3 : <T, U>(x: T, cb: (a: T) => U, y: U) => U
->(x: T) => '' : (x: T) => string
->x : T
->T : T
-
-        var r11b = c3.foo3(1, (x: T) => '', 1); // {}
->r11b : {}
->c3.foo3(1, (x: T) => '', 1) : {}
->c3.foo3 : <T, U>(x: T, cb: (a: T) => U, y: U) => U
->c3 : C3<number, string>
->foo3 : <T, U>(x: T, cb: (a: T) => U, y: U) => U
->(x: T) => '' : (x: T) => string
->x : T
->T : T
-
-        var r12 = c3.foo3(1, function (a) { return '' }, 1); // {}
->r12 : {}
->c3.foo3(1, function (a) { return '' }, 1) : {}
->c3.foo3 : <T, U>(x: T, cb: (a: T) => U, y: U) => U
->c3 : C3<number, string>
->foo3 : <T, U>(x: T, cb: (a: T) => U, y: U) => U
->function (a) { return '' } : (a: number) => string
->a : number
-    }
-}
diff --git a/tests/baselines/reference/genericRestArgs.errors.txt b/tests/baselines/reference/genericRestArgs.errors.txt
index db36a9a0162b5..49f61de325f47 100644
--- a/tests/baselines/reference/genericRestArgs.errors.txt
+++ b/tests/baselines/reference/genericRestArgs.errors.txt
@@ -1,10 +1,14 @@
+tests/cases/compiler/genericRestArgs.ts(2,12): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/compiler/genericRestArgs.ts(5,34): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
+tests/cases/compiler/genericRestArgs.ts(10,12): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/compiler/genericRestArgs.ts(12,30): error TS2345: Argument of type 'number' is not assignable to parameter of type 'any[]'.
 
 
-==== tests/cases/compiler/genericRestArgs.ts (2 errors) ====
+==== tests/cases/compiler/genericRestArgs.ts (4 errors) ====
     function makeArrayG<T>(...items: T[]): T[] { return items; }
     var a1Ga = makeArrayG(1, ""); // no error
+               ~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var a1Gb = makeArrayG<any>(1, ""); 
     var a1Gc = makeArrayG<Object>(1, ""); 
     var a1Gd = makeArrayG<number>(1, ""); // error
@@ -15,6 +19,8 @@ tests/cases/compiler/genericRestArgs.ts(12,30): error TS2345: Argument of type '
         return [item1, item2, item3];
     }
     var a2Ga = makeArrayGOpt(1, ""); 
+               ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var a2Gb = makeArrayG<any>(1, "");
     var a2Gc = makeArrayG<any[]>(1, ""); // error
                                  ~
diff --git a/tests/baselines/reference/genericTypeArgumentInference1.types b/tests/baselines/reference/genericTypeArgumentInference1.types
index 20a9a0ca8f98f..be7a3e9226daf 100644
--- a/tests/baselines/reference/genericTypeArgumentInference1.types
+++ b/tests/baselines/reference/genericTypeArgumentInference1.types
@@ -42,12 +42,12 @@ declare var _: Underscore.Static;
 >Static : Underscore.Static
 
 var r = _.all([true, 1, null, 'yes'], _.identity);
->r : {}
->_.all([true, 1, null, 'yes'], _.identity) : {}
+>r : string | number | boolean
+>_.all([true, 1, null, 'yes'], _.identity) : string | number | boolean
 >_.all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => T
 >_ : Underscore.Static
 >all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => T
->[true, 1, null, 'yes'] : {}[]
+>[true, 1, null, 'yes'] : Array<string | number | boolean>
 >_.identity : <T>(value: T) => T
 >_ : Underscore.Static
 >identity : <T>(value: T) => T
@@ -69,7 +69,7 @@ var r3 = _.all([], _.identity);
 >_.all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => T
 >_ : Underscore.Static
 >all : <T>(list: T[], iterator?: Underscore.Iterator<T, boolean>, context?: any) => T
->[] : any[]
+>[] : undefined[]
 >_.identity : <T>(value: T) => T
 >_ : Underscore.Static
 >identity : <T>(value: T) => T
diff --git a/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.types b/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.types
index 05697f1e1f9d1..f0cab6e74672b 100644
--- a/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.types
+++ b/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.types
@@ -8,7 +8,7 @@ class LazyArray<T> {
 ><{ [objectId: string]: T; }>{} : { [x: string]: T; }
 >objectId : string
 >T : T
->{} : { [x: string]: T; }
+>{} : { [x: string]: undefined; }
 
     array() {
 >array : () => { [x: string]: T; }
diff --git a/tests/baselines/reference/genericsManyTypeParameters.types b/tests/baselines/reference/genericsManyTypeParameters.types
index 65f9a7c115e00..df2144de866c4 100644
--- a/tests/baselines/reference/genericsManyTypeParameters.types
+++ b/tests/baselines/reference/genericsManyTypeParameters.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/genericsManyTypeParameters.ts ===
 function Foo<
->Foo : <a1, a21, a31, a41, a51, a61, a119, a22, a32, a42, a52, a62, a219, a23, a33, a43, a53, a63, a319, a24, a34, a44, a54, a64, a419, a25, a35, a45, a55, a65, a519, a26, a36, a46, a56, a66, a619, a27, a37, a47, a57, a67, a71, a28, a38, a48, a58, a68, a81, a29, a39, a49, a59, a69, a91, a210, a310, a410, a510, a610, a111, a211, a311, a411, a511, a611, a112, a212, a312, a412, a512, a612, a113, a213, a313, a413, a513, a613, a114, a214, a314, a414, a514, a614, a115, a215, a315, a415, a515, a615, a116, a216, a316, a416, a516, a616, a117, a217, a317, a417, a517, a617, a118, a218, a318, a418, a518, a618>(x1: a1, y1: a21, z1: a31, a1: a41, b1: a51, c1: a61, x2: a119, y2: a22, z2: a32, a2: a42, b2: a52, c2: a62, x3: a219, y3: a23, z3: a33, a3: a43, b3: a53, c3: a63, x4: a319, y4: a24, z4: a34, a4: a44, b4: a54, c4: a64, x5: a419, y5: a25, z5: a35, a5: a45, b5: a55, c5: a65, x6: a519, y6: a26, z6: a36, a6: a46, b6: a56, c6: a66, x7: a619, y7: a27, z7: a37, a7: a47, b7: a57, c7: a67, x8: a71, y8: a28, z8: a38, a8: a48, b8: a58, c8: a68, x9: a81, y9: a29, z9: a39, a9: a49, b9: a59, c9: a69, x10: a91, y12: a210, z10: a310, a10: a410, b10: a510, c10: a610, x11: a111, y13: a211, z11: a311, a11: a411, b11: a511, c11: a611, x12: a112, y14: a212, z12: a312, a12: a412, b12: a512, c12: a612, x13: a113, y15: a213, z13: a313, a13: a413, b13: a513, c13: a613, x14: a114, y16: a214, z14: a314, a14: a414, b14: a514, c14: a614, x15: a115, y17: a215, z15: a315, a15: a415, b15: a515, c15: a615, x16: a116, y18: a216, z16: a316, a16: a416, b16: a516, c16: a616, x17: a117, y19: a217, z17: a317, a17: a417, b17: a517, c17: a617, x18: a118, y10: a218, z18: a318, a18: a418, b18: a518, c18: a618) => {}[]
+>Foo : <a1, a21, a31, a41, a51, a61, a119, a22, a32, a42, a52, a62, a219, a23, a33, a43, a53, a63, a319, a24, a34, a44, a54, a64, a419, a25, a35, a45, a55, a65, a519, a26, a36, a46, a56, a66, a619, a27, a37, a47, a57, a67, a71, a28, a38, a48, a58, a68, a81, a29, a39, a49, a59, a69, a91, a210, a310, a410, a510, a610, a111, a211, a311, a411, a511, a611, a112, a212, a312, a412, a512, a612, a113, a213, a313, a413, a513, a613, a114, a214, a314, a414, a514, a614, a115, a215, a315, a415, a515, a615, a116, a216, a316, a416, a516, a616, a117, a217, a317, a417, a517, a617, a118, a218, a318, a418, a518, a618>(x1: a1, y1: a21, z1: a31, a1: a41, b1: a51, c1: a61, x2: a119, y2: a22, z2: a32, a2: a42, b2: a52, c2: a62, x3: a219, y3: a23, z3: a33, a3: a43, b3: a53, c3: a63, x4: a319, y4: a24, z4: a34, a4: a44, b4: a54, c4: a64, x5: a419, y5: a25, z5: a35, a5: a45, b5: a55, c5: a65, x6: a519, y6: a26, z6: a36, a6: a46, b6: a56, c6: a66, x7: a619, y7: a27, z7: a37, a7: a47, b7: a57, c7: a67, x8: a71, y8: a28, z8: a38, a8: a48, b8: a58, c8: a68, x9: a81, y9: a29, z9: a39, a9: a49, b9: a59, c9: a69, x10: a91, y12: a210, z10: a310, a10: a410, b10: a510, c10: a610, x11: a111, y13: a211, z11: a311, a11: a411, b11: a511, c11: a611, x12: a112, y14: a212, z12: a312, a12: a412, b12: a512, c12: a612, x13: a113, y15: a213, z13: a313, a13: a413, b13: a513, c13: a613, x14: a114, y16: a214, z14: a314, a14: a414, b14: a514, c14: a614, x15: a115, y17: a215, z15: a315, a15: a415, b15: a515, c15: a615, x16: a116, y18: a216, z16: a316, a16: a416, b16: a516, c16: a616, x17: a117, y19: a217, z17: a317, a17: a417, b17: a517, c17: a617, x18: a118, y10: a218, z18: a318, a18: a418, b18: a518, c18: a618) => Array<a1 | a21 | a31 | a41 | a51 | a61 | a119 | a22 | a32 | a42 | a52 | a62 | a219 | a23 | a33 | a43 | a53 | a63 | a319 | a24 | a34 | a44 | a54 | a64 | a419 | a25 | a35 | a45 | a55 | a65 | a519 | a26 | a36 | a46 | a56 | a66 | a619 | a27 | a37 | a47 | a57 | a67 | a71 | a28 | a38 | a48 | a58 | a68 | a81 | a29 | a39 | a49 | a59 | a69 | a91 | a210 | a310 | a410 | a510 | a610 | a111 | a211 | a311 | a411 | a511 | a611 | a112 | a212 | a312 | a412 | a512 | a612 | a113 | a213 | a313 | a413 | a513 | a613 | a114 | a214 | a314 | a414 | a514 | a614 | a115 | a215 | a315 | a415 | a515 | a615 | a116 | a216 | a316 | a416 | a516 | a616 | a117 | a217 | a317 | a417 | a517 | a617 | a118 | a218 | a318 | a418 | a518 | a618>
 
     a1, a21, a31, a41, a51, a61,
 >a1 : a1
@@ -402,7 +402,7 @@ function Foo<
     )
     {
         return [x1 , y1 , z1 , a1 , b1 , c1,
->[x1 , y1 , z1 , a1 , b1 , c1,           x2 , y2 , z2 , a2 , b2 , c2,           x3 , y3 , z3 , a3 , b3 , c3,           x4 , y4 , z4 , a4 , b4 , c4,           x5 , y5 , z5 , a5 , b5 , c5,           x6 , y6 , z6 , a6 , b6 , c6,           x7 , y7 , z7 , a7 , b7 , c7,           x8 , y8 , z8 , a8 , b8 , c8,           x9 , y9 , z9 , a9 , b9 , c9,           x10 , y12 , z10 , a10 , b10 , c10,           x11 , y13 , z11 , a11 , b11 , c11,           x12 , y14 , z12 , a12 , b12 , c12,           x13 , y15 , z13 , a13 , b13 , c13,           x14 , y16 , z14 , a14 , b14 , c14,           x15 , y17 , z15 , a15 , b15 , c15,           x16 , y18 , z16 , a16 , b16 , c16,           x17 , y19 , z17 , a17 , b17 , c17,           x18 , y10 , z18 , a18 , b18 , c18] : {}[]
+>[x1 , y1 , z1 , a1 , b1 , c1,           x2 , y2 , z2 , a2 , b2 , c2,           x3 , y3 , z3 , a3 , b3 , c3,           x4 , y4 , z4 , a4 , b4 , c4,           x5 , y5 , z5 , a5 , b5 , c5,           x6 , y6 , z6 , a6 , b6 , c6,           x7 , y7 , z7 , a7 , b7 , c7,           x8 , y8 , z8 , a8 , b8 , c8,           x9 , y9 , z9 , a9 , b9 , c9,           x10 , y12 , z10 , a10 , b10 , c10,           x11 , y13 , z11 , a11 , b11 , c11,           x12 , y14 , z12 , a12 , b12 , c12,           x13 , y15 , z13 , a13 , b13 , c13,           x14 , y16 , z14 , a14 , b14 , c14,           x15 , y17 , z15 , a15 , b15 , c15,           x16 , y18 , z16 , a16 , b16 , c16,           x17 , y19 , z17 , a17 , b17 , c17,           x18 , y10 , z18 , a18 , b18 , c18] : Array<a1 | a21 | a31 | a41 | a51 | a61 | a119 | a22 | a32 | a42 | a52 | a62 | a219 | a23 | a33 | a43 | a53 | a63 | a319 | a24 | a34 | a44 | a54 | a64 | a419 | a25 | a35 | a45 | a55 | a65 | a519 | a26 | a36 | a46 | a56 | a66 | a619 | a27 | a37 | a47 | a57 | a67 | a71 | a28 | a38 | a48 | a58 | a68 | a81 | a29 | a39 | a49 | a59 | a69 | a91 | a210 | a310 | a410 | a510 | a610 | a111 | a211 | a311 | a411 | a511 | a611 | a112 | a212 | a312 | a412 | a512 | a612 | a113 | a213 | a313 | a413 | a513 | a613 | a114 | a214 | a314 | a414 | a514 | a614 | a115 | a215 | a315 | a415 | a515 | a615 | a116 | a216 | a316 | a416 | a516 | a616 | a117 | a217 | a317 | a417 | a517 | a617 | a118 | a218 | a318 | a418 | a518 | a618>
 >x1 : a1
 >y1 : a21
 >z1 : a31
diff --git a/tests/baselines/reference/heterogeneousArrayAndOverloads.errors.txt b/tests/baselines/reference/heterogeneousArrayAndOverloads.errors.txt
index 072d06e86868b..985aaa7948cb8 100644
--- a/tests/baselines/reference/heterogeneousArrayAndOverloads.errors.txt
+++ b/tests/baselines/reference/heterogeneousArrayAndOverloads.errors.txt
@@ -1,5 +1,6 @@
-tests/cases/compiler/heterogeneousArrayAndOverloads.ts(9,19): error TS2345: Argument of type '{}[]' is not assignable to parameter of type 'string[]'.
-  Type '{}' is not assignable to type 'string'.
+tests/cases/compiler/heterogeneousArrayAndOverloads.ts(9,19): error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'string[]'.
+  Type 'string | number' is not assignable to type 'string':
+    Type 'number' is not assignable to type 'string'.
 
 
 ==== tests/cases/compiler/heterogeneousArrayAndOverloads.ts (1 errors) ====
@@ -13,7 +14,8 @@ tests/cases/compiler/heterogeneousArrayAndOverloads.ts(9,19): error TS2345: Argu
             this.test([]);
             this.test([1, 2, "hi", 5]); // Error
                       ~~~~~~~~~~~~~~~
-!!! error TS2345: Argument of type '{}[]' is not assignable to parameter of type 'string[]'.
-!!! error TS2345:   Type '{}' is not assignable to type 'string'.
+!!! error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'string[]'.
+!!! error TS2345:   Type 'string | number' is not assignable to type 'string':
+!!! error TS2345:     Type 'number' is not assignable to type 'string'.
         }
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/heterogeneousArrayLiterals.types b/tests/baselines/reference/heterogeneousArrayLiterals.types
index 81770731633f4..c236fe7ff6d59 100644
--- a/tests/baselines/reference/heterogeneousArrayLiterals.types
+++ b/tests/baselines/reference/heterogeneousArrayLiterals.types
@@ -2,16 +2,16 @@
 // type of an array is the best common type of its elements (plus its contextual type if it exists)
 
 var a = [1, '']; // {}[]
->a : {}[]
->[1, ''] : {}[]
+>a : Array<string | number>
+>[1, ''] : Array<string | number>
 
 var b = [1, null]; // number[]
 >b : number[]
 >[1, null] : number[]
 
 var c = [1, '', null]; // {}[]
->c : {}[]
->[1, '', null] : {}[]
+>c : Array<string | number>
+>[1, '', null] : Array<string | number>
 
 var d = [{}, 1]; // {}[]
 >d : {}[]
@@ -31,8 +31,8 @@ var f = [[], [1]]; // number[][]
 >[1] : number[]
 
 var g = [[1], ['']]; // {}[]
->g : {}[]
->[[1], ['']] : {}[]
+>g : Array<string[] | number[]>
+>[[1], ['']] : Array<string[] | number[]>
 >[1] : number[]
 >[''] : string[]
 
@@ -46,8 +46,8 @@ var h = [{ foo: 1, bar: '' }, { foo: 2 }]; // {foo: number}[]
 >foo : number
 
 var i = [{ foo: 1, bar: '' }, { foo: '' }]; // {}[]
->i : {}[]
->[{ foo: 1, bar: '' }, { foo: '' }] : {}[]
+>i : Array<{ foo: number; bar: string; } | { foo: string; }>
+>[{ foo: 1, bar: '' }, { foo: '' }] : Array<{ foo: number; bar: string; } | { foo: string; }>
 >{ foo: 1, bar: '' } : { foo: number; bar: string; }
 >foo : number
 >bar : string
@@ -55,8 +55,8 @@ var i = [{ foo: 1, bar: '' }, { foo: '' }]; // {}[]
 >foo : string
 
 var j = [() => 1, () => '']; // {}[]
->j : {}[]
->[() => 1, () => ''] : {}[]
+>j : Array<{ (): number; } | { (): string; }>
+>[() => 1, () => ''] : Array<{ (): number; } | { (): string; }>
 >() => 1 : () => number
 >() => '' : () => string
 
@@ -80,8 +80,8 @@ var m = [() => 1, () => '', () => null]; // { (): any }[]
 >() => null : () => any
 
 var n = [[() => 1], [() => '']]; // {}[]
->n : {}[]
->[[() => 1], [() => '']] : {}[]
+>n : Array<{ (): number; }[] | { (): string; }[]>
+>[[() => 1], [() => '']] : Array<{ (): number; }[] | { (): string; }[]>
 >[() => 1] : { (): number; }[]
 >() => 1 : () => number
 >[() => ''] : { (): string; }[]
@@ -129,8 +129,8 @@ module Derived {
 >base : Base
 
     var i = [{ foo: base, basear: derived }, { foo: derived }]; // {foo: Derived}[]
->i : {}[]
->[{ foo: base, basear: derived }, { foo: derived }] : {}[]
+>i : Array<{ foo: Base; basear: Derived; } | { foo: Derived; }>
+>[{ foo: base, basear: derived }, { foo: derived }] : Array<{ foo: Base; basear: Derived; } | { foo: Derived; }>
 >{ foo: base, basear: derived } : { foo: Base; basear: Derived; }
 >foo : Base
 >base : Base
@@ -149,8 +149,8 @@ module Derived {
 >derived : Derived
 
     var k = [() => base, () => 1]; // {}[]~
->k : {}[]
->[() => base, () => 1] : {}[]
+>k : Array<{ (): Base; } | { (): number; }>
+>[() => base, () => 1] : Array<{ (): Base; } | { (): number; }>
 >() => base : () => Base
 >base : Base
 >() => 1 : () => number
@@ -182,8 +182,8 @@ module Derived {
 >derived : Derived
 
     var o = [derived, derived2]; // {}[]
->o : {}[]
->[derived, derived2] : {}[]
+>o : Array<Derived | Derived2>
+>[derived, derived2] : Array<Derived | Derived2>
 >derived : Derived
 >derived2 : Derived2
 
@@ -195,8 +195,8 @@ module Derived {
 >base : Base
 
     var q = [[() => derived2], [() => derived]]; // {}[]
->q : {}[]
->[[() => derived2], [() => derived]] : {}[]
+>q : Array<{ (): Derived2; }[] | { (): Derived; }[]>
+>[[() => derived2], [() => derived]] : Array<{ (): Derived2; }[] | { (): Derived; }[]>
 >[() => derived2] : { (): Derived2; }[]
 >() => derived2 : () => Derived2
 >derived2 : Derived2
@@ -212,24 +212,24 @@ module WithContextualType {
     var a: Base[] = [derived, derived2];
 >a : Base[]
 >Base : Base
->[derived, derived2] : Base[]
+>[derived, derived2] : Array<Derived | Derived2>
 >derived : Derived
 >derived2 : Derived2
 
     var b: Derived[] = [null];
 >b : Derived[]
 >Derived : Derived
->[null] : Derived[]
+>[null] : null[]
 
     var c: Derived[] = [];
 >c : Derived[]
 >Derived : Derived
->[] : Derived[]
+>[] : undefined[]
 
     var d: { (): Base }[] = [() => derived, () => derived2];
 >d : { (): Base; }[]
 >Base : Base
->[() => derived, () => derived2] : { (): Base; }[]
+>[() => derived, () => derived2] : Array<{ (): Derived; } | { (): Derived2; }>
 >() => derived : () => Derived
 >derived : Derived
 >() => derived2 : () => Derived2
@@ -257,19 +257,19 @@ function foo<T, U>(t: T, u: U) {
 >t : T
 
     var c = [t, u]; // {}[]
->c : {}[]
->[t, u] : {}[]
+>c : Array<T | U>
+>[t, u] : Array<T | U>
 >t : T
 >u : U
 
     var d = [t, 1]; // {}[]
->d : {}[]
->[t, 1] : {}[]
+>d : Array<number | T>
+>[t, 1] : Array<number | T>
 >t : T
 
     var e = [() => t, () => u]; // {}[]
->e : {}[]
->[() => t, () => u] : {}[]
+>e : Array<{ (): T; } | { (): U; }>
+>[() => t, () => u] : Array<{ (): T; } | { (): U; }>
 >() => t : () => T
 >t : T
 >() => u : () => U
@@ -308,19 +308,19 @@ function foo2<T extends Base, U extends Derived>(t: T, u: U) {
 >t : T
 
     var c = [t, u]; // {}[]
->c : {}[]
->[t, u] : {}[]
+>c : Array<T | U>
+>[t, u] : Array<T | U>
 >t : T
 >u : U
 
     var d = [t, 1]; // {}[]
->d : {}[]
->[t, 1] : {}[]
+>d : Array<number | T>
+>[t, 1] : Array<number | T>
 >t : T
 
     var e = [() => t, () => u]; // {}[]
->e : {}[]
->[() => t, () => u] : {}[]
+>e : Array<{ (): T; } | { (): U; }>
+>[() => t, () => u] : Array<{ (): T; } | { (): U; }>
 >() => t : () => T
 >t : T
 >() => u : () => U
@@ -342,8 +342,8 @@ function foo2<T extends Base, U extends Derived>(t: T, u: U) {
 >base : Base
 
     var h = [t, derived]; // Derived[]
->h : {}[]
->[t, derived] : {}[]
+>h : Array<Derived | T>
+>[t, derived] : Array<Derived | T>
 >t : T
 >derived : Derived
 
@@ -383,19 +383,19 @@ function foo3<T extends Derived, U extends Derived>(t: T, u: U) {
 >t : T
 
     var c = [t, u]; // {}[]
->c : {}[]
->[t, u] : {}[]
+>c : Array<T | U>
+>[t, u] : Array<T | U>
 >t : T
 >u : U
 
     var d = [t, 1]; // {}[]
->d : {}[]
->[t, 1] : {}[]
+>d : Array<number | T>
+>[t, 1] : Array<number | T>
 >t : T
 
     var e = [() => t, () => u]; // {}[]
->e : {}[]
->[() => t, () => u] : {}[]
+>e : Array<{ (): T; } | { (): U; }>
+>[() => t, () => u] : Array<{ (): T; } | { (): U; }>
 >() => t : () => T
 >t : T
 >() => u : () => U
@@ -458,19 +458,19 @@ function foo4<T extends Base, U extends Base>(t: T, u: U) {
 >t : T
 
     var c = [t, u]; // BUG 821629
->c : {}[]
->[t, u] : {}[]
+>c : Array<T | U>
+>[t, u] : Array<T | U>
 >t : T
 >u : U
 
     var d = [t, 1]; // {}[]
->d : {}[]
->[t, 1] : {}[]
+>d : Array<number | T>
+>[t, 1] : Array<number | T>
 >t : T
 
     var e = [() => t, () => u]; // {}[]
->e : {}[]
->[() => t, () => u] : {}[]
+>e : Array<{ (): T; } | { (): U; }>
+>[() => t, () => u] : Array<{ (): T; } | { (): U; }>
 >() => t : () => T
 >t : T
 >() => u : () => U
@@ -492,8 +492,8 @@ function foo4<T extends Base, U extends Base>(t: T, u: U) {
 >base : Base
 
     var h = [t, derived]; // Derived[]
->h : {}[]
->[t, derived] : {}[]
+>h : Array<Derived | T>
+>[t, derived] : Array<Derived | T>
 >t : T
 >derived : Derived
 
@@ -504,15 +504,15 @@ function foo4<T extends Base, U extends Base>(t: T, u: U) {
 >base : Base
 
     var j = [u, derived]; // Derived[]
->j : {}[]
->[u, derived] : {}[]
+>j : Array<Derived | U>
+>[u, derived] : Array<Derived | U>
 >u : U
 >derived : Derived
 
     var k: Base[] = [t, u];
 >k : Base[]
 >Base : Base
->[t, u] : Base[]
+>[t, u] : Array<T | U>
 >t : T
 >u : U
 }
diff --git a/tests/baselines/reference/incrementOperatorWithAnyOtherType.types b/tests/baselines/reference/incrementOperatorWithAnyOtherType.types
index 165c166941cbb..930c87274d039 100644
--- a/tests/baselines/reference/incrementOperatorWithAnyOtherType.types
+++ b/tests/baselines/reference/incrementOperatorWithAnyOtherType.types
@@ -9,7 +9,7 @@ var ANY1;
 
 var ANY2: any[] = ["", ""];
 >ANY2 : any[]
->["", ""] : any[]
+>["", ""] : string[]
 
 var obj = {x:1,y:null};
 >obj : { x: number; y: any; }
diff --git a/tests/baselines/reference/incrementOperatorWithEnumType.errors.txt b/tests/baselines/reference/incrementOperatorWithEnumType.errors.txt
index 7617dbba379b3..9bcf6c7612f66 100644
--- a/tests/baselines/reference/incrementOperatorWithEnumType.errors.txt
+++ b/tests/baselines/reference/incrementOperatorWithEnumType.errors.txt
@@ -1,21 +1,21 @@
-tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts(7,23): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts(12,1): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-
-
-==== tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts (2 errors) ====
-    // ++ operator on enum type
-    
-    enum ENUM1 { A, B, "" };
-    
-    // expression
-    var ResultIsNumber1 = ++ENUM1["B"];
-    var ResultIsNumber2 = ENUM1.B++;
-                          ~~~~~~~
-!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
-    
-    // miss assignment operator
-    ++ENUM1["B"];
-    
-    ENUM1.B++;
-    ~~~~~~~
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts(7,23): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts(12,1): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+
+
+==== tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts (2 errors) ====
+    // ++ operator on enum type
+    
+    enum ENUM1 { A, B, "" };
+    
+    // expression
+    var ResultIsNumber1 = ++ENUM1["B"];
+    var ResultIsNumber2 = ENUM1.B++;
+                          ~~~~~~~
+!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+    
+    // miss assignment operator
+    ++ENUM1["B"];
+    
+    ENUM1.B++;
+    ~~~~~~~
 !!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
\ No newline at end of file
diff --git a/tests/baselines/reference/indexSignaturesInferentialTyping.types b/tests/baselines/reference/indexSignaturesInferentialTyping.types
index 3c16db3a2bf9d..4054ccca227b2 100644
--- a/tests/baselines/reference/indexSignaturesInferentialTyping.types
+++ b/tests/baselines/reference/indexSignaturesInferentialTyping.types
@@ -24,10 +24,10 @@ var x1 = foo({ 0: 0, 1: 1 });       // type should be number
 >{ 0: 0, 1: 1 } : { [x: number]: number; 0: number; 1: number; }
 
 var x2 = foo({ zero: 0, one: 1 });
->x2 : {}
->foo({ zero: 0, one: 1 }) : {}
+>x2 : any
+>foo({ zero: 0, one: 1 }) : any
 >foo : <T>(items: { [x: number]: T; }) => T
->{ zero: 0, one: 1 } : { [x: number]: {}; zero: number; one: number; }
+>{ zero: 0, one: 1 } : { [x: number]: undefined; zero: number; one: number; }
 >zero : number
 >one : number
 
diff --git a/tests/baselines/reference/indexer.types b/tests/baselines/reference/indexer.types
index 236113cfaa823..9987fdde0b16c 100644
--- a/tests/baselines/reference/indexer.types
+++ b/tests/baselines/reference/indexer.types
@@ -17,7 +17,7 @@ interface JQuery {
 var jq:JQuery={ 0: { id : "a" }, 1: { id : "b" } };
 >jq : JQuery
 >JQuery : JQuery
->{ 0: { id : "a" }, 1: { id : "b" } } : { [x: number]: JQueryElement; 0: { id: string; }; 1: { id: string; }; }
+>{ 0: { id : "a" }, 1: { id : "b" } } : { [x: number]: { id: string; }; 0: { id: string; }; 1: { id: string; }; }
 >{ id : "a" } : { id: string; }
 >id : string
 >{ id : "b" } : { id: string; }
diff --git a/tests/baselines/reference/indexer2.errors.txt b/tests/baselines/reference/indexer2.errors.txt
new file mode 100644
index 0000000000000..9587bb6bb75d1
--- /dev/null
+++ b/tests/baselines/reference/indexer2.errors.txt
@@ -0,0 +1,20 @@
+tests/cases/compiler/indexer2.ts(6,25): error TS2353: Neither type '{ [x: number]: undefined; }' nor type 'IDirectChildrenMap' is assignable to the other:
+  Types of property 'hasOwnProperty' are incompatible:
+    Type '(v: string) => boolean' is not assignable to type '(objectId: number) => boolean':
+      Types of parameters 'v' and 'objectId' are incompatible:
+        Type 'string' is not assignable to type 'number'.
+
+
+==== tests/cases/compiler/indexer2.ts (1 errors) ====
+    interface IHeapObjectProperty {}
+    interface IDirectChildrenMap { 
+            hasOwnProperty(objectId: number) : boolean; 
+            [objectId: number] : IHeapObjectProperty[]; 
+    }    
+    var directChildrenMap = <IDirectChildrenMap>{}; 
+                            ~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2353: Neither type '{ [x: number]: undefined; }' nor type 'IDirectChildrenMap' is assignable to the other:
+!!! error TS2353:   Types of property 'hasOwnProperty' are incompatible:
+!!! error TS2353:     Type '(v: string) => boolean' is not assignable to type '(objectId: number) => boolean':
+!!! error TS2353:       Types of parameters 'v' and 'objectId' are incompatible:
+!!! error TS2353:         Type 'string' is not assignable to type 'number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/indexer2.types b/tests/baselines/reference/indexer2.types
deleted file mode 100644
index 498ade679a8fc..0000000000000
--- a/tests/baselines/reference/indexer2.types
+++ /dev/null
@@ -1,21 +0,0 @@
-=== tests/cases/compiler/indexer2.ts ===
-interface IHeapObjectProperty {}
->IHeapObjectProperty : IHeapObjectProperty
-
-interface IDirectChildrenMap { 
->IDirectChildrenMap : IDirectChildrenMap
-
-        hasOwnProperty(objectId: number) : boolean; 
->hasOwnProperty : (objectId: number) => boolean
->objectId : number
-
-        [objectId: number] : IHeapObjectProperty[]; 
->objectId : number
->IHeapObjectProperty : IHeapObjectProperty
-}    
-var directChildrenMap = <IDirectChildrenMap>{}; 
->directChildrenMap : IDirectChildrenMap
-><IDirectChildrenMap>{} : IDirectChildrenMap
->IDirectChildrenMap : IDirectChildrenMap
->{} : { [x: number]: IHeapObjectProperty[]; }
-
diff --git a/tests/baselines/reference/indexer2A.errors.txt b/tests/baselines/reference/indexer2A.errors.txt
index adf90fb743f63..548ed5e565b43 100644
--- a/tests/baselines/reference/indexer2A.errors.txt
+++ b/tests/baselines/reference/indexer2A.errors.txt
@@ -1,7 +1,12 @@
 tests/cases/compiler/indexer2A.ts(4,5): error TS2391: Function implementation is missing or not immediately following the declaration.
+tests/cases/compiler/indexer2A.ts(7,25): error TS2353: Neither type '{ [x: number]: undefined; }' nor type 'IDirectChildrenMap' is assignable to the other:
+  Types of property 'hasOwnProperty' are incompatible:
+    Type '(v: string) => boolean' is not assignable to type '(objectId: number) => boolean':
+      Types of parameters 'v' and 'objectId' are incompatible:
+        Type 'string' is not assignable to type 'number'.
 
 
-==== tests/cases/compiler/indexer2A.ts (1 errors) ====
+==== tests/cases/compiler/indexer2A.ts (2 errors) ====
     class IHeapObjectProperty { }
     class IDirectChildrenMap {
         // Decided to enforce a semicolon after declarations
@@ -10,4 +15,10 @@ tests/cases/compiler/indexer2A.ts(4,5): error TS2391: Function implementation is
 !!! error TS2391: Function implementation is missing or not immediately following the declaration.
         [objectId: number]: IHeapObjectProperty[]
     }
-    var directChildrenMap = <IDirectChildrenMap>{}; 
\ No newline at end of file
+    var directChildrenMap = <IDirectChildrenMap>{}; 
+                            ~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2353: Neither type '{ [x: number]: undefined; }' nor type 'IDirectChildrenMap' is assignable to the other:
+!!! error TS2353:   Types of property 'hasOwnProperty' are incompatible:
+!!! error TS2353:     Type '(v: string) => boolean' is not assignable to type '(objectId: number) => boolean':
+!!! error TS2353:       Types of parameters 'v' and 'objectId' are incompatible:
+!!! error TS2353:         Type 'string' is not assignable to type 'number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/indexer3.types b/tests/baselines/reference/indexer3.types
index 2b23ac8588539..7f660ab6aa95e 100644
--- a/tests/baselines/reference/indexer3.types
+++ b/tests/baselines/reference/indexer3.types
@@ -3,7 +3,7 @@ var dateMap: { [x: string]: Date; } = {}
 >dateMap : { [x: string]: Date; }
 >x : string
 >Date : Date
->{} : { [x: string]: Date; }
+>{} : { [x: string]: undefined; }
 
 var r: Date = dateMap["hello"] // result type includes indexer using BCT
 >r : Date
diff --git a/tests/baselines/reference/indexerA.types b/tests/baselines/reference/indexerA.types
index 7b409ecedc0ce..39f7372c8390c 100644
--- a/tests/baselines/reference/indexerA.types
+++ b/tests/baselines/reference/indexerA.types
@@ -17,7 +17,7 @@ class JQuery {
 var jq:JQuery={ 0: { id : "a" }, 1: { id : "b" } };
 >jq : JQuery
 >JQuery : JQuery
->{ 0: { id : "a" }, 1: { id : "b" } } : { [x: number]: JQueryElement; 0: { id: string; }; 1: { id: string; }; }
+>{ 0: { id : "a" }, 1: { id : "b" } } : { [x: number]: { id: string; }; 0: { id: string; }; 1: { id: string; }; }
 >{ id : "a" } : { id: string; }
 >id : string
 >{ id : "b" } : { id: string; }
diff --git a/tests/baselines/reference/indexerWithTuple.types b/tests/baselines/reference/indexerWithTuple.types
index 0a2de09b2c8df..28053a330817f 100644
--- a/tests/baselines/reference/indexerWithTuple.types
+++ b/tests/baselines/reference/indexerWithTuple.types
@@ -26,19 +26,19 @@ var ele11 = strNumTuple[1]; // number
 >strNumTuple : [string, number]
 
 var ele12 = strNumTuple[2]; // {}
->ele12 : {}
->strNumTuple[2] : {}
+>ele12 : string | number
+>strNumTuple[2] : string | number
 >strNumTuple : [string, number]
 
 var ele13 = strNumTuple[idx0]; // {}
->ele13 : {}
->strNumTuple[idx0] : {}
+>ele13 : string | number
+>strNumTuple[idx0] : string | number
 >strNumTuple : [string, number]
 >idx0 : number
 
 var ele14 = strNumTuple[idx1]; // {}
->ele14 : {}
->strNumTuple[idx1] : {}
+>ele14 : string | number
+>strNumTuple[idx1] : string | number
 >strNumTuple : [string, number]
 >idx1 : number
 
@@ -58,7 +58,7 @@ var strNumTuple1 = numTupleTuple[1];  //[string, number];
 >numTupleTuple : [number, [string, number]]
 
 var ele17 = numTupleTuple[2]; // {}
->ele17 : {}
->numTupleTuple[2] : {}
+>ele17 : number | [string, number]
+>numTupleTuple[2] : number | [string, number]
 >numTupleTuple : [number, [string, number]]
 
diff --git a/tests/baselines/reference/inferentialTypingWithFunctionTypeZip.types b/tests/baselines/reference/inferentialTypingWithFunctionTypeZip.types
index 11e017d6661c2..53a9dff0b48d6 100644
--- a/tests/baselines/reference/inferentialTypingWithFunctionTypeZip.types
+++ b/tests/baselines/reference/inferentialTypingWithFunctionTypeZip.types
@@ -34,7 +34,7 @@ var result = zipWith([1, 2], ['a', 'b'], pair);
 >zipWith([1, 2], ['a', 'b'], pair) : { x: number; y: {}; }[]
 >zipWith : <T, S, U>(a: T[], b: S[], f: (x: T) => (y: S) => U) => U[]
 >[1, 2] : number[]
->['a', 'b'] : {}[]
+>['a', 'b'] : string[]
 >pair : <T, S>(x: T) => (y: S) => { x: T; y: S; }
 
 var i = result[0].x; // number
diff --git a/tests/baselines/reference/inferentiallyTypingAnEmptyArray.types b/tests/baselines/reference/inferentiallyTypingAnEmptyArray.types
index c8f51c985e6e4..451280ee16f41 100644
--- a/tests/baselines/reference/inferentiallyTypingAnEmptyArray.types
+++ b/tests/baselines/reference/inferentiallyTypingAnEmptyArray.types
@@ -25,6 +25,6 @@ foo([]).bar;
 >foo([]).bar : any
 >foo([]) : any
 >foo : <T>(arr: T[]) => T
->[] : any[]
+>[] : undefined[]
 >bar : any
 
diff --git a/tests/baselines/reference/interfaceContextualType.types b/tests/baselines/reference/interfaceContextualType.types
index 88ba9dcbc24e1..3078ecfdfa426 100644
--- a/tests/baselines/reference/interfaceContextualType.types
+++ b/tests/baselines/reference/interfaceContextualType.types
@@ -27,11 +27,11 @@ class Bug {
 >ok : () => void
 
         this.values = {};
->this.values = {} : { [x: string]: IOptions; }
+>this.values = {} : { [x: string]: undefined; }
 >this.values : IMap
 >this : Bug
 >values : IMap
->{} : { [x: string]: IOptions; }
+>{} : { [x: string]: undefined; }
 
         this.values['comments'] = { italic: true };
 >this.values['comments'] = { italic: true } : { italic: boolean; }
@@ -46,11 +46,11 @@ class Bug {
 >shouldBeOK : () => void
 
         this.values = {
->this.values = {            comments: { italic: true }        } : { [x: string]: IOptions; comments: { italic: boolean; }; }
+>this.values = {            comments: { italic: true }        } : { [x: string]: { italic: boolean; }; comments: { italic: boolean; }; }
 >this.values : IMap
 >this : Bug
 >values : IMap
->{            comments: { italic: true }        } : { [x: string]: IOptions; comments: { italic: boolean; }; }
+>{            comments: { italic: true }        } : { [x: string]: { italic: boolean; }; comments: { italic: boolean; }; }
 
             comments: { italic: true }
 >comments : { italic: boolean; }
diff --git a/tests/baselines/reference/invalidMultipleVariableDeclarations.errors.txt b/tests/baselines/reference/invalidMultipleVariableDeclarations.errors.txt
index 0a4761994ddfb..b82c82b9eb516 100644
--- a/tests/baselines/reference/invalidMultipleVariableDeclarations.errors.txt
+++ b/tests/baselines/reference/invalidMultipleVariableDeclarations.errors.txt
@@ -7,7 +7,7 @@ tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDec
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(40,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'b' must be of type 'I', but here has type 'C2'.
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(43,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'.
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(46,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
-tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(47,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '{}[]'.
+tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(47,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'Array<C | D<string>>'.
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(50,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr2' must be of type 'D<string>[]', but here has type 'D<number>[]'.
 tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDeclarations.ts(53,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'm' must be of type 'typeof M', but here has type 'typeof A'.
 
@@ -79,7 +79,7 @@ tests/cases/conformance/statements/VariableStatements/invalidMultipleVariableDec
 !!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'number[]'.
     var arr = [new C(), new C2(), new D<string>()];
         ~~~
-!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type '{}[]'.
+!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'arr' must be of type 'string[]', but here has type 'Array<C | D<string>>'.
     
     var arr2 = [new D<string>()];
     var arr2 = new Array<D<number>>();
diff --git a/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.types b/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.types
index d44b220e818a3..95c9643c29a79 100644
--- a/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.types
+++ b/tests/baselines/reference/logicalOrExpressionIsContextuallyTyped.types
@@ -7,7 +7,7 @@
 var r: { a: string } = { a: '', b: 123 } || { a: '', b: true };
 >r : { a: string; }
 >a : string
->{ a: '', b: 123 } || { a: '', b: true } : { a: string; }
+>{ a: '', b: 123 } || { a: '', b: true } : { a: string; b: number; } | { a: string; b: boolean; }
 >{ a: '', b: 123 } : { a: string; b: number; }
 >a : string
 >b : number
diff --git a/tests/baselines/reference/logicalOrOperatorWithEveryType.types b/tests/baselines/reference/logicalOrOperatorWithEveryType.types
index 3cf0399f4377b..3e3b0dcf37fbe 100644
--- a/tests/baselines/reference/logicalOrOperatorWithEveryType.types
+++ b/tests/baselines/reference/logicalOrOperatorWithEveryType.types
@@ -108,38 +108,38 @@ var rb2 = a2 || a2;         // boolean   || boolean is boolean
 >a2 : boolean
 
 var rb3 = a3 || a2;         // number    || boolean is {}
->rb3 : {}
->a3 || a2 : {}
+>rb3 : number | boolean
+>a3 || a2 : number | boolean
 >a3 : number
 >a2 : boolean
 
 var rb4 = a4 || a2;         // string    || boolean is {}
->rb4 : {}
->a4 || a2 : {}
+>rb4 : string | boolean
+>a4 || a2 : string | boolean
 >a4 : string
 >a2 : boolean
 
 var rb5 = a5 || a2;         // void      || boolean is {}
->rb5 : {}
->a5 || a2 : {}
+>rb5 : boolean | void
+>a5 || a2 : boolean | void
 >a5 : void
 >a2 : boolean
 
 var rb6 = a6 || a2;         // enum      || boolean is {}
->rb6 : {}
->a6 || a2 : {}
+>rb6 : boolean | E
+>a6 || a2 : boolean | E
 >a6 : E
 >a2 : boolean
 
 var rb7 = a7 || a2;         // object    || boolean is {}
->rb7 : {}
->a7 || a2 : {}
+>rb7 : boolean | { a: string; }
+>a7 || a2 : boolean | { a: string; }
 >a7 : { a: string; }
 >a2 : boolean
 
 var rb8 = a8 || a2;         // array     || boolean is {}
->rb8 : {}
->a8 || a2 : {}
+>rb8 : boolean | string[]
+>a8 || a2 : boolean | string[]
 >a8 : string[]
 >a2 : boolean
 
@@ -161,8 +161,8 @@ var rc1 = a1 || a3;         // any       || number is any
 >a3 : number
 
 var rc2 = a2 || a3;         // boolean   || number is {}
->rc2 : {}
->a2 || a3 : {}
+>rc2 : number | boolean
+>a2 || a3 : number | boolean
 >a2 : boolean
 >a3 : number
 
@@ -173,14 +173,14 @@ var rc3 = a3 || a3;         // number    || number is number
 >a3 : number
 
 var rc4 = a4 || a3;         // string    || number is {}
->rc4 : {}
->a4 || a3 : {}
+>rc4 : string | number
+>a4 || a3 : string | number
 >a4 : string
 >a3 : number
 
 var rc5 = a5 || a3;         // void      || number is {}
->rc5 : {}
->a5 || a3 : {}
+>rc5 : number | void
+>a5 || a3 : number | void
 >a5 : void
 >a3 : number
 
@@ -191,14 +191,14 @@ var rc6 = a6 || a3;         // enum      || number is number
 >a3 : number
 
 var rc7 = a7 || a3;         // object    || number is {}
->rc7 : {}
->a7 || a3 : {}
+>rc7 : number | { a: string; }
+>a7 || a3 : number | { a: string; }
 >a7 : { a: string; }
 >a3 : number
 
 var rc8 = a8 || a3;         // array     || number is {}
->rc8 : {}
->a8 || a3 : {}
+>rc8 : number | string[]
+>a8 || a3 : number | string[]
 >a8 : string[]
 >a3 : number
 
@@ -220,14 +220,14 @@ var rd1 = a1 || a4;         // any       || string is any
 >a4 : string
 
 var rd2 = a2 || a4;         // boolean   || string is {}
->rd2 : {}
->a2 || a4 : {}
+>rd2 : string | boolean
+>a2 || a4 : string | boolean
 >a2 : boolean
 >a4 : string
 
 var rd3 = a3 || a4;         // number    || string is {}
->rd3 : {}
->a3 || a4 : {}
+>rd3 : string | number
+>a3 || a4 : string | number
 >a3 : number
 >a4 : string
 
@@ -238,26 +238,26 @@ var rd4 = a4 || a4;         // string    || string is string
 >a4 : string
 
 var rd5 = a5 || a4;         // void      || string is {}
->rd5 : {}
->a5 || a4 : {}
+>rd5 : string | void
+>a5 || a4 : string | void
 >a5 : void
 >a4 : string
 
 var rd6 = a6 || a4;         // enum      || string is {}
->rd6 : {}
->a6 || a4 : {}
+>rd6 : string | E
+>a6 || a4 : string | E
 >a6 : E
 >a4 : string
 
 var rd7 = a7 || a4;         // object    || string is {}
->rd7 : {}
->a7 || a4 : {}
+>rd7 : string | { a: string; }
+>a7 || a4 : string | { a: string; }
 >a7 : { a: string; }
 >a4 : string
 
 var rd8 = a8 || a4;         // array     || string is {}
->rd8 : {}
->a8 || a4 : {}
+>rd8 : string | string[]
+>a8 || a4 : string | string[]
 >a8 : string[]
 >a4 : string
 
@@ -279,20 +279,20 @@ var re1 = a1 || a5;         // any       || void is any
 >a5 : void
 
 var re2 = a2 || a5;         // boolean   || void is {}
->re2 : {}
->a2 || a5 : {}
+>re2 : boolean | void
+>a2 || a5 : boolean | void
 >a2 : boolean
 >a5 : void
 
 var re3 = a3 || a5;         // number    || void is {}
->re3 : {}
->a3 || a5 : {}
+>re3 : number | void
+>a3 || a5 : number | void
 >a3 : number
 >a5 : void
 
 var re4 = a4 || a5;         // string    || void is {}
->re4 : {}
->a4 || a5 : {}
+>re4 : string | void
+>a4 || a5 : string | void
 >a4 : string
 >a5 : void
 
@@ -303,20 +303,20 @@ var re5 = a5 || a5;         // void      || void is void
 >a5 : void
 
 var re6 = a6 || a5;         // enum      || void is {}
->re6 : {}
->a6 || a5 : {}
+>re6 : void | E
+>a6 || a5 : void | E
 >a6 : E
 >a5 : void
 
 var re7 = a7 || a5;         // object    || void is {}
->re7 : {}
->a7 || a5 : {}
+>re7 : void | { a: string; }
+>a7 || a5 : void | { a: string; }
 >a7 : { a: string; }
 >a5 : void
 
 var re8 = a8 || a5;         // array     || void is {}
->re8 : {}
->a8 || a5 : {}
+>re8 : void | string[]
+>a8 || a5 : void | string[]
 >a8 : string[]
 >a5 : void
 
@@ -338,8 +338,8 @@ var rg1 = a1 || a6;         // any       || enum is any
 >a6 : E
 
 var rg2 = a2 || a6;         // boolean   || enum is {}
->rg2 : {}
->a2 || a6 : {}
+>rg2 : boolean | E
+>a2 || a6 : boolean | E
 >a2 : boolean
 >a6 : E
 
@@ -350,14 +350,14 @@ var rg3 = a3 || a6;         // number    || enum is number
 >a6 : E
 
 var rg4 = a4 || a6;         // string    || enum is {}
->rg4 : {}
->a4 || a6 : {}
+>rg4 : string | E
+>a4 || a6 : string | E
 >a4 : string
 >a6 : E
 
 var rg5 = a5 || a6;         // void      || enum is {}
->rg5 : {}
->a5 || a6 : {}
+>rg5 : void | E
+>a5 || a6 : void | E
 >a5 : void
 >a6 : E
 
@@ -368,14 +368,14 @@ var rg6 = a6 || a6;         // enum      || enum is E
 >a6 : E
 
 var rg7 = a7 || a6;         // object    || enum is {}
->rg7 : {}
->a7 || a6 : {}
+>rg7 : E | { a: string; }
+>a7 || a6 : E | { a: string; }
 >a7 : { a: string; }
 >a6 : E
 
 var rg8 = a8 || a6;         // array     || enum is {}
->rg8 : {}
->a8 || a6 : {}
+>rg8 : string[] | E
+>a8 || a6 : string[] | E
 >a8 : string[]
 >a6 : E
 
@@ -397,32 +397,32 @@ var rh1 = a1 || a7;         // any       || object is any
 >a7 : { a: string; }
 
 var rh2 = a2 || a7;         // boolean   || object is {}
->rh2 : {}
->a2 || a7 : {}
+>rh2 : boolean | { a: string; }
+>a2 || a7 : boolean | { a: string; }
 >a2 : boolean
 >a7 : { a: string; }
 
 var rh3 = a3 || a7;         // number    || object is {}
->rh3 : {}
->a3 || a7 : {}
+>rh3 : number | { a: string; }
+>a3 || a7 : number | { a: string; }
 >a3 : number
 >a7 : { a: string; }
 
 var rh4 = a4 || a7;         // string    || object is {}
->rh4 : {}
->a4 || a7 : {}
+>rh4 : string | { a: string; }
+>a4 || a7 : string | { a: string; }
 >a4 : string
 >a7 : { a: string; }
 
 var rh5 = a5 || a7;         // void      || object is {}
->rh5 : {}
->a5 || a7 : {}
+>rh5 : void | { a: string; }
+>a5 || a7 : void | { a: string; }
 >a5 : void
 >a7 : { a: string; }
 
 var rh6 = a6 || a7;         // enum      || object is {}
->rh6 : {}
->a6 || a7 : {}
+>rh6 : E | { a: string; }
+>a6 || a7 : E | { a: string; }
 >a6 : E
 >a7 : { a: string; }
 
@@ -433,8 +433,8 @@ var rh7 = a7 || a7;         // object    || object is object
 >a7 : { a: string; }
 
 var rh8 = a8 || a7;         // array     || object is {}
->rh8 : {}
->a8 || a7 : {}
+>rh8 : string[] | { a: string; }
+>a8 || a7 : string[] | { a: string; }
 >a8 : string[]
 >a7 : { a: string; }
 
@@ -456,38 +456,38 @@ var ri1 = a1 || a8;         // any       || array is any
 >a8 : string[]
 
 var ri2 = a2 || a8;         // boolean   || array is {}
->ri2 : {}
->a2 || a8 : {}
+>ri2 : boolean | string[]
+>a2 || a8 : boolean | string[]
 >a2 : boolean
 >a8 : string[]
 
 var ri3 = a3 || a8;         // number    || array is {}
->ri3 : {}
->a3 || a8 : {}
+>ri3 : number | string[]
+>a3 || a8 : number | string[]
 >a3 : number
 >a8 : string[]
 
 var ri4 = a4 || a8;         // string    || array is {}
->ri4 : {}
->a4 || a8 : {}
+>ri4 : string | string[]
+>a4 || a8 : string | string[]
 >a4 : string
 >a8 : string[]
 
 var ri5 = a5 || a8;         // void      || array is {}
->ri5 : {}
->a5 || a8 : {}
+>ri5 : void | string[]
+>a5 || a8 : void | string[]
 >a5 : void
 >a8 : string[]
 
 var ri6 = a6 || a8;         // enum      || array is {}
->ri6 : {}
->a6 || a8 : {}
+>ri6 : string[] | E
+>a6 || a8 : string[] | E
 >a6 : E
 >a8 : string[]
 
 var ri7 = a7 || a8;         // object    || array is {}
->ri7 : {}
->a7 || a8 : {}
+>ri7 : string[] | { a: string; }
+>a7 || a8 : string[] | { a: string; }
 >a7 : { a: string; }
 >a8 : string[]
 
diff --git a/tests/baselines/reference/logicalOrOperatorWithTypeParameters.types b/tests/baselines/reference/logicalOrOperatorWithTypeParameters.types
index ff0e0ce568a07..4008fbbff5077 100644
--- a/tests/baselines/reference/logicalOrOperatorWithTypeParameters.types
+++ b/tests/baselines/reference/logicalOrOperatorWithTypeParameters.types
@@ -22,14 +22,14 @@ function fn1<T, U>(t: T, u: U) {
 >t : T
 
     var r3 = t || u;
->r3 : {}
->t || u : {}
+>r3 : T | U
+>t || u : T | U
 >t : T
 >u : U
 
     var r4: {} = t || u;
 >r4 : {}
->t || u : {}
+>t || u : T | U
 >t : T
 >u : U
 }
@@ -47,8 +47,8 @@ function fn2<T, U/* extends T*/, V/* extends T*/>(t: T, u: U, v: V) {
 >V : V
 
     var r1 = t || u;
->r1 : {}
->t || u : {}
+>r1 : T | U
+>t || u : T | U
 >t : T
 >u : U
 
@@ -67,14 +67,14 @@ function fn2<T, U/* extends T*/, V/* extends T*/>(t: T, u: U, v: V) {
 >u : U
 
     var r5 = u || v;
->r5 : {}
->u || v : {}
+>r5 : U | V
+>u || v : U | V
 >u : U
 >v : V
 
     var r6: {} = u || v;
 >r6 : {}
->u || v : {}
+>u || v : U | V
 >u : U
 >v : V
 
@@ -95,14 +95,14 @@ function fn3<T extends { a: string; b: string }, U extends { a: string; b: numbe
 >U : U
 
     var r1 = t || u;
->r1 : {}
->t || u : {}
+>r1 : T | U
+>t || u : T | U
 >t : T
 >u : U
 
     var r2: {} = t || u;
 >r2 : {}
->t || u : {}
+>t || u : T | U
 >t : T
 >u : U
 
@@ -116,7 +116,7 @@ function fn3<T extends { a: string; b: string }, U extends { a: string; b: numbe
     var r4: { a: string } = t || u;
 >r4 : { a: string; }
 >a : string
->t || u : { a: string; }
+>t || u : T | U
 >t : T
 >u : U
 }
diff --git a/tests/baselines/reference/memberVariableDeclarations1.types b/tests/baselines/reference/memberVariableDeclarations1.types
index 10ec78d69dcef..4dd68cdeb3511 100644
--- a/tests/baselines/reference/memberVariableDeclarations1.types
+++ b/tests/baselines/reference/memberVariableDeclarations1.types
@@ -20,7 +20,7 @@ class Employee {
     public reports: Employee[] = [];
 >reports : Employee[]
 >Employee : Employee
->[] : Employee[]
+>[] : undefined[]
 }
 
 class Employee2 {
@@ -57,11 +57,11 @@ class Employee2 {
 >manager : Employee
 
         this.reports = [];
->this.reports = [] : Employee[]
+>this.reports = [] : undefined[]
 >this.reports : Employee[]
 >this : Employee2
 >reports : Employee[]
->[] : Employee[]
+>[] : undefined[]
     }
 }
 
diff --git a/tests/baselines/reference/mismatchedExplicitTypeParameterAndArgumentType.errors.txt b/tests/baselines/reference/mismatchedExplicitTypeParameterAndArgumentType.errors.txt
index 557f60967a6a0..ed4f45ec1de75 100644
--- a/tests/baselines/reference/mismatchedExplicitTypeParameterAndArgumentType.errors.txt
+++ b/tests/baselines/reference/mismatchedExplicitTypeParameterAndArgumentType.errors.txt
@@ -1,5 +1,6 @@
-tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(10,30): error TS2345: Argument of type '{}[]' is not assignable to parameter of type 'number[]'.
-  Type '{}' is not assignable to type 'number'.
+tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(10,30): error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+  Type 'string | number' is not assignable to type 'number':
+    Type 'string' is not assignable to type 'number'.
 tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(11,11): error TS2346: Supplied parameters do not match any signature of call target.
 
 
@@ -15,8 +16,9 @@ tests/cases/compiler/mismatchedExplicitTypeParameterAndArgumentType.ts(11,11): e
     var r6 = map<Object, Object>([1, ""], (x) => x.toString());
     var r7 = map<number, string>([1, ""], (x) => x.toString()); // error
                                  ~~~~~~~
-!!! error TS2345: Argument of type '{}[]' is not assignable to parameter of type 'number[]'.
-!!! error TS2345:   Type '{}' is not assignable to type 'number'.
+!!! error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+!!! error TS2345:   Type 'string | number' is not assignable to type 'number':
+!!! error TS2345:     Type 'string' is not assignable to type 'number'.
     var r7b = map<number>([1, ""], (x) => x.toString()); // error
               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2346: Supplied parameters do not match any signature of call target.
diff --git a/tests/baselines/reference/negateOperatorWithAnyOtherType.types b/tests/baselines/reference/negateOperatorWithAnyOtherType.types
index 8785ab073b201..85a2d9c92333b 100644
--- a/tests/baselines/reference/negateOperatorWithAnyOtherType.types
+++ b/tests/baselines/reference/negateOperatorWithAnyOtherType.types
@@ -9,7 +9,7 @@ var ANY1;
 
 var ANY2: any[] = ["", ""];
 >ANY2 : any[]
->["", ""] : any[]
+>["", ""] : string[]
 
 var obj: () => {}
 >obj : () => {}
diff --git a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.errors.txt b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.errors.txt
deleted file mode 100644
index d53f12fd50401..0000000000000
--- a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.errors.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-tests/cases/compiler/noImplicitAnyFunctionExpressionAssignment.ts(2,27): error TS7011: Function expression, which lacks return-type annotation, implicitly has an 'any' return type.
-tests/cases/compiler/noImplicitAnyFunctionExpressionAssignment.ts(6,28): error TS7010: 'f', which lacks return-type annotation, implicitly has an 'any' return type.
-
-
-==== tests/cases/compiler/noImplicitAnyFunctionExpressionAssignment.ts (2 errors) ====
-    
-    var x: (a: any) => void = function <T>(x: T) {
-                              ~~~~~~~~~~~~~~~~~~~~
-        return null;
-    ~~~~~~~~~~~~~~~~
-    };
-    ~
-!!! error TS7011: Function expression, which lacks return-type annotation, implicitly has an 'any' return type.
-    
-    var x2: (a: any) => void = function f<T>(x: T) {
-                               ~~~~~~~~~~~~~~~~~~~~~
-        return null;
-    ~~~~~~~~~~~~~~~~
-    };
-    ~
-!!! error TS7010: 'f', which lacks return-type annotation, implicitly has an 'any' return type.
\ No newline at end of file
diff --git a/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types
new file mode 100644
index 0000000000000..b07252dac6def
--- /dev/null
+++ b/tests/baselines/reference/noImplicitAnyFunctionExpressionAssignment.types
@@ -0,0 +1,24 @@
+=== tests/cases/compiler/noImplicitAnyFunctionExpressionAssignment.ts ===
+
+var x: (a: any) => void = function <T>(x: T) {
+>x : (a: any) => void
+>a : any
+>function <T>(x: T) {    return null;} : <T>(x: T) => any
+>T : T
+>x : T
+>T : T
+
+    return null;
+};
+
+var x2: (a: any) => void = function f<T>(x: T) {
+>x2 : (a: any) => void
+>a : any
+>function f<T>(x: T) {    return null;} : <T>(x: T) => any
+>f : <T>(x: T) => any
+>T : T
+>x : T
+>T : T
+
+    return null;
+};
diff --git a/tests/baselines/reference/nonContextuallyTypedLogicalOr.errors.txt b/tests/baselines/reference/nonContextuallyTypedLogicalOr.errors.txt
deleted file mode 100644
index ca4dc9f67e387..0000000000000
--- a/tests/baselines/reference/nonContextuallyTypedLogicalOr.errors.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-tests/cases/compiler/nonContextuallyTypedLogicalOr.ts(16,10): error TS2339: Property 'dummy' does not exist on type '{}'.
-
-
-==== tests/cases/compiler/nonContextuallyTypedLogicalOr.ts (1 errors) ====
-    interface Contextual {
-        dummy;
-        p?: number;
-    }
-    
-    interface Ellement {
-        dummy;
-        p: any;
-    }
-    
-    var c: Contextual;
-    var e: Ellement;
-    
-    // This should error. Even though we are contextually typing e with Contextual, the RHS still
-    // needs to be a supertype of the LHS to win as the best common type.
-    (c || e).dummy;
-             ~~~~~
-!!! error TS2339: Property 'dummy' does not exist on type '{}'.
\ No newline at end of file
diff --git a/tests/baselines/reference/nonContextuallyTypedLogicalOr.js b/tests/baselines/reference/nonContextuallyTypedLogicalOr.js
index a29390bcf7f59..e3ec95533fd2e 100644
--- a/tests/baselines/reference/nonContextuallyTypedLogicalOr.js
+++ b/tests/baselines/reference/nonContextuallyTypedLogicalOr.js
@@ -12,13 +12,9 @@ interface Ellement {
 var c: Contextual;
 var e: Ellement;
 
-// This should error. Even though we are contextually typing e with Contextual, the RHS still
-// needs to be a supertype of the LHS to win as the best common type.
 (c || e).dummy;
 
 //// [nonContextuallyTypedLogicalOr.js]
 var c;
 var e;
-// This should error. Even though we are contextually typing e with Contextual, the RHS still
-// needs to be a supertype of the LHS to win as the best common type.
 (c || e).dummy;
diff --git a/tests/baselines/reference/nonContextuallyTypedLogicalOr.types b/tests/baselines/reference/nonContextuallyTypedLogicalOr.types
new file mode 100644
index 0000000000000..aeb9d1409c6e6
--- /dev/null
+++ b/tests/baselines/reference/nonContextuallyTypedLogicalOr.types
@@ -0,0 +1,37 @@
+=== tests/cases/compiler/nonContextuallyTypedLogicalOr.ts ===
+interface Contextual {
+>Contextual : Contextual
+
+    dummy;
+>dummy : any
+
+    p?: number;
+>p : number
+}
+
+interface Ellement {
+>Ellement : Ellement
+
+    dummy;
+>dummy : any
+
+    p: any;
+>p : any
+}
+
+var c: Contextual;
+>c : Contextual
+>Contextual : Contextual
+
+var e: Ellement;
+>e : Ellement
+>Ellement : Ellement
+
+(c || e).dummy;
+>(c || e).dummy : any
+>(c || e) : Contextual | Ellement
+>c || e : Contextual | Ellement
+>c : Contextual
+>e : Ellement
+>dummy : any
+
diff --git a/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations.errors.txt b/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations.errors.txt
index 1560a28470261..b59b734b3d03e 100644
--- a/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations.errors.txt
+++ b/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations.errors.txt
@@ -10,9 +10,10 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(55,5): error TS2412: Property '"4.0"' of type 'number' is not assignable to numeric index type 'string'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(68,5): error TS2412: Property '2.0' of type 'number' is not assignable to numeric index type 'string'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(73,5): error TS2412: Property '"4.0"' of type 'number' is not assignable to numeric index type 'string'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(78,5): error TS2322: Type '{ [x: number]: {}; 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: any; X: string; foo: () => string; }' is not assignable to type '{ [x: number]: string; }':
+tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(78,5): error TS2322: Type '{ [x: number]: string | number; 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: any; X: string; foo: () => string; }' is not assignable to type '{ [x: number]: string; }':
   Index signatures are incompatible:
-    Type '{}' 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/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations.ts(88,9): error TS2304: Cannot find name 'Myn'.
 
 
@@ -116,9 +117,10 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
     // error
     var b: { [x: number]: string; } = {
         ~
-!!! error TS2322: Type '{ [x: number]: {}; 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: any; X: string; foo: () => string; }' is not assignable to type '{ [x: number]: string; }':
+!!! error TS2322: Type '{ [x: number]: string | number; 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: any; X: string; foo: () => string; }' is not assignable to type '{ [x: number]: string; }':
 !!! error TS2322:   Index signatures are incompatible:
-!!! error TS2322:     Type '{}' is not assignable to type 'string'.
+!!! error TS2322:     Type 'string | number' is not assignable to type 'string':
+!!! error TS2322:       Type 'number' is not assignable to type 'string'.
         a: '',
         b: 1, 
         c: () => { }, 
diff --git a/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.errors.txt b/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.errors.txt
index 0e9cff15560ff..4d0488ec80ffb 100644
--- a/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.errors.txt
+++ b/tests/baselines/reference/numericIndexerConstrainsPropertyDeclarations2.errors.txt
@@ -4,10 +4,10 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(26,5): error TS2412: Property '"4.0"' of type 'string' is not assignable to numeric index type 'A'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(34,5): error TS2412: Property '3.0' of type 'number' is not assignable to numeric index type 'A'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(35,5): error TS2412: Property '"4.0"' of type 'string' is not assignable to numeric index type 'A'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(39,5): error TS2322: Type '{ [x: number]: {}; 1.0: A; 2.0: B; 3.0: number; "2.5": B; "4.0": string; }' is not assignable to type '{ [x: number]: A; }':
+tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts(39,5): error TS2322: Type '{ [x: number]: string | number | A; 1.0: A; 2.0: B; 3.0: number; "2.5": B; "4.0": string; }' is not assignable to type '{ [x: number]: A; }':
   Index signatures are incompatible:
-    Type '{}' is not assignable to type 'A':
-      Property 'foo' is missing in type '{}'.
+    Type 'string | number | A' is not assignable to type 'A':
+      Type 'string' is not assignable to type 'A'.
 
 
 ==== tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerConstrainsPropertyDeclarations2.ts (7 errors) ====
@@ -63,10 +63,10 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/numericIndexerCo
     // error
     var b: { [x: number]: A } = {
         ~
-!!! error TS2322: Type '{ [x: number]: {}; 1.0: A; 2.0: B; 3.0: number; "2.5": B; "4.0": string; }' is not assignable to type '{ [x: number]: A; }':
+!!! error TS2322: Type '{ [x: number]: string | number | A; 1.0: A; 2.0: B; 3.0: number; "2.5": B; "4.0": string; }' is not assignable to type '{ [x: number]: A; }':
 !!! error TS2322:   Index signatures are incompatible:
-!!! error TS2322:     Type '{}' is not assignable to type 'A':
-!!! error TS2322:       Property 'foo' is missing in type '{}'.
+!!! error TS2322:     Type 'string | number | A' is not assignable to type 'A':
+!!! error TS2322:       Type 'string' is not assignable to type 'A'.
         1.0: new A(), 
         2.0: new B(), 
         "2.5": new B(),
diff --git a/tests/baselines/reference/numericIndexerConstraint4.types b/tests/baselines/reference/numericIndexerConstraint4.types
index f0004e52b45c5..78b57d4179ee5 100644
--- a/tests/baselines/reference/numericIndexerConstraint4.types
+++ b/tests/baselines/reference/numericIndexerConstraint4.types
@@ -22,7 +22,7 @@ var x: {
 >A : A
 
 } = { data: new B() }
->{ data: new B() } : { [x: number]: A; data: B; }
+>{ data: new B() } : { [x: number]: undefined; data: B; }
 >data : B
 >new B() : B
 >B : typeof B
diff --git a/tests/baselines/reference/objectIndexer.types b/tests/baselines/reference/objectIndexer.types
index a2a7f99cf5d7d..7b42ea51b5612 100644
--- a/tests/baselines/reference/objectIndexer.types
+++ b/tests/baselines/reference/objectIndexer.types
@@ -23,11 +23,11 @@ class Emitter {
 
     constructor () {
         this.listeners = {};
->this.listeners = {} : { [x: string]: Callback; }
+>this.listeners = {} : { [x: string]: undefined; }
 >this.listeners : IMap
 >this : Emitter
 >listeners : IMap
->{} : { [x: string]: Callback; }
+>{} : { [x: string]: undefined; }
     }
 }
 
diff --git a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers1.types b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers1.types
index ab83b0c78f0c9..a0603ae0777e1 100644
--- a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers1.types
+++ b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers1.types
@@ -50,7 +50,7 @@ var a: {
 var b: { [x: number]: string; } = { foo: '' };
 >b : { [x: number]: string; }
 >x : number
->{ foo: '' } : { [x: number]: string; foo: string; }
+>{ foo: '' } : { [x: number]: undefined; foo: string; }
 >foo : string
 
 function foo1(x: A);
diff --git a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers2.types b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers2.types
index cd8f19b2b7eff..9e4ccb5c43b11 100644
--- a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers2.types
+++ b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers2.types
@@ -64,7 +64,7 @@ var b: { [x: number]: Derived; } = { foo: <Derived>null };
 >b : { [x: number]: Derived; }
 >x : number
 >Derived : Derived
->{ foo: <Derived>null } : { [x: number]: Derived; foo: Derived; }
+>{ foo: <Derived>null } : { [x: number]: undefined; foo: Derived; }
 >foo : Derived
 ><Derived>null : Derived
 >Derived : Derived
diff --git a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers3.types b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers3.types
index 6a73749fc8416..3553f5f7252ee 100644
--- a/tests/baselines/reference/objectTypesIdentityWithNumericIndexers3.types
+++ b/tests/baselines/reference/objectTypesIdentityWithNumericIndexers3.types
@@ -50,7 +50,7 @@ var a: {
 var b: { [x: number]: string; } = { foo: '' };
 >b : { [x: number]: string; }
 >x : number
->{ foo: '' } : { [x: number]: string; foo: string; }
+>{ foo: '' } : { [x: number]: undefined; foo: string; }
 >foo : string
 
 function foo1(x: A);
diff --git a/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.types b/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.types
index 846190010b4c4..7ad68cefa4f56 100644
--- a/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.types
+++ b/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.types
@@ -37,7 +37,7 @@ module Bugs {
                                 var tokens:IToken[]= [];
 >tokens : IToken[]
 >IToken : IToken
->[] : IToken[]
+>[] : undefined[]
 
                                 tokens.push({ startIndex: 1, type: '', bracket: 3 });
 >tokens.push({ startIndex: 1, type: '', bracket: 3 }) : number
diff --git a/tests/baselines/reference/parser15.4.4.14-9-2.errors.txt b/tests/baselines/reference/parser15.4.4.14-9-2.errors.txt
index ab9bab7890c8a..237541b40f7ba 100644
--- a/tests/baselines/reference/parser15.4.4.14-9-2.errors.txt
+++ b/tests/baselines/reference/parser15.4.4.14-9-2.errors.txt
@@ -1,7 +1,8 @@
+tests/cases/conformance/parser/ecmascript5/parser15.4.4.14-9-2.ts(16,11): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/conformance/parser/ecmascript5/parser15.4.4.14-9-2.ts(25,1): error TS2304: Cannot find name 'runTestCase'.
 
 
-==== tests/cases/conformance/parser/ecmascript5/parser15.4.4.14-9-2.ts (1 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/parser15.4.4.14-9-2.ts (2 errors) ====
     /// Copyright (c) 2012 Ecma International.  All rights reserved. 
     /// Ecma International makes this code available under the terms and conditions set
     /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the 
@@ -18,6 +19,8 @@ tests/cases/conformance/parser/ecmascript5/parser15.4.4.14-9-2.ts(25,1): error T
       var one = 1;
       var _float = -(4/3);
       var a = new Array(false,undefined,null,"0",obj,-1.3333333333333, "str",-0,true,+0, one, 1,0, false, _float, -(4/3));
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
       if (a.indexOf(-(4/3)) === 14 &&      // a[14]=_float===-(4/3)
           a.indexOf(0) === 7      &&       // a[7] = +0, 0===+0
           a.indexOf(-0) === 7      &&     // a[7] = +0, -0===+0
diff --git a/tests/baselines/reference/parserEnum7.errors.txt b/tests/baselines/reference/parserEnum7.errors.txt
index 48c938e02de55..a4a2326546a05 100644
--- a/tests/baselines/reference/parserEnum7.errors.txt
+++ b/tests/baselines/reference/parserEnum7.errors.txt
@@ -1,15 +1,15 @@
-tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,3): error TS1151: An enum member cannot have a numeric name.
-tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,6): error TS1151: An enum member cannot have a numeric name.
-tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,9): error TS1151: An enum member cannot have a numeric name.
-
-
-==== tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts (3 errors) ====
-    enum E {
-      1, 2, 3
-      ~
-!!! error TS1151: An enum member cannot have a numeric name.
-         ~
-!!! error TS1151: An enum member cannot have a numeric name.
-            ~
-!!! error TS1151: An enum member cannot have a numeric name.
+tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,3): error TS1151: An enum member cannot have a numeric name.
+tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,6): error TS1151: An enum member cannot have a numeric name.
+tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,9): error TS1151: An enum member cannot have a numeric name.
+
+
+==== tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts (3 errors) ====
+    enum E {
+      1, 2, 3
+      ~
+!!! error TS1151: An enum member cannot have a numeric name.
+         ~
+!!! error TS1151: An enum member cannot have a numeric name.
+            ~
+!!! error TS1151: An enum member cannot have a numeric name.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserEnum7.js b/tests/baselines/reference/parserEnum7.js
index 831090f4ce782..3781167bbbaff 100644
--- a/tests/baselines/reference/parserEnum7.js
+++ b/tests/baselines/reference/parserEnum7.js
@@ -1,12 +1,12 @@
-//// [parserEnum7.ts]
+//// [parserEnum7.ts]
 enum E {
   1, 2, 3
-}
-
-//// [parserEnum7.js]
-var E;
-(function (E) {
-    E[E["1"] = 0] = "1";
-    E[E["2"] = 1] = "2";
-    E[E["3"] = 2] = "3";
-})(E || (E = {}));
+}
+
+//// [parserEnum7.js]
+var E;
+(function (E) {
+    E[E["1"] = 0] = "1";
+    E[E["2"] = 1] = "2";
+    E[E["3"] = 2] = "3";
+})(E || (E = {}));
diff --git a/tests/baselines/reference/promisePermutations.errors.txt b/tests/baselines/reference/promisePermutations.errors.txt
index ee723821cce6b..0b2aa01bb5ca0 100644
--- a/tests/baselines/reference/promisePermutations.errors.txt
+++ b/tests/baselines/reference/promisePermutations.errors.txt
@@ -1,3 +1,4 @@
+tests/cases/compiler/promisePermutations.ts(74,70): error TS2345: Argument of type '(x: number) => IPromise<number>' is not assignable to parameter of type '(value: IPromise<number>) => IPromise<number>'.
 tests/cases/compiler/promisePermutations.ts(79,19): error TS2345: Argument of type '(x: number, y?: string) => IPromise<string>' is not assignable to parameter of type '(value: string) => IPromise<string>'.
 tests/cases/compiler/promisePermutations.ts(82,19): error TS2345: Argument of type '(x: number, y?: string) => IPromise<string>' is not assignable to parameter of type '(value: string) => IPromise<string>'.
 tests/cases/compiler/promisePermutations.ts(83,19): error TS2345: Argument of type '(x: number, y?: string) => Promise<string>' is not assignable to parameter of type '(value: string) => Promise<string>'.
@@ -19,13 +20,20 @@ tests/cases/compiler/promisePermutations.ts(120,19): error TS2345: Argument of t
 tests/cases/compiler/promisePermutations.ts(121,19): error TS2345: Argument of type '<T>(x: T, cb: (a: T) => T) => Promise<T>' is not assignable to parameter of type '(value: number) => Promise<number>'.
 tests/cases/compiler/promisePermutations.ts(122,19): error TS2345: Argument of type '<T>(x: T, cb: (a: T) => T) => Promise<T>' is not assignable to parameter of type '(value: number) => IPromise<any>'.
 tests/cases/compiler/promisePermutations.ts(126,19): error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => IPromise<T>' is not assignable to parameter of type '(value: number) => IPromise<number>'.
+tests/cases/compiler/promisePermutations.ts(129,11): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/compiler/promisePermutations.ts(132,19): error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => IPromise<T>' is not assignable to parameter of type '(value: number) => IPromise<number>'.
 tests/cases/compiler/promisePermutations.ts(133,19): error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => Promise<T>' is not assignable to parameter of type '(value: number) => Promise<number>'.
 tests/cases/compiler/promisePermutations.ts(134,19): error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => Promise<T>' is not assignable to parameter of type '(value: number) => IPromise<any>'.
+tests/cases/compiler/promisePermutations.ts(137,11): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/compiler/promisePermutations.ts(144,12): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/compiler/promisePermutations.ts(152,12): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/compiler/promisePermutations.ts(156,21): error TS2345: Argument of type '{ (x: number): IPromise<number>; (x: string): IPromise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 tests/cases/compiler/promisePermutations.ts(158,21): error TS2345: Argument of type '{ (x: number): IPromise<number>; (x: string): IPromise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
+tests/cases/compiler/promisePermutations.ts(159,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => Promise<string>'.
+tests/cases/compiler/promisePermutations.ts(160,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 
 
-==== tests/cases/compiler/promisePermutations.ts (25 errors) ====
+==== tests/cases/compiler/promisePermutations.ts (33 errors) ====
     interface Promise<T> {
         then<U>(success?: (value: T) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>;
         then<U>(success?: (value: T) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>;
@@ -39,7 +47,7 @@ tests/cases/compiler/promisePermutations.ts(158,21): error TS2345: Argument of t
         then<U>(success?: (value: T) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
         then<U>(success?: (value: T) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>;
         then<U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
-        done?<U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
+        done? <U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
     }
     
     declare function testFunction(): IPromise<number>;
@@ -99,7 +107,9 @@ tests/cases/compiler/promisePermutations.ts(158,21): error TS2345: Argument of t
     var s3a = s3.then(testFunction3, testFunction3, testFunction3);
     var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P);
     var s3c = s3.then(testFunction3P, testFunction3, testFunction3);
-    var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3);
+    var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3); // error
+                                                                         ~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '(x: number) => IPromise<number>' is not assignable to parameter of type '(value: IPromise<number>) => IPromise<number>'.
     
     var r4: IPromise<string>;
     var sIPromise: (x: any) => IPromise<string>;
@@ -118,7 +128,7 @@ tests/cases/compiler/promisePermutations.ts(158,21): error TS2345: Argument of t
     var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
                       ~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '(x: number, y?: string) => Promise<string>' is not assignable to parameter of type '(value: string) => IPromise<string>'.
-    var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4); 
+    var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4);
     
     var r5: IPromise<string>;
     var r5a = r5.then(testFunction5, testFunction5, testFunction5); // error
@@ -197,6 +207,8 @@ tests/cases/compiler/promisePermutations.ts(158,21): error TS2345: Argument of t
     var r9b = r9.then(sIPromise, sIPromise, sIPromise); // ok
     var r9c = r9.then(nIPromise, nIPromise, nIPromise); // ok
     var r9d = r9.then(testFunction, sIPromise, nIPromise); // ok
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
     var s9: Promise<number>;
     var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
@@ -210,7 +222,9 @@ tests/cases/compiler/promisePermutations.ts(158,21): error TS2345: Argument of t
 !!! error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => Promise<T>' is not assignable to parameter of type '(value: number) => IPromise<any>'.
     var s9d = s9.then(sPromise, sPromise, sPromise); // ok
     var s9e = s9.then(nPromise, nPromise, nPromise); // ok
-    var s9f = s9.then(testFunction, sIPromise, nIPromise); // ok
+    var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
     
     var r10 = testFunction10(x => x);
@@ -218,6 +232,8 @@ tests/cases/compiler/promisePermutations.ts(158,21): error TS2345: Argument of t
     var r10b = r10.then(sIPromise, sIPromise, sIPromise); // ok
     var r10c = r10.then(nIPromise, nIPromise, nIPromise); // ok
     var r10d = r10.then(testFunction, sIPromise, nIPromise); // ok
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
     var s10 = testFunction10P(x => x);
     var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
@@ -225,17 +241,25 @@ tests/cases/compiler/promisePermutations.ts(158,21): error TS2345: Argument of t
     var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
     var s10d = s10.then(sPromise, sPromise, sPromise); // ok
     var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
-    var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // ok
+    var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
     
     var r11: IPromise<number>;
-    var r11a = r11.then(testFunction11, testFunction11, testFunction11); // ok
+    var r11a = r11.then(testFunction11, testFunction11, testFunction11); // error
+                        ~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '{ (x: number): IPromise<number>; (x: string): IPromise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
     var s11: Promise<number>;
     var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
                         ~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '{ (x: number): IPromise<number>; (x: string): IPromise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
-    var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
-    var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // ok
+    var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error
+                        ~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => Promise<string>'.
+    var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error
+                        ~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
     
     var r12 = testFunction12(x => x);
     var r12a = r12.then(testFunction12, testFunction12, testFunction12); // ok
diff --git a/tests/baselines/reference/promisePermutations.js b/tests/baselines/reference/promisePermutations.js
index 189ef40335e0c..e59e49d6f8c69 100644
--- a/tests/baselines/reference/promisePermutations.js
+++ b/tests/baselines/reference/promisePermutations.js
@@ -12,7 +12,7 @@ interface IPromise<T> {
     then<U>(success?: (value: T) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
     then<U>(success?: (value: T) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>;
     then<U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
-    done?<U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
+    done? <U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
 }
 
 declare function testFunction(): IPromise<number>;
@@ -72,7 +72,7 @@ var s3: Promise<number>;
 var s3a = s3.then(testFunction3, testFunction3, testFunction3);
 var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P);
 var s3c = s3.then(testFunction3P, testFunction3, testFunction3);
-var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3);
+var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3); // error
 
 var r4: IPromise<string>;
 var sIPromise: (x: any) => IPromise<string>;
@@ -83,7 +83,7 @@ var s4: Promise<string>;
 var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error 
 var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
-var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4); 
+var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4);
 
 var r5: IPromise<string>;
 var r5a = r5.then(testFunction5, testFunction5, testFunction5); // error
@@ -135,7 +135,7 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 var s9e = s9.then(nPromise, nPromise, nPromise); // ok
-var s9f = s9.then(testFunction, sIPromise, nIPromise); // ok
+var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 
 var r10 = testFunction10(x => x);
@@ -150,15 +150,15 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
-var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // ok
+var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
 
 var r11: IPromise<number>;
-var r11a = r11.then(testFunction11, testFunction11, testFunction11); // ok
+var r11a = r11.then(testFunction11, testFunction11, testFunction11); // error
 var s11: Promise<number>;
 var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
-var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
-var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // ok
+var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error
+var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error
 
 var r12 = testFunction12(x => x);
 var r12a = r12.then(testFunction12, testFunction12, testFunction12); // ok
@@ -192,7 +192,7 @@ var s3;
 var s3a = s3.then(testFunction3, testFunction3, testFunction3);
 var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P);
 var s3c = s3.then(testFunction3P, testFunction3, testFunction3);
-var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3);
+var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3); // error
 var r4;
 var sIPromise;
 var sPromise;
@@ -249,7 +249,7 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 var s9e = s9.then(nPromise, nPromise, nPromise); // ok
-var s9f = s9.then(testFunction, sIPromise, nIPromise); // ok
+var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var r10 = testFunction10(function (x) { return x; });
 var r10a = r10.then(testFunction10, testFunction10, testFunction10); // ok
@@ -263,14 +263,14 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
-var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // ok
+var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
 var r11;
-var r11a = r11.then(testFunction11, testFunction11, testFunction11); // ok
+var r11a = r11.then(testFunction11, testFunction11, testFunction11); // error
 var s11;
 var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
-var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
-var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // ok
+var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error
+var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error
 var r12 = testFunction12(function (x) { return x; });
 var r12a = r12.then(testFunction12, testFunction12, testFunction12); // ok
 var s12 = testFunction12(function (x) { return x; });
diff --git a/tests/baselines/reference/promisePermutations2.errors.txt b/tests/baselines/reference/promisePermutations2.errors.txt
index f85a3eb925f88..e512ca73277d5 100644
--- a/tests/baselines/reference/promisePermutations2.errors.txt
+++ b/tests/baselines/reference/promisePermutations2.errors.txt
@@ -20,15 +20,20 @@ tests/cases/compiler/promisePermutations2.ts(119,19): error TS2345: Argument of
 tests/cases/compiler/promisePermutations2.ts(120,19): error TS2345: Argument of type '<T>(x: T, cb: (a: T) => T) => Promise<T>' is not assignable to parameter of type '(value: number) => Promise<number>'.
 tests/cases/compiler/promisePermutations2.ts(121,19): error TS2345: Argument of type '<T>(x: T, cb: (a: T) => T) => Promise<T>' is not assignable to parameter of type '(value: number) => IPromise<any>'.
 tests/cases/compiler/promisePermutations2.ts(125,19): error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => IPromise<T>' is not assignable to parameter of type '(value: number) => IPromise<number>'.
+tests/cases/compiler/promisePermutations2.ts(128,11): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/compiler/promisePermutations2.ts(131,19): error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => IPromise<T>' is not assignable to parameter of type '(value: number) => IPromise<number>'.
 tests/cases/compiler/promisePermutations2.ts(132,19): error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => Promise<T>' is not assignable to parameter of type '(value: number) => Promise<number>'.
 tests/cases/compiler/promisePermutations2.ts(133,19): error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => Promise<T>' is not assignable to parameter of type '(value: number) => IPromise<any>'.
+tests/cases/compiler/promisePermutations2.ts(136,11): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/compiler/promisePermutations2.ts(143,12): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/compiler/promisePermutations2.ts(151,12): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/compiler/promisePermutations2.ts(155,21): error TS2345: Argument of type '{ (x: number): IPromise<number>; (x: string): IPromise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 tests/cases/compiler/promisePermutations2.ts(157,21): error TS2345: Argument of type '{ (x: number): IPromise<number>; (x: string): IPromise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 tests/cases/compiler/promisePermutations2.ts(158,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => Promise<string>'.
 tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 
 
-==== tests/cases/compiler/promisePermutations2.ts (28 errors) ====
+==== tests/cases/compiler/promisePermutations2.ts (33 errors) ====
     // same as promisePermutations but without the same overloads in Promise<T>
     
     interface Promise<T> {
@@ -41,7 +46,7 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of
         then<U>(success?: (value: T) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
         then<U>(success?: (value: T) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>;
         then<U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
-        done?<U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
+        done? <U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
     }
     
     declare function testFunction(): IPromise<number>;
@@ -122,7 +127,7 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of
     var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
                       ~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '(x: number, y?: string) => Promise<string>' is not assignable to parameter of type '(value: string) => IPromise<string>'.
-    var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4); 
+    var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4);
     
     var r5: IPromise<string>;
     var r5a = r5.then(testFunction5, testFunction5, testFunction5); // error
@@ -200,7 +205,9 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => IPromise<T>' is not assignable to parameter of type '(value: number) => IPromise<number>'.
     var r9b = r9.then(sIPromise, sIPromise, sIPromise); // ok
     var r9c = r9.then(nIPromise, nIPromise, nIPromise); // ok
-    var r9d = r9.then(testFunction, sIPromise, nIPromise); // ok
+    var r9d = r9.then(testFunction, sIPromise, nIPromise); // error
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
     var s9: Promise<number>;
     var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
@@ -214,14 +221,18 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => Promise<T>' is not assignable to parameter of type '(value: number) => IPromise<any>'.
     var s9d = s9.then(sPromise, sPromise, sPromise); // ok
     var s9e = s9.then(nPromise, nPromise, nPromise); // ok
-    var s9f = s9.then(testFunction, sIPromise, nIPromise); // ok
+    var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
     
     var r10 = testFunction10(x => x);
     var r10a = r10.then(testFunction10, testFunction10, testFunction10); // ok
     var r10b = r10.then(sIPromise, sIPromise, sIPromise); // ok
     var r10c = r10.then(nIPromise, nIPromise, nIPromise); // ok
-    var r10d = r10.then(testFunction, sIPromise, nIPromise); // ok
+    var r10d = r10.then(testFunction, sIPromise, nIPromise); // error
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
     var s10 = testFunction10P(x => x);
     var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
@@ -229,11 +240,15 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of
     var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
     var s10d = s10.then(sPromise, sPromise, sPromise); // ok
     var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
-    var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // ok
+    var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
     
     var r11: IPromise<number>;
-    var r11a = r11.then(testFunction11, testFunction11, testFunction11); // ok
+    var r11a = r11.then(testFunction11, testFunction11, testFunction11); // error
+                        ~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '{ (x: number): IPromise<number>; (x: string): IPromise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
     var s11: Promise<number>;
     var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
                         ~~~~~~~~~~~~~~
diff --git a/tests/baselines/reference/promisePermutations2.js b/tests/baselines/reference/promisePermutations2.js
index 008594ee120db..a7b5d8cf83586 100644
--- a/tests/baselines/reference/promisePermutations2.js
+++ b/tests/baselines/reference/promisePermutations2.js
@@ -11,7 +11,7 @@ interface IPromise<T> {
     then<U>(success?: (value: T) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
     then<U>(success?: (value: T) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>;
     then<U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
-    done?<U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
+    done? <U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
 }
 
 declare function testFunction(): IPromise<number>;
@@ -82,7 +82,7 @@ var s4: Promise<string>;
 var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error 
 var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
-var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4); 
+var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4);
 
 var r5: IPromise<string>;
 var r5a = r5.then(testFunction5, testFunction5, testFunction5); // error
@@ -126,7 +126,7 @@ var r9: IPromise<number>;
 var r9a = r9.then(testFunction9, testFunction9, testFunction9); // error
 var r9b = r9.then(sIPromise, sIPromise, sIPromise); // ok
 var r9c = r9.then(nIPromise, nIPromise, nIPromise); // ok
-var r9d = r9.then(testFunction, sIPromise, nIPromise); // ok
+var r9d = r9.then(testFunction, sIPromise, nIPromise); // error
 var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var s9: Promise<number>;
 var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
@@ -134,14 +134,14 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 var s9e = s9.then(nPromise, nPromise, nPromise); // ok
-var s9f = s9.then(testFunction, sIPromise, nIPromise); // ok
+var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 
 var r10 = testFunction10(x => x);
 var r10a = r10.then(testFunction10, testFunction10, testFunction10); // ok
 var r10b = r10.then(sIPromise, sIPromise, sIPromise); // ok
 var r10c = r10.then(nIPromise, nIPromise, nIPromise); // ok
-var r10d = r10.then(testFunction, sIPromise, nIPromise); // ok
+var r10d = r10.then(testFunction, sIPromise, nIPromise); // error
 var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var s10 = testFunction10P(x => x);
 var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
@@ -149,11 +149,11 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
-var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // ok
+var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
 
 var r11: IPromise<number>;
-var r11a = r11.then(testFunction11, testFunction11, testFunction11); // ok
+var r11a = r11.then(testFunction11, testFunction11, testFunction11); // error
 var s11: Promise<number>;
 var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
 var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
@@ -241,7 +241,7 @@ var r9;
 var r9a = r9.then(testFunction9, testFunction9, testFunction9); // error
 var r9b = r9.then(sIPromise, sIPromise, sIPromise); // ok
 var r9c = r9.then(nIPromise, nIPromise, nIPromise); // ok
-var r9d = r9.then(testFunction, sIPromise, nIPromise); // ok
+var r9d = r9.then(testFunction, sIPromise, nIPromise); // error
 var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var s9;
 var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
@@ -249,13 +249,13 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 var s9e = s9.then(nPromise, nPromise, nPromise); // ok
-var s9f = s9.then(testFunction, sIPromise, nIPromise); // ok
+var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var r10 = testFunction10(function (x) { return x; });
 var r10a = r10.then(testFunction10, testFunction10, testFunction10); // ok
 var r10b = r10.then(sIPromise, sIPromise, sIPromise); // ok
 var r10c = r10.then(nIPromise, nIPromise, nIPromise); // ok
-var r10d = r10.then(testFunction, sIPromise, nIPromise); // ok
+var r10d = r10.then(testFunction, sIPromise, nIPromise); // error
 var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var s10 = testFunction10P(function (x) { return x; });
 var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
@@ -263,10 +263,10 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
-var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // ok
+var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
 var r11;
-var r11a = r11.then(testFunction11, testFunction11, testFunction11); // ok
+var r11a = r11.then(testFunction11, testFunction11, testFunction11); // error
 var s11;
 var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
 var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
diff --git a/tests/baselines/reference/promisePermutations3.errors.txt b/tests/baselines/reference/promisePermutations3.errors.txt
index edd5f879043e7..97d47cc7f7f4b 100644
--- a/tests/baselines/reference/promisePermutations3.errors.txt
+++ b/tests/baselines/reference/promisePermutations3.errors.txt
@@ -1,4 +1,5 @@
 tests/cases/compiler/promisePermutations3.ts(68,69): error TS2345: Argument of type '(x: number) => IPromise<number>' is not assignable to parameter of type '(value: IPromise<number>) => IPromise<number>'.
+tests/cases/compiler/promisePermutations3.ts(73,70): error TS2345: Argument of type '(x: number) => IPromise<number>' is not assignable to parameter of type '(value: IPromise<number>) => IPromise<number>'.
 tests/cases/compiler/promisePermutations3.ts(78,19): error TS2345: Argument of type '(x: number, y?: string) => IPromise<string>' is not assignable to parameter of type '(value: string) => IPromise<string>'.
 tests/cases/compiler/promisePermutations3.ts(81,19): error TS2345: Argument of type '(x: number, y?: string) => IPromise<string>' is not assignable to parameter of type '(value: string) => IPromise<string>'.
 tests/cases/compiler/promisePermutations3.ts(82,19): error TS2345: Argument of type '(x: number, y?: string) => Promise<string>' is not assignable to parameter of type '(value: string) => Promise<string>'.
@@ -20,15 +21,21 @@ tests/cases/compiler/promisePermutations3.ts(119,19): error TS2345: Argument of
 tests/cases/compiler/promisePermutations3.ts(120,19): error TS2345: Argument of type '<T>(x: T, cb: (a: T) => T) => Promise<T>' is not assignable to parameter of type '(value: number) => Promise<number>'.
 tests/cases/compiler/promisePermutations3.ts(121,19): error TS2345: Argument of type '<T>(x: T, cb: (a: T) => T) => Promise<T>' is not assignable to parameter of type '(value: number) => IPromise<any>'.
 tests/cases/compiler/promisePermutations3.ts(125,19): error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => IPromise<T>' is not assignable to parameter of type '(value: number) => IPromise<number>'.
+tests/cases/compiler/promisePermutations3.ts(128,11): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/compiler/promisePermutations3.ts(131,19): error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => IPromise<T>' is not assignable to parameter of type '(value: number) => IPromise<number>'.
 tests/cases/compiler/promisePermutations3.ts(132,19): error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => Promise<T>' is not assignable to parameter of type '(value: number) => Promise<number>'.
 tests/cases/compiler/promisePermutations3.ts(133,19): error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => Promise<T>' is not assignable to parameter of type '(value: number) => IPromise<any>'.
+tests/cases/compiler/promisePermutations3.ts(136,11): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/compiler/promisePermutations3.ts(143,12): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/compiler/promisePermutations3.ts(151,12): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/compiler/promisePermutations3.ts(155,21): error TS2345: Argument of type '{ (x: number): IPromise<number>; (x: string): IPromise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 tests/cases/compiler/promisePermutations3.ts(157,21): error TS2345: Argument of type '{ (x: number): IPromise<number>; (x: string): IPromise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
+tests/cases/compiler/promisePermutations3.ts(158,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => Promise<string>'.
+tests/cases/compiler/promisePermutations3.ts(159,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of type '{ <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }' is not assignable to parameter of type '(value: (x: any) => any) => Promise<any>'.
 
 
-==== tests/cases/compiler/promisePermutations3.ts (28 errors) ====
+==== tests/cases/compiler/promisePermutations3.ts (35 errors) ====
     // same as promisePermutations but without the same overloads in IPromise<T>
     
     interface Promise<T> {
@@ -41,7 +48,7 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
     
     interface IPromise<T> {
         then<U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
-        done?<U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
+        done? <U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
     }
     
     declare function testFunction(): IPromise<number>;
@@ -104,6 +111,8 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
     var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P);
     var s3c = s3.then(testFunction3P, testFunction3, testFunction3);
     var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3);
+                                                                         ~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '(x: number) => IPromise<number>' is not assignable to parameter of type '(value: IPromise<number>) => IPromise<number>'.
     
     var r4: IPromise<string>;
     var sIPromise: (x: any) => IPromise<string>;
@@ -122,7 +131,7 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
     var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
                       ~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '(x: number, y?: string) => Promise<string>' is not assignable to parameter of type '(value: string) => IPromise<string>'.
-    var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4); 
+    var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4);
     
     var r5: IPromise<string>;
     var r5a = r5.then(testFunction5, testFunction5, testFunction5); // error
@@ -200,7 +209,9 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => IPromise<T>' is not assignable to parameter of type '(value: number) => IPromise<number>'.
     var r9b = r9.then(sIPromise, sIPromise, sIPromise); // ok
     var r9c = r9.then(nIPromise, nIPromise, nIPromise); // ok
-    var r9d = r9.then(testFunction, sIPromise, nIPromise); // ok
+    var r9d = r9.then(testFunction, sIPromise, nIPromise); // error
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
     var s9: Promise<number>;
     var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
@@ -214,14 +225,18 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '<T>(x: T, cb: <U>(a: U) => U) => Promise<T>' is not assignable to parameter of type '(value: number) => IPromise<any>'.
     var s9d = s9.then(sPromise, sPromise, sPromise); // ok
     var s9e = s9.then(nPromise, nPromise, nPromise); // ok
-    var s9f = s9.then(testFunction, sIPromise, nIPromise); // ok
+    var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
     
     var r10 = testFunction10(x => x);
     var r10a = r10.then(testFunction10, testFunction10, testFunction10); // ok
     var r10b = r10.then(sIPromise, sIPromise, sIPromise); // ok
     var r10c = r10.then(nIPromise, nIPromise, nIPromise); // ok
-    var r10d = r10.then(testFunction, sIPromise, nIPromise); // ok
+    var r10d = r10.then(testFunction, sIPromise, nIPromise); // error
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
     var s10 = testFunction10P(x => x);
     var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
@@ -229,7 +244,9 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
     var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
     var s10d = s10.then(sPromise, sPromise, sPromise); // ok
     var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
-    var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // ok
+    var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
     
     var r11: IPromise<number>;
@@ -240,8 +257,12 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
     var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
                         ~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type '{ (x: number): IPromise<number>; (x: string): IPromise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
-    var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
-    var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // ok
+    var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error
+                        ~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => Promise<string>'.
+    var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error
+                        ~~~~~~~~~~~~~~~
+!!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
     
     var r12 = testFunction12(x => x);
     var r12a = r12.then(testFunction12, testFunction12, testFunction12); // ok
diff --git a/tests/baselines/reference/promisePermutations3.js b/tests/baselines/reference/promisePermutations3.js
index d65d8c233f8e6..eb9c882b971b9 100644
--- a/tests/baselines/reference/promisePermutations3.js
+++ b/tests/baselines/reference/promisePermutations3.js
@@ -11,7 +11,7 @@ interface Promise<T> {
 
 interface IPromise<T> {
     then<U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
-    done?<U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
+    done? <U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
 }
 
 declare function testFunction(): IPromise<number>;
@@ -82,7 +82,7 @@ var s4: Promise<string>;
 var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error 
 var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
-var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4); 
+var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4);
 
 var r5: IPromise<string>;
 var r5a = r5.then(testFunction5, testFunction5, testFunction5); // error
@@ -126,7 +126,7 @@ var r9: IPromise<number>;
 var r9a = r9.then(testFunction9, testFunction9, testFunction9); // error
 var r9b = r9.then(sIPromise, sIPromise, sIPromise); // ok
 var r9c = r9.then(nIPromise, nIPromise, nIPromise); // ok
-var r9d = r9.then(testFunction, sIPromise, nIPromise); // ok
+var r9d = r9.then(testFunction, sIPromise, nIPromise); // error
 var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var s9: Promise<number>;
 var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
@@ -134,14 +134,14 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 var s9e = s9.then(nPromise, nPromise, nPromise); // ok
-var s9f = s9.then(testFunction, sIPromise, nIPromise); // ok
+var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 
 var r10 = testFunction10(x => x);
 var r10a = r10.then(testFunction10, testFunction10, testFunction10); // ok
 var r10b = r10.then(sIPromise, sIPromise, sIPromise); // ok
 var r10c = r10.then(nIPromise, nIPromise, nIPromise); // ok
-var r10d = r10.then(testFunction, sIPromise, nIPromise); // ok
+var r10d = r10.then(testFunction, sIPromise, nIPromise); // error
 var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var s10 = testFunction10P(x => x);
 var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
@@ -149,15 +149,15 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
-var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // ok
+var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
 
 var r11: IPromise<number>;
 var r11a = r11.then(testFunction11, testFunction11, testFunction11); // ok
 var s11: Promise<number>;
 var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
-var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
-var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // ok
+var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error
+var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error
 
 var r12 = testFunction12(x => x);
 var r12a = r12.then(testFunction12, testFunction12, testFunction12); // ok
@@ -241,7 +241,7 @@ var r9;
 var r9a = r9.then(testFunction9, testFunction9, testFunction9); // error
 var r9b = r9.then(sIPromise, sIPromise, sIPromise); // ok
 var r9c = r9.then(nIPromise, nIPromise, nIPromise); // ok
-var r9d = r9.then(testFunction, sIPromise, nIPromise); // ok
+var r9d = r9.then(testFunction, sIPromise, nIPromise); // error
 var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var s9;
 var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
@@ -249,13 +249,13 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 var s9e = s9.then(nPromise, nPromise, nPromise); // ok
-var s9f = s9.then(testFunction, sIPromise, nIPromise); // ok
+var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var r10 = testFunction10(function (x) { return x; });
 var r10a = r10.then(testFunction10, testFunction10, testFunction10); // ok
 var r10b = r10.then(sIPromise, sIPromise, sIPromise); // ok
 var r10c = r10.then(nIPromise, nIPromise, nIPromise); // ok
-var r10d = r10.then(testFunction, sIPromise, nIPromise); // ok
+var r10d = r10.then(testFunction, sIPromise, nIPromise); // error
 var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var s10 = testFunction10P(function (x) { return x; });
 var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
@@ -263,14 +263,14 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
-var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // ok
+var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
 var r11;
 var r11a = r11.then(testFunction11, testFunction11, testFunction11); // ok
 var s11;
 var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
-var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
-var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // ok
+var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error
+var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error
 var r12 = testFunction12(function (x) { return x; });
 var r12a = r12.then(testFunction12, testFunction12, testFunction12); // ok
 var s12 = testFunction12(function (x) { return x; });
diff --git a/tests/baselines/reference/returnTypeParameterWithModules.types b/tests/baselines/reference/returnTypeParameterWithModules.types
index adcc1b4bcee22..4be0efcd2a5f1 100644
--- a/tests/baselines/reference/returnTypeParameterWithModules.types
+++ b/tests/baselines/reference/returnTypeParameterWithModules.types
@@ -21,7 +21,7 @@ module M1 {
 >reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue?: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
 >apply : (thisArg: any, argArray?: any) => any
 >ar : any
->e ? [f, e] : [f] : any
+>e ? [f, e] : [f] : any[]
 >e : any
 >[f, e] : any[]
 >f : any
diff --git a/tests/baselines/reference/sourceMapValidationClasses.types b/tests/baselines/reference/sourceMapValidationClasses.types
index d53cdcb997461..4f391c86f6542 100644
--- a/tests/baselines/reference/sourceMapValidationClasses.types
+++ b/tests/baselines/reference/sourceMapValidationClasses.types
@@ -56,7 +56,7 @@ module Foo.Bar {
         var greeters: Greeter[] = []; /* inline block comment */
 >greeters : Greeter[]
 >Greeter : Greeter
->[] : Greeter[]
+>[] : undefined[]
 
         greeters[0] = new Greeter(greeting);
 >greeters[0] = new Greeter(greeting) : Greeter
diff --git a/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt b/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt
index a731dcca188bc..b71b04263b14d 100644
--- a/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt
+++ b/tests/baselines/reference/stringIndexerConstrainsPropertyDeclarations.errors.txt
@@ -24,9 +24,10 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerCon
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(71,5): error TS2411: Property 'foo' of type '() => string' is not assignable to string index type 'string'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(73,5): error TS2411: Property '"4.0"' of type 'number' is not assignable to string index type 'string'.
 tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(74,5): error TS2411: Property 'f' of type 'MyString' is not assignable to string index type 'string'.
-tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(78,5): error TS2322: Type '{ [x: string]: {}; 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: MyString; X: string; foo: () => string; }' is not assignable to type '{ [x: string]: string; }':
+tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts(78,5): error TS2322: Type '{ [x: string]: string | number | MyString | { (): void; }; 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: MyString; X: string; foo: () => string; }' is not assignable to type '{ [x: string]: string; }':
   Index signatures are incompatible:
-    Type '{}' is not assignable to type 'string'.
+    Type 'string | number | MyString | { (): void; }' is not assignable to type 'string':
+      Type 'number' is not assignable to type 'string'.
 
 
 ==== tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerConstrainsPropertyDeclarations.ts (27 errors) ====
@@ -159,9 +160,10 @@ tests/cases/conformance/types/objectTypeLiteral/indexSignatures/stringIndexerCon
     // error
     var b: { [x: string]: string; } = {
         ~
-!!! error TS2322: Type '{ [x: string]: {}; 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: MyString; X: string; foo: () => string; }' is not assignable to type '{ [x: string]: string; }':
+!!! error TS2322: Type '{ [x: string]: string | number | MyString | { (): void; }; 1.0: string; 2.0: number; a: string; b: number; c: () => void; "d": string; "e": number; "3.0": string; "4.0": number; f: MyString; X: string; foo: () => string; }' is not assignable to type '{ [x: string]: string; }':
 !!! error TS2322:   Index signatures are incompatible:
-!!! error TS2322:     Type '{}' is not assignable to type 'string'.
+!!! error TS2322:     Type 'string | number | MyString | { (): void; }' is not assignable to type 'string':
+!!! error TS2322:       Type 'number' is not assignable to type 'string'.
         a: '',
         b: 1, 
         c: () => { }, 
diff --git a/tests/baselines/reference/subtypesOfTypeParameter.errors.txt b/tests/baselines/reference/subtypesOfTypeParameter.errors.txt
index a986258bf11bd..bdb3c9a056f50 100644
--- a/tests/baselines/reference/subtypesOfTypeParameter.errors.txt
+++ b/tests/baselines/reference/subtypesOfTypeParameter.errors.txt
@@ -1,46 +1,10 @@
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(7,7): error TS2416: Class 'D1<T, U>' incorrectly extends base class 'C3<T>':
   Types of property 'foo' are incompatible:
     Type 'U' is not assignable to type 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(12,13): error TS2367: No best common type exists between 'T' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(13,13): error TS2367: No best common type exists between 'U' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(38,14): error TS2367: No best common type exists between 'number' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(39,14): error TS2367: No best common type exists between 'T' and 'number'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(41,14): error TS2367: No best common type exists between 'string' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(42,14): error TS2367: No best common type exists between 'T' and 'string'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(44,14): error TS2367: No best common type exists between 'boolean' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(45,14): error TS2367: No best common type exists between 'T' and 'boolean'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(47,14): error TS2367: No best common type exists between 'Date' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(48,14): error TS2367: No best common type exists between 'T' and 'Date'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(50,14): error TS2367: No best common type exists between 'RegExp' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(51,14): error TS2367: No best common type exists between 'T' and 'RegExp'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(53,14): error TS2367: No best common type exists between '{ foo: number; }' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(54,14): error TS2367: No best common type exists between 'T' and '{ foo: number; }'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(56,14): error TS2367: No best common type exists between '() => void' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(57,14): error TS2367: No best common type exists between 'T' and '() => void'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(59,14): error TS2367: No best common type exists between '<T>(x: T) => T' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(60,15): error TS2367: No best common type exists between 'T' and '<T>(x: T) => T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(63,14): error TS2367: No best common type exists between 'I1' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(64,14): error TS2367: No best common type exists between 'T' and 'I1'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(67,15): error TS2367: No best common type exists between 'C1' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(68,15): error TS2367: No best common type exists between 'T' and 'C1'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(72,15): error TS2367: No best common type exists between 'C2<number>' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(73,15): error TS2367: No best common type exists between 'T' and 'C2<number>'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(76,15): error TS2367: No best common type exists between 'typeof E' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(77,15): error TS2367: No best common type exists between 'T' and 'typeof E'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(79,15): error TS2367: No best common type exists between 'E' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(80,15): error TS2367: No best common type exists between 'T' and 'E'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(83,15): error TS2367: No best common type exists between 'typeof f' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(84,15): error TS2367: No best common type exists between 'T' and 'typeof f'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(87,15): error TS2367: No best common type exists between 'typeof c' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(88,15): error TS2367: No best common type exists between 'T' and 'typeof c'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(91,19): error TS2367: No best common type exists between 'T' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(92,19): error TS2367: No best common type exists between 'T' and 'T'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(95,21): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(96,19): error TS2367: No best common type exists between 'T' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts(97,19): error TS2367: No best common type exists between 'U' and 'T'.
 
 
-==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts (38 errors) ====
+==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameter.ts (2 errors) ====
     // checking whether other types are subtypes of type parameters
     
     class C3<T> {
@@ -57,11 +21,7 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
     
     function f1<T, U>(x: T, y: U) {
         var r = true ? x : y; // error
-                ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'U'.
         var r = true ? y : x; // error
-                ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'T'.
     }
     
     interface I1 { foo: number; }
@@ -87,135 +47,67 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
         var r0b = true ? x : u;
     
         var r1 = true ? 1 : x; 
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'number' and 'T'.
         var r1 = true ? x : 1;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'number'.
     
         var r2 = true ? '' : x;
-                 ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'string' and 'T'.
         var r2 = true ? x : '';
-                 ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'string'.
     
         var r3 = true ? true : x;
-                 ~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'boolean' and 'T'.
         var r3 = true ? x : true;
-                 ~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'boolean'.
     
         var r4 = true ? new Date() : x;
-                 ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'Date' and 'T'.
         var r4 = true ? x : new Date();
-                 ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'Date'.
     
         var r5 = true ? /1/ : x;
-                 ~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'RegExp' and 'T'.
         var r5 = true ? x : /1/;
-                 ~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'RegExp'.
     
         var r6 = true ? { foo: 1 } : x;
-                 ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between '{ foo: number; }' and 'T'.
         var r6 = true ? x : { foo: 1 };
-                 ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and '{ foo: number; }'.
     
         var r7 = true ? () => { } : x;
-                 ~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between '() => void' and 'T'.
         var r7 = true ? x : () => { };
-                 ~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and '() => void'.
     
         var r8 = true ? <T>(x: T) => { return x } : x;
-                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between '<T>(x: T) => T' and 'T'.
         var r8b = true ? x : <T>(x: T) => { return x }; // type parameters not identical across declarations
-                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and '<T>(x: T) => T'.
     
         var i1: I1;
         var r9 = true ? i1 : x;
-                 ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'I1' and 'T'.
         var r9 = true ? x : i1;
-                 ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'I1'.
     
         var c1: C1;
         var r10 = true ? c1 : x;
-                  ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'C1' and 'T'.
         var r10 = true ? x : c1;
-                  ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'C1'.
     
     
         var c2: C2<number>;
         var r12 = true ? c2 : x;
-                  ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'C2<number>' and 'T'.
         var r12 = true ? x : c2;
-                  ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'C2<number>'.
     
     
         var r13 = true ? E : x;
-                  ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'typeof E' and 'T'.
         var r13 = true ? x : E;
-                  ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'typeof E'.
     
         var r14 = true ? E.A : x;
-                  ~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'E' and 'T'.
         var r14 = true ? x : E.A;
-                  ~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'E'.
     
         var af: typeof f;
         var r15 = true ? af : x;
-                  ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'typeof f' and 'T'.
         var r15 = true ? x : af;
-                  ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'typeof f'.
     
         var ac: typeof c;
         var r16 = true ? ac : x;
-                  ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'typeof c' and 'T'.
         var r16 = true ? x : ac;
-                  ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'typeof c'.
     
         function f17<T>(a: T) {
             var r17 = true ? x : a;
-                      ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'T'.
             var r17 = true ? a : x;
-                      ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'T'.
         }
     
         function f18<T, U extends T>(a: U) {
                         ~~~~~~~~~~~
 !!! error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
             var r18 = true ? x : a;
-                      ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'U'.
             var r18 = true ? a : x;
-                      ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'T'.
         }
     
         var r19 = true ? new Object() : x; // BCT is Object
diff --git a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.errors.txt b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.errors.txt
index c2b429c08bb9a..1a2ced3b6f2c7 100644
--- a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.errors.txt
+++ b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.errors.txt
@@ -1,46 +1,18 @@
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(3,13): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(4,13): error TS2367: No best common type exists between 'T' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(5,13): error TS2367: No best common type exists between 'U' and 'T'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(9,13): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(9,26): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(10,13): error TS2367: No best common type exists between 'T' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(11,13): error TS2367: No best common type exists between 'U' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(14,14): error TS2367: No best common type exists between 'V' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(15,14): error TS2367: No best common type exists between 'U' and 'V'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(18,14): error TS2367: No best common type exists between 'V' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(19,14): error TS2367: No best common type exists between 'T' and 'V'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(23,13): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(24,13): error TS2367: No best common type exists between 'T' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(25,13): error TS2367: No best common type exists between 'U' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(28,14): error TS2367: No best common type exists between 'T' and 'Date'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(29,14): error TS2367: No best common type exists between 'Date' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(60,14): error TS2367: No best common type exists between 'number' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(61,14): error TS2367: No best common type exists between 'T' and 'number'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(65,14): error TS2367: No best common type exists between 'string' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(66,14): error TS2367: No best common type exists between 'T' and 'string'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(70,14): error TS2367: No best common type exists between 'boolean' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(71,14): error TS2367: No best common type exists between 'T' and 'boolean'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(118,15): error TS2367: No best common type exists between 'typeof E' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(119,15): error TS2367: No best common type exists between 'T' and 'typeof E'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(121,15): error TS2367: No best common type exists between 'E' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(122,15): error TS2367: No best common type exists between 'T' and 'E'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(143,18): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(144,19): error TS2367: No best common type exists between 'T' and 'V'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts(145,19): error TS2367: No best common type exists between 'V' and 'T'.
 
 
-==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts (29 errors) ====
+==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts (5 errors) ====
     // checking whether other types are subtypes of type parameters with constraints
     
     function f1<T extends U, U>(x: T, y: U) {
                 ~~~~~~~~~~~
 !!! error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
         var r = true ? x : y;
-                ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'U'.
         var r = true ? y : x;
-                ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'T'.
     }
     
     // V > U > T
@@ -50,27 +22,15 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
                              ~~~~~~~~~~~
 !!! error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
         var r = true ? x : y;
-                ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'U'.
         var r = true ? y : x;
-                ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'T'.
     
         // ok
         var r2 = true ? z : y;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'V' and 'U'.
         var r2 = true ? y : z;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'V'.
     
         // ok
-        var r2 = true ? z : x;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'V' and 'T'.
-        var r2 = true ? x : z;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'V'.
+        var r2a = true ? z : x;
+        var r2b = true ? x : z;
     }
     
     // Date > U > T
@@ -78,19 +38,11 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
                 ~~~~~~~~~~~
 !!! error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
         var r = true ? x : y;
-                ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'U'.
         var r = true ? y : x;
-                ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'T'.
     
         // ok
         var r2 = true ? x : new Date(); 
-                 ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'Date'.
         var r2 = true ? new Date() : x;
-                 ~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'Date' and 'T'.
     
         // ok
         var r3 = true ? y : new Date(); 
@@ -121,30 +73,18 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
     }
     
     function f5<T extends Number>(x: T) {
-        var r1 = true ? 1 : x; // error
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'number' and 'T'.
-        var r1 = true ? x : 1; // error
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'number'.
+        var r1 = true ? 1 : x; // ok
+        var r1 = true ? x : 1; // ok
     }
     
     function f6<T extends String>(x: T) {
-        var r2 = true ? '' : x; // error
-                 ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'string' and 'T'.
-        var r2 = true ? x : ''; // error
-                 ~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'string'.
+        var r2 = true ? '' : x; // ok
+        var r2 = true ? x : ''; // ok
     }
     
     function f7<T extends Boolean>(x: T) {
-        var r3 = true ? true : x; // error
-                 ~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'boolean' and 'T'.
-        var r3 = true ? x : true; // error
-                 ~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'boolean'.
+        var r3 = true ? true : x; // ok
+        var r3 = true ? x : true; // ok
     }
     
     function f8<T extends Date>(x: T) {
@@ -191,19 +131,11 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
     }
     
     function f16<T extends E>(x: T) {
-        var r13 = true ? E : x; // BUG 831833
-                  ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'typeof E' and 'T'.
-        var r13 = true ? x : E; // BUG 831833
-                  ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'typeof E'.
+        var r13 = true ? E : x; // ok
+        var r13 = true ? x : E; // ok
     
-        var r14 = true ? E.A : x; // BUG 831833
-                  ~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'E' and 'T'.
-        var r14 = true ? x : E.A; // BUG 831833
-                  ~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'E'.
+        var r14 = true ? E.A : x; // ok
+        var r14 = true ? x : E.A; // ok
     }
     
     function f17<T extends typeof f>(x: T) {
@@ -228,11 +160,7 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
                      ~~~~~~~~~~~
 !!! error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
             var r18 = true ? x : a; // ok
-                      ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'V'.
             var r18 = true ? a : x; // ok
-                      ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'V' and 'T'.
         }
     }
     
diff --git a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.js b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.js
index bf582fe13e58d..bd729f36222e1 100644
--- a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.js
+++ b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints2.js
@@ -16,8 +16,8 @@ function f2<T extends U, U extends V, V>(x: T, y: U, z: V) {
     var r2 = true ? y : z;
 
     // ok
-    var r2 = true ? z : x;
-    var r2 = true ? x : z;
+    var r2a = true ? z : x;
+    var r2b = true ? x : z;
 }
 
 // Date > U > T
@@ -58,18 +58,18 @@ function f4<T extends Number>(x: T) {
 }
 
 function f5<T extends Number>(x: T) {
-    var r1 = true ? 1 : x; // error
-    var r1 = true ? x : 1; // error
+    var r1 = true ? 1 : x; // ok
+    var r1 = true ? x : 1; // ok
 }
 
 function f6<T extends String>(x: T) {
-    var r2 = true ? '' : x; // error
-    var r2 = true ? x : ''; // error
+    var r2 = true ? '' : x; // ok
+    var r2 = true ? x : ''; // ok
 }
 
 function f7<T extends Boolean>(x: T) {
-    var r3 = true ? true : x; // error
-    var r3 = true ? x : true; // error
+    var r3 = true ? true : x; // ok
+    var r3 = true ? x : true; // ok
 }
 
 function f8<T extends Date>(x: T) {
@@ -116,11 +116,11 @@ function f15<T extends C2<number>>(x: T) {
 }
 
 function f16<T extends E>(x: T) {
-    var r13 = true ? E : x; // BUG 831833
-    var r13 = true ? x : E; // BUG 831833
+    var r13 = true ? E : x; // ok
+    var r13 = true ? x : E; // ok
 
-    var r14 = true ? E.A : x; // BUG 831833
-    var r14 = true ? x : E.A; // BUG 831833
+    var r14 = true ? E.A : x; // ok
+    var r14 = true ? x : E.A; // ok
 }
 
 function f17<T extends typeof f>(x: T) {
@@ -171,8 +171,8 @@ function f2(x, y, z) {
     var r2 = true ? z : y;
     var r2 = true ? y : z;
     // ok
-    var r2 = true ? z : x;
-    var r2 = true ? x : z;
+    var r2a = true ? z : x;
+    var r2b = true ? x : z;
 }
 // Date > U > T
 function f3(x, y) {
@@ -222,16 +222,16 @@ function f4(x) {
     var r0b = true ? x : u; // ok
 }
 function f5(x) {
-    var r1 = true ? 1 : x; // error
-    var r1 = true ? x : 1; // error
+    var r1 = true ? 1 : x; // ok
+    var r1 = true ? x : 1; // ok
 }
 function f6(x) {
-    var r2 = true ? '' : x; // error
-    var r2 = true ? x : ''; // error
+    var r2 = true ? '' : x; // ok
+    var r2 = true ? x : ''; // ok
 }
 function f7(x) {
-    var r3 = true ? true : x; // error
-    var r3 = true ? x : true; // error
+    var r3 = true ? true : x; // ok
+    var r3 = true ? x : true; // ok
 }
 function f8(x) {
     var r4 = true ? new Date() : x; // ok
@@ -275,10 +275,10 @@ function f15(x) {
     var r12 = true ? x : c2; // ok
 }
 function f16(x) {
-    var r13 = true ? E : x; // BUG 831833
-    var r13 = true ? x : E; // BUG 831833
-    var r14 = true ? 0 /* A */ : x; // BUG 831833
-    var r14 = true ? x : 0 /* A */; // BUG 831833
+    var r13 = true ? E : x; // ok
+    var r13 = true ? x : E; // ok
+    var r14 = true ? 0 /* A */ : x; // ok
+    var r14 = true ? x : 0 /* A */; // ok
 }
 function f17(x) {
     var af;
diff --git a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints3.errors.txt b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints3.errors.txt
index f26389bb2a2f1..2a5fa5ad3628a 100644
--- a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints3.errors.txt
+++ b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints3.errors.txt
@@ -1,13 +1,7 @@
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints3.ts(3,12): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints3.ts(5,13): error TS2367: No best common type exists between 'T' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints3.ts(6,13): error TS2367: No best common type exists between 'U' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints3.ts(9,14): error TS2367: No best common type exists between 'T' and 'V'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints3.ts(10,14): error TS2367: No best common type exists between 'V' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints3.ts(13,14): error TS2367: No best common type exists between 'V' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints3.ts(14,14): error TS2367: No best common type exists between 'U' and 'V'.
 
 
-==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints3.ts (7 errors) ====
+==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints3.ts (1 errors) ====
     // checking whether other types are subtypes of type parameters with constraints
     
     function f<T extends U, U, V>(t: T, u: U, v: V) {
@@ -15,25 +9,13 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
 !!! error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
         // ok
         var r = true ? t : u;
-                ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'U'.
         var r = true ? u : t;
-                ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'T'.
     
-        // error
+        // ok
         var r2 = true ? t : v;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'V'.
         var r2 = true ? v : t;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'V' and 'T'.
     
-        // error
+        // ok
         var r3 = true ? v : u;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'V' and 'U'.
         var r3 = true ? u : v;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'V'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints3.js b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints3.js
index 229beffd33478..790c0fa5b96e4 100644
--- a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints3.js
+++ b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints3.js
@@ -6,11 +6,11 @@ function f<T extends U, U, V>(t: T, u: U, v: V) {
     var r = true ? t : u;
     var r = true ? u : t;
 
-    // error
+    // ok
     var r2 = true ? t : v;
     var r2 = true ? v : t;
 
-    // error
+    // ok
     var r3 = true ? v : u;
     var r3 = true ? u : v;
 }
@@ -21,10 +21,10 @@ function f(t, u, v) {
     // ok
     var r = true ? t : u;
     var r = true ? u : t;
-    // error
+    // ok
     var r2 = true ? t : v;
     var r2 = true ? v : t;
-    // error
+    // ok
     var r3 = true ? v : u;
     var r3 = true ? u : v;
 }
diff --git a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints4.errors.txt b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints4.errors.txt
index 082d78d43d58f..872cb8ef96542 100644
--- a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints4.errors.txt
+++ b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints4.errors.txt
@@ -1,11 +1,3 @@
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts(6,13): error TS2367: No best common type exists between 'T' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts(7,13): error TS2367: No best common type exists between 'U' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts(10,14): error TS2367: No best common type exists between 'T' and 'V'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts(11,14): error TS2367: No best common type exists between 'V' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts(14,14): error TS2367: No best common type exists between 'V' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts(15,14): error TS2367: No best common type exists between 'U' and 'V'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts(26,14): error TS2367: No best common type exists between 'V' and 'Foo'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts(27,14): error TS2367: No best common type exists between 'Foo' and 'V'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts(45,7): error TS2416: Class 'D3<T, U, V>' incorrectly extends base class 'B1<Foo>':
   Types of property 'foo' are incompatible:
     Type 'V' is not assignable to type 'Foo':
@@ -29,34 +21,22 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts(77,5): error TS2411: Property 'foo' of type 'V' is not assignable to string index type 'U'.
 
 
-==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts (18 errors) ====
+==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts (10 errors) ====
     // checking whether other types are subtypes of type parameters with constraints
     
     class Foo { foo: number; }
     function f<T extends Foo, U extends Foo, V>(t: T, u: U, v: V) {
-        // error
+        // ok
         var r = true ? t : u;
-                ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'U'.
         var r = true ? u : t;
-                ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'T'.
     
-        // error
+        // ok
         var r2 = true ? t : v;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'V'.
         var r2 = true ? v : t;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'V' and 'T'.
     
-        // error
+        // ok
         var r3 = true ? v : u;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'V' and 'U'.
         var r3 = true ? u : v;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'V'.
     
         // ok
         var r4 = true ? t : new Foo();
@@ -66,13 +46,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
         var r5 = true ? u : new Foo();
         var r5 = true ? new Foo() : u;
     
-        // BUG, should be error
+        // ok
         var r6 = true ? v : new Foo();
-                 ~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'V' and 'Foo'.
         var r6 = true ? new Foo() : v;
-                 ~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'Foo' and 'V'.
     
     }
     
diff --git a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints4.js b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints4.js
index 96983ecf68fe2..f1cf61d484fe6 100644
--- a/tests/baselines/reference/subtypesOfTypeParameterWithConstraints4.js
+++ b/tests/baselines/reference/subtypesOfTypeParameterWithConstraints4.js
@@ -3,15 +3,15 @@
 
 class Foo { foo: number; }
 function f<T extends Foo, U extends Foo, V>(t: T, u: U, v: V) {
-    // error
+    // ok
     var r = true ? t : u;
     var r = true ? u : t;
 
-    // error
+    // ok
     var r2 = true ? t : v;
     var r2 = true ? v : t;
 
-    // error
+    // ok
     var r3 = true ? v : u;
     var r3 = true ? u : v;
 
@@ -23,7 +23,7 @@ function f<T extends Foo, U extends Foo, V>(t: T, u: U, v: V) {
     var r5 = true ? u : new Foo();
     var r5 = true ? new Foo() : u;
 
-    // BUG, should be error
+    // ok
     var r6 = true ? v : new Foo();
     var r6 = true ? new Foo() : v;
 
@@ -92,13 +92,13 @@ var Foo = (function () {
     return Foo;
 })();
 function f(t, u, v) {
-    // error
+    // ok
     var r = true ? t : u;
     var r = true ? u : t;
-    // error
+    // ok
     var r2 = true ? t : v;
     var r2 = true ? v : t;
-    // error
+    // ok
     var r3 = true ? v : u;
     var r3 = true ? u : v;
     // ok
@@ -107,7 +107,7 @@ function f(t, u, v) {
     // ok
     var r5 = true ? u : new Foo();
     var r5 = true ? new Foo() : u;
-    // BUG, should be error
+    // ok
     var r6 = true ? v : new Foo();
     var r6 = true ? new Foo() : v;
 }
diff --git a/tests/baselines/reference/subtypesOfTypeParameterWithRecursiveConstraints.errors.txt b/tests/baselines/reference/subtypesOfTypeParameterWithRecursiveConstraints.errors.txt
index bf7cbbcae038e..f4b1d7ef04112 100644
--- a/tests/baselines/reference/subtypesOfTypeParameterWithRecursiveConstraints.errors.txt
+++ b/tests/baselines/reference/subtypesOfTypeParameterWithRecursiveConstraints.errors.txt
@@ -1,30 +1,6 @@
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(4,12): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(4,30): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(4,48): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(6,14): error TS2367: No best common type exists between 'T' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(7,14): error TS2367: No best common type exists between 'U' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(10,14): error TS2367: No best common type exists between 'T' and 'V'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(11,14): error TS2367: No best common type exists between 'V' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(14,14): error TS2367: No best common type exists between 'V' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(15,14): error TS2367: No best common type exists between 'U' and 'V'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(18,14): error TS2367: No best common type exists between 'T' and 'Foo<T>'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(19,14): error TS2367: No best common type exists between 'Foo<T>' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(22,14): error TS2367: No best common type exists between 'U' and 'Foo<T>'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(23,14): error TS2367: No best common type exists between 'Foo<T>' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(26,14): error TS2367: No best common type exists between 'V' and 'Foo<T>'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(27,14): error TS2367: No best common type exists between 'Foo<T>' and 'V'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(31,14): error TS2367: No best common type exists between 'T' and 'Foo<U>'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(32,14): error TS2367: No best common type exists between 'Foo<U>' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(35,14): error TS2367: No best common type exists between 'U' and 'Foo<U>'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(36,14): error TS2367: No best common type exists between 'Foo<U>' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(39,14): error TS2367: No best common type exists between 'V' and 'Foo<U>'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(40,14): error TS2367: No best common type exists between 'Foo<U>' and 'V'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(44,15): error TS2367: No best common type exists between 'T' and 'Foo<V>'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(45,15): error TS2367: No best common type exists between 'Foo<V>' and 'T'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(48,15): error TS2367: No best common type exists between 'U' and 'Foo<V>'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(49,15): error TS2367: No best common type exists between 'Foo<V>' and 'U'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(52,15): error TS2367: No best common type exists between 'V' and 'Foo<V>'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(53,15): error TS2367: No best common type exists between 'Foo<V>' and 'V'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(61,14): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(61,32): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(61,50): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
@@ -111,7 +87,7 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts(153,50): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
 
 
-==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts (99 errors) ====
+==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts (75 errors) ====
     // checking whether other types are subtypes of type parameters with constraints
     
     class Foo<T> { foo: T; }
@@ -122,103 +98,55 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOf
 !!! error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
                                                    ~~~~~~~~~~~~~~~~
 !!! error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
-        // error
+        // ok
         var r1 = true ? t : u;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'U'.
         var r1 = true ? u : t;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'T'.
     
-        // error
+        // ok
         var r2 = true ? t : v;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'V'.
         var r2 = true ? v : t;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'V' and 'T'.
     
-        // error
+        // ok
         var r3 = true ? v : u;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'V' and 'U'.
         var r3 = true ? u : v;
-                 ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'V'.
     
-        // ok?
+        // ok
         var r4 = true ? t : new Foo<T>();
-                 ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'Foo<T>'.
         var r4 = true ? new Foo<T>() : t;
-                 ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'Foo<T>' and 'T'.
     
-        // ok?
+        // ok
         var r5 = true ? u : new Foo<T>();
-                 ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'Foo<T>'.
         var r5 = true ? new Foo<T>() : u;
-                 ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'Foo<T>' and 'U'.
     
-        // ok?
+        // ok
         var r6 = true ? v : new Foo<T>();
-                 ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'V' and 'Foo<T>'.
         var r6 = true ? new Foo<T>() : v;
-                 ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'Foo<T>' and 'V'.
     
     
-        // ok?
+        // ok
         var r7 = true ? t : new Foo<U>();
-                 ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'Foo<U>'.
         var r7 = true ? new Foo<U>() : t;
-                 ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'Foo<U>' and 'T'.
     
-        // ok?
+        // ok
         var r8 = true ? u : new Foo<U>();
-                 ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'Foo<U>'.
         var r8 = true ? new Foo<U>() : u;
-                 ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'Foo<U>' and 'U'.
     
-        // ok?
+        // ok
         var r9 = true ? v : new Foo<U>();
-                 ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'V' and 'Foo<U>'.
         var r9 = true ? new Foo<U>() : v;
-                 ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'Foo<U>' and 'V'.
     
     
-        // ok?
+        // ok
         var r10 = true ? t : new Foo<V>();
-                  ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'T' and 'Foo<V>'.
         var r10 = true ? new Foo<V>() : t;
-                  ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'Foo<V>' and 'T'.
     
-        // ok?
+        // ok
         var r11 = true ? u : new Foo<V>();
-                  ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'U' and 'Foo<V>'.
         var r11 = true ? new Foo<V>() : u;
-                  ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'Foo<V>' and 'U'.
     
-        // ok?
+        // ok
         var r12 = true ? v : new Foo<V>();
-                  ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'V' and 'Foo<V>'.
         var r12 = true ? new Foo<V>() : v;
-                  ~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between 'Foo<V>' and 'V'.
     }
     
     module M1 {
diff --git a/tests/baselines/reference/subtypesOfTypeParameterWithRecursiveConstraints.js b/tests/baselines/reference/subtypesOfTypeParameterWithRecursiveConstraints.js
index e345d746bf7d5..1caa7d99087b5 100644
--- a/tests/baselines/reference/subtypesOfTypeParameterWithRecursiveConstraints.js
+++ b/tests/baselines/reference/subtypesOfTypeParameterWithRecursiveConstraints.js
@@ -3,53 +3,53 @@
 
 class Foo<T> { foo: T; }
 function f<T extends Foo<U>, U extends Foo<T>, V extends Foo<V>>(t: T, u: U, v: V) {
-    // error
+    // ok
     var r1 = true ? t : u;
     var r1 = true ? u : t;
 
-    // error
+    // ok
     var r2 = true ? t : v;
     var r2 = true ? v : t;
 
-    // error
+    // ok
     var r3 = true ? v : u;
     var r3 = true ? u : v;
 
-    // ok?
+    // ok
     var r4 = true ? t : new Foo<T>();
     var r4 = true ? new Foo<T>() : t;
 
-    // ok?
+    // ok
     var r5 = true ? u : new Foo<T>();
     var r5 = true ? new Foo<T>() : u;
 
-    // ok?
+    // ok
     var r6 = true ? v : new Foo<T>();
     var r6 = true ? new Foo<T>() : v;
 
 
-    // ok?
+    // ok
     var r7 = true ? t : new Foo<U>();
     var r7 = true ? new Foo<U>() : t;
 
-    // ok?
+    // ok
     var r8 = true ? u : new Foo<U>();
     var r8 = true ? new Foo<U>() : u;
 
-    // ok?
+    // ok
     var r9 = true ? v : new Foo<U>();
     var r9 = true ? new Foo<U>() : v;
 
 
-    // ok?
+    // ok
     var r10 = true ? t : new Foo<V>();
     var r10 = true ? new Foo<V>() : t;
 
-    // ok?
+    // ok
     var r11 = true ? u : new Foo<V>();
     var r11 = true ? new Foo<V>() : u;
 
-    // ok?
+    // ok
     var r12 = true ? v : new Foo<V>();
     var r12 = true ? new Foo<V>() : v;
 }
@@ -171,40 +171,40 @@ var Foo = (function () {
     return Foo;
 })();
 function f(t, u, v) {
-    // error
+    // ok
     var r1 = true ? t : u;
     var r1 = true ? u : t;
-    // error
+    // ok
     var r2 = true ? t : v;
     var r2 = true ? v : t;
-    // error
+    // ok
     var r3 = true ? v : u;
     var r3 = true ? u : v;
-    // ok?
+    // ok
     var r4 = true ? t : new Foo();
     var r4 = true ? new Foo() : t;
-    // ok?
+    // ok
     var r5 = true ? u : new Foo();
     var r5 = true ? new Foo() : u;
-    // ok?
+    // ok
     var r6 = true ? v : new Foo();
     var r6 = true ? new Foo() : v;
-    // ok?
+    // ok
     var r7 = true ? t : new Foo();
     var r7 = true ? new Foo() : t;
-    // ok?
+    // ok
     var r8 = true ? u : new Foo();
     var r8 = true ? new Foo() : u;
-    // ok?
+    // ok
     var r9 = true ? v : new Foo();
     var r9 = true ? new Foo() : v;
-    // ok?
+    // ok
     var r10 = true ? t : new Foo();
     var r10 = true ? new Foo() : t;
-    // ok?
+    // ok
     var r11 = true ? u : new Foo();
     var r11 = true ? new Foo() : u;
-    // ok?
+    // ok
     var r12 = true ? v : new Foo();
     var r12 = true ? new Foo() : v;
 }
diff --git a/tests/baselines/reference/subtypingWithCallSignatures2.types b/tests/baselines/reference/subtypingWithCallSignatures2.types
index 5006e00d52b1e..12344a46f3f55 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures2.types
+++ b/tests/baselines/reference/subtypingWithCallSignatures2.types
@@ -368,8 +368,8 @@ var r2a = [r2arg1, r2arg2];
 >r2arg2 : (x: number) => string[]
 
 var r2b = [r2arg2, r2arg1];
->r2b : { (x: number): string[]; }[]
->[r2arg2, r2arg1] : { (x: number): string[]; }[]
+>r2b : { <T>(x: T): string[]; }[]
+>[r2arg2, r2arg1] : { <T>(x: T): string[]; }[]
 >r2arg2 : (x: number) => string[]
 >r2arg1 : <T>(x: T) => string[]
 
@@ -399,8 +399,8 @@ var r3a = [r3arg1, r3arg2];
 >r3arg2 : (x: number) => void
 
 var r3b = [r3arg2, r3arg1];
->r3b : { (x: number): void; }[]
->[r3arg2, r3arg1] : { (x: number): void; }[]
+>r3b : { <T>(x: T): T; }[]
+>[r3arg2, r3arg1] : { <T>(x: T): T; }[]
 >r3arg2 : (x: number) => void
 >r3arg1 : <T>(x: T) => T
 
@@ -795,8 +795,8 @@ var r12a = [r12arg1, r12arg2];
 >r12arg2 : (x: Base[], y: Derived2[]) => Derived[]
 
 var r12b = [r12arg2, r12arg1];
->r12b : { (x: Base[], y: Derived2[]): Derived[]; }[]
->[r12arg2, r12arg1] : { (x: Base[], y: Derived2[]): Derived[]; }[]
+>r12b : { <T extends Base[]>(x: Base[], y: T): Derived[]; }[]
+>[r12arg2, r12arg1] : { <T extends Base[]>(x: Base[], y: T): Derived[]; }[]
 >r12arg2 : (x: Base[], y: Derived2[]) => Derived[]
 >r12arg1 : <T extends Base[]>(x: Base[], y: T) => Derived[]
 
diff --git a/tests/baselines/reference/subtypingWithCallSignatures3.types b/tests/baselines/reference/subtypingWithCallSignatures3.types
index 8c136113464aa..be5fb44c9c720 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures3.types
+++ b/tests/baselines/reference/subtypingWithCallSignatures3.types
@@ -340,14 +340,14 @@ module Errors {
 >r3arg : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U
 
     var r3a = [r3arg2, r3arg];
->r3a : {}[]
->[r3arg2, r3arg] : {}[]
+>r3a : Array<{ <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U): (r: T) => U; } | { (x: (arg: Base) => Derived, y: (arg2: Base) => Derived): (r: Base) => Derived; }>
+>[r3arg2, r3arg] : Array<{ <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U): (r: T) => U; } | { (x: (arg: Base) => Derived, y: (arg2: Base) => Derived): (r: Base) => Derived; }>
 >r3arg2 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
 >r3arg : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U
 
     var r3b = [r3arg, r3arg2];
->r3b : {}[]
->[r3arg, r3arg2] : {}[]
+>r3b : Array<{ <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U): (r: T) => U; } | { (x: (arg: Base) => Derived, y: (arg2: Base) => Derived): (r: Base) => Derived; }>
+>[r3arg, r3arg2] : Array<{ <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U): (r: T) => U; } | { (x: (arg: Base) => Derived, y: (arg2: Base) => Derived): (r: Base) => Derived; }>
 >r3arg : <T extends Base, U extends Derived>(x: (arg: T) => U, y: (arg2: { foo: number; }) => U) => (r: T) => U
 >r3arg2 : (x: (arg: Base) => Derived, y: (arg2: Base) => Derived) => (r: Base) => Derived
 
@@ -535,8 +535,8 @@ module Errors {
 >r7arg3 : <T extends Base>(x: { a: T; b: T; }) => number
 
     var r7e = [r7arg3, r7arg2];
->r7e : { <T extends Base>(x: { a: T; b: T; }): number; }[]
->[r7arg3, r7arg2] : { <T extends Base>(x: { a: T; b: T; }): number; }[]
+>r7e : { (x: { a: string; b: number; }): number; }[]
+>[r7arg3, r7arg2] : { (x: { a: string; b: number; }): number; }[]
 >r7arg3 : <T extends Base>(x: { a: T; b: T; }) => number
 >r7arg2 : (x: { a: string; b: number; }) => number
 
diff --git a/tests/baselines/reference/subtypingWithCallSignatures4.types b/tests/baselines/reference/subtypingWithCallSignatures4.types
index 07b3af3e540d1..f31a4fa928e49 100644
--- a/tests/baselines/reference/subtypingWithCallSignatures4.types
+++ b/tests/baselines/reference/subtypingWithCallSignatures4.types
@@ -318,8 +318,8 @@ var r3a = [r3arg, r3arg2];
 >r3arg2 : <T>(x: T) => void
 
 var r3b = [r3arg2, r3arg];
->r3b : { <T>(x: T): void; }[]
->[r3arg2, r3arg] : { <T>(x: T): void; }[]
+>r3b : { <T>(x: T): T; }[]
+>[r3arg2, r3arg] : { <T>(x: T): T; }[]
 >r3arg2 : <T>(x: T) => void
 >r3arg : <T>(x: T) => T
 
@@ -442,8 +442,8 @@ var r6a = [r6arg, r6arg2];
 >r6arg2 : <T extends Base>(x: (arg: T) => Derived) => T
 
 var r6b = [r6arg2, r6arg];
->r6b : { <T extends Base>(x: (arg: T) => Derived): T; }[]
->[r6arg2, r6arg] : { <T extends Base>(x: (arg: T) => Derived): T; }[]
+>r6b : { <T extends Base, U extends Derived>(x: (arg: T) => U): T; }[]
+>[r6arg2, r6arg] : { <T extends Base, U extends Derived>(x: (arg: T) => U): T; }[]
 >r6arg2 : <T extends Base>(x: (arg: T) => Derived) => T
 >r6arg : <T extends Base, U extends Derived>(x: (arg: T) => U) => T
 
@@ -491,8 +491,8 @@ var r11a = [r11arg, r11arg2];
 >r11arg2 : <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
 
 var r11b = [r11arg2, r11arg];
->r11b : { <T>(x: { foo: T; }, y: { foo: T; bar: T; }): Base; }[]
->[r11arg2, r11arg] : { <T>(x: { foo: T; }, y: { foo: T; bar: T; }): Base; }[]
+>r11b : { <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }): Base; }[]
+>[r11arg2, r11arg] : { <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }): Base; }[]
 >r11arg2 : <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
 >r11arg : <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 
@@ -534,8 +534,8 @@ var r15a = [r15arg, r15arg2];
 >r15arg2 : <T>(x: { a: T; b: T; }) => T[]
 
 var r15b = [r15arg2, r15arg];
->r15b : { <T>(x: { a: T; b: T; }): T[]; }[]
->[r15arg2, r15arg] : { <T>(x: { a: T; b: T; }): T[]; }[]
+>r15b : { <U, V>(x: { a: U; b: V; }): U[]; }[]
+>[r15arg2, r15arg] : { <U, V>(x: { a: U; b: V; }): U[]; }[]
 >r15arg2 : <T>(x: { a: T; b: T; }) => T[]
 >r15arg : <U, V>(x: { a: U; b: V; }) => U[]
 
diff --git a/tests/baselines/reference/subtypingWithConstructSignatures2.types b/tests/baselines/reference/subtypingWithConstructSignatures2.types
index fdba60147517d..3832697d04c5a 100644
--- a/tests/baselines/reference/subtypingWithConstructSignatures2.types
+++ b/tests/baselines/reference/subtypingWithConstructSignatures2.types
@@ -360,8 +360,8 @@ var r2a = [r2arg1, r2arg2];
 >r2arg2 : new (x: number) => string[]
 
 var r2b = [r2arg2, r2arg1];
->r2b : { new (x: number): string[]; }[]
->[r2arg2, r2arg1] : { new (x: number): string[]; }[]
+>r2b : { new <T>(x: T): string[]; }[]
+>[r2arg2, r2arg1] : { new <T>(x: T): string[]; }[]
 >r2arg2 : new (x: number) => string[]
 >r2arg1 : new <T>(x: T) => string[]
 
@@ -389,8 +389,8 @@ var r3a = [r3arg1, r3arg2];
 >r3arg2 : new (x: number) => void
 
 var r3b = [r3arg2, r3arg1];
->r3b : { new (x: number): void; }[]
->[r3arg2, r3arg1] : { new (x: number): void; }[]
+>r3b : { new <T>(x: T): T; }[]
+>[r3arg2, r3arg1] : { new <T>(x: T): T; }[]
 >r3arg2 : new (x: number) => void
 >r3arg1 : new <T>(x: T) => T
 
@@ -630,14 +630,14 @@ var r9 = foo9(r9arg1); // any
 >r9arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => new (r: T) => U
 
 var r9a = [r9arg1, r9arg2];
->r9a : {}[]
->[r9arg1, r9arg2] : {}[]
+>r9a : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U): new (r: T) => U; } | { new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
+>[r9arg1, r9arg2] : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U): new (r: T) => U; } | { new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
 >r9arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => new (r: T) => U
 >r9arg2 : new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived
 
 var r9b = [r9arg2, r9arg1];
->r9b : {}[]
->[r9arg2, r9arg1] : {}[]
+>r9b : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U): new (r: T) => U; } | { new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
+>[r9arg2, r9arg1] : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U): new (r: T) => U; } | { new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
 >r9arg2 : new (x: new (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived
 >r9arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: string; bing: number; }) => U) => new (r: T) => U
 
@@ -747,8 +747,8 @@ var r12a = [r12arg1, r12arg2];
 >r12arg2 : new (x: Base[], y: Derived2[]) => Derived[]
 
 var r12b = [r12arg2, r12arg1];
->r12b : { new (x: Base[], y: Derived2[]): Derived[]; }[]
->[r12arg2, r12arg1] : { new (x: Base[], y: Derived2[]): Derived[]; }[]
+>r12b : { new <T extends Base[]>(x: Base[], y: T): Derived[]; }[]
+>[r12arg2, r12arg1] : { new <T extends Base[]>(x: Base[], y: T): Derived[]; }[]
 >r12arg2 : new (x: Base[], y: Derived2[]) => Derived[]
 >r12arg1 : new <T extends Base[]>(x: Base[], y: T) => Derived[]
 
diff --git a/tests/baselines/reference/subtypingWithConstructSignatures3.types b/tests/baselines/reference/subtypingWithConstructSignatures3.types
index cf4db8939fd1b..ff6b9adef0ad6 100644
--- a/tests/baselines/reference/subtypingWithConstructSignatures3.types
+++ b/tests/baselines/reference/subtypingWithConstructSignatures3.types
@@ -318,14 +318,14 @@ module Errors {
 >r3arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U) => new (r: T) => U
 
     var r3a = [r3arg2, r3arg1];
->r3a : {}[]
->[r3arg2, r3arg1] : {}[]
+>r3a : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U): new (r: T) => U; } | { new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
+>[r3arg2, r3arg1] : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U): new (r: T) => U; } | { new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
 >r3arg2 : new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived
 >r3arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U) => new (r: T) => U
 
     var r3b = [r3arg1, r3arg2];
->r3b : {}[]
->[r3arg1, r3arg2] : {}[]
+>r3b : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U): new (r: T) => U; } | { new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
+>[r3arg1, r3arg2] : Array<{ new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U): new (r: T) => U; } | { new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived): new (r: Base) => Derived; }>
 >r3arg1 : new <T extends Base, U extends Derived>(x: new (arg: T) => U, y: (arg2: { foo: number; }) => U) => new (r: T) => U
 >r3arg2 : new (x: (arg: Base) => Derived, y: new (arg2: Base) => Derived) => new (r: Base) => Derived
 
@@ -497,8 +497,8 @@ module Errors {
 >r7arg3 : new <T extends Base>(x: { a: T; b: T; }) => number
 
     var r7e = [r7arg3, r7arg2];
->r7e : { new <T extends Base>(x: { a: T; b: T; }): number; }[]
->[r7arg3, r7arg2] : { new <T extends Base>(x: { a: T; b: T; }): number; }[]
+>r7e : { new (x: { a: string; b: number; }): number; }[]
+>[r7arg3, r7arg2] : { new (x: { a: string; b: number; }): number; }[]
 >r7arg3 : new <T extends Base>(x: { a: T; b: T; }) => number
 >r7arg2 : new (x: { a: string; b: number; }) => number
 
diff --git a/tests/baselines/reference/subtypingWithConstructSignatures4.types b/tests/baselines/reference/subtypingWithConstructSignatures4.types
index a9116880df35d..473bbe9a205c2 100644
--- a/tests/baselines/reference/subtypingWithConstructSignatures4.types
+++ b/tests/baselines/reference/subtypingWithConstructSignatures4.types
@@ -307,8 +307,8 @@ var r3a = [r3arg, r3arg2];
 >r3arg2 : new <T>(x: T) => void
 
 var r3b = [r3arg2, r3arg];
->r3b : { new <T>(x: T): void; }[]
->[r3arg2, r3arg] : { new <T>(x: T): void; }[]
+>r3b : { new <T>(x: T): T; }[]
+>[r3arg2, r3arg] : { new <T>(x: T): T; }[]
 >r3arg2 : new <T>(x: T) => void
 >r3arg : new <T>(x: T) => T
 
@@ -421,8 +421,8 @@ var r6a = [r6arg, r6arg2];
 >r6arg2 : new <T extends Base>(x: new (arg: T) => Derived) => T
 
 var r6b = [r6arg2, r6arg];
->r6b : { new <T extends Base>(x: new (arg: T) => Derived): T; }[]
->[r6arg2, r6arg] : { new <T extends Base>(x: new (arg: T) => Derived): T; }[]
+>r6b : { new <T extends Base, U extends Derived>(x: new (arg: T) => U): T; }[]
+>[r6arg2, r6arg] : { new <T extends Base, U extends Derived>(x: new (arg: T) => U): T; }[]
 >r6arg2 : new <T extends Base>(x: new (arg: T) => Derived) => T
 >r6arg : new <T extends Base, U extends Derived>(x: new (arg: T) => U) => T
 
@@ -466,8 +466,8 @@ var r11a = [r11arg, r11arg2];
 >r11arg2 : new <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
 
 var r11b = [r11arg2, r11arg];
->r11b : { new <T>(x: { foo: T; }, y: { foo: T; bar: T; }): Base; }[]
->[r11arg2, r11arg] : { new <T>(x: { foo: T; }, y: { foo: T; bar: T; }): Base; }[]
+>r11b : { new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }): Base; }[]
+>[r11arg2, r11arg] : { new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }): Base; }[]
 >r11arg2 : new <T>(x: { foo: T; }, y: { foo: T; bar: T; }) => Base
 >r11arg : new <T, U>(x: { foo: T; }, y: { foo: U; bar: U; }) => Base
 
@@ -505,8 +505,8 @@ var r15a = [r15arg, r15arg2];
 >r15arg2 : new <T>(x: { a: T; b: T; }) => T[]
 
 var r15b = [r15arg2, r15arg];
->r15b : { new <T>(x: { a: T; b: T; }): T[]; }[]
->[r15arg2, r15arg] : { new <T>(x: { a: T; b: T; }): T[]; }[]
+>r15b : { new <U, V>(x: { a: U; b: V; }): U[]; }[]
+>[r15arg2, r15arg] : { new <U, V>(x: { a: U; b: V; }): U[]; }[]
 >r15arg2 : new <T>(x: { a: T; b: T; }) => T[]
 >r15arg : new <U, V>(x: { a: U; b: V; }) => U[]
 
diff --git a/tests/baselines/reference/subtypingWithObjectMembersOptionality2.errors.txt b/tests/baselines/reference/subtypingWithObjectMembersOptionality2.errors.txt
index 74d47f1256593..ac17303572d6e 100644
--- a/tests/baselines/reference/subtypingWithObjectMembersOptionality2.errors.txt
+++ b/tests/baselines/reference/subtypingWithObjectMembersOptionality2.errors.txt
@@ -4,10 +4,9 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
   Property '1' is optional in type 'S2' but required in type 'T2'.
 tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembersOptionality2.ts(26,11): error TS2429: Interface 'S3' incorrectly extends interface 'T3':
   Property ''1'' is optional in type 'S3' but required in type 'T3'.
-tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembersOptionality2.ts(33,9): error TS2367: No best common type exists between '{ Foo: Base; }' and '{ Foo?: Derived; }'.
 
 
-==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembersOptionality2.ts (4 errors) ====
+==== tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembersOptionality2.ts (3 errors) ====
     // Derived member is optional but base member is not, should be an error
     
     interface Base { foo: string; }
@@ -49,6 +48,4 @@ tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingW
     // object literal case
     var a: { Foo: Base; }
     var b: { Foo?: Derived; }
-    var r = true ? a : b; // error
-            ~~~~~~~~~~~~
-!!! error TS2367: No best common type exists between '{ Foo: Base; }' and '{ Foo?: Derived; }'.
\ No newline at end of file
+    var r = true ? a : b; // ok
\ No newline at end of file
diff --git a/tests/baselines/reference/subtypingWithObjectMembersOptionality2.js b/tests/baselines/reference/subtypingWithObjectMembersOptionality2.js
index 186f3ba454497..33c4cc927daa6 100644
--- a/tests/baselines/reference/subtypingWithObjectMembersOptionality2.js
+++ b/tests/baselines/reference/subtypingWithObjectMembersOptionality2.js
@@ -31,11 +31,11 @@ interface S3 extends T3 {
 // object literal case
 var a: { Foo: Base; }
 var b: { Foo?: Derived; }
-var r = true ? a : b; // error
+var r = true ? a : b; // ok
 
 //// [subtypingWithObjectMembersOptionality2.js]
 // Derived member is optional but base member is not, should be an error
 // object literal case
 var a;
 var b;
-var r = true ? a : b; // error
+var r = true ? a : b; // ok
diff --git a/tests/baselines/reference/targetTypeTest2.types b/tests/baselines/reference/targetTypeTest2.types
index 795dd7036f7ed..f40d68d075ace 100644
--- a/tests/baselines/reference/targetTypeTest2.types
+++ b/tests/baselines/reference/targetTypeTest2.types
@@ -4,7 +4,7 @@
 
 var a : any[] = [1,2,"3"];
 >a : any[]
->[1,2,"3"] : any[]
+>[1,2,"3"] : Array<string | number>
 
 
 function func1(stuff:any[]) { return stuff; }
@@ -21,7 +21,7 @@ function func2(stuff1:string, stuff2:number, stuff3:number) {
 	return func1([stuff1, stuff2, stuff3]);
 >func1([stuff1, stuff2, stuff3]) : any[]
 >func1 : (stuff: any[]) => any[]
->[stuff1, stuff2, stuff3] : any[]
+>[stuff1, stuff2, stuff3] : Array<string | number>
 >stuff1 : string
 >stuff2 : number
 >stuff3 : number
diff --git a/tests/baselines/reference/targetTypeTest3.errors.txt b/tests/baselines/reference/targetTypeTest3.errors.txt
index e81cba71a4791..d9dbec4115072 100644
--- a/tests/baselines/reference/targetTypeTest3.errors.txt
+++ b/tests/baselines/reference/targetTypeTest3.errors.txt
@@ -1,5 +1,6 @@
-tests/cases/compiler/targetTypeTest3.ts(4,5): error TS2322: Type '{}[]' is not assignable to type 'string[]':
-  Type '{}' is not assignable to type 'string'.
+tests/cases/compiler/targetTypeTest3.ts(4,5): error TS2322: Type 'Array<string | 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/compiler/targetTypeTest3.ts (1 errors) ====
@@ -8,8 +9,9 @@ tests/cases/compiler/targetTypeTest3.ts(4,5): error TS2322: Type '{}[]' is not a
     
     var a : string[] = [1,2,"3"]; // should produce an error
         ~
-!!! error TS2322: Type '{}[]' is not assignable to type 'string[]':
-!!! error TS2322:   Type '{}' is not assignable to type 'string'.
+!!! error TS2322: Type 'Array<string | number>' is not assignable to type 'string[]':
+!!! error TS2322:   Type 'string | number' is not assignable to type 'string':
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.
     
     
     function func1(stuff:any[]) { return stuff; }
diff --git a/tests/baselines/reference/thisInPropertyBoundDeclarations.types b/tests/baselines/reference/thisInPropertyBoundDeclarations.types
index 1ccebef5eaa2c..899aa41a684da 100644
--- a/tests/baselines/reference/thisInPropertyBoundDeclarations.types
+++ b/tests/baselines/reference/thisInPropertyBoundDeclarations.types
@@ -8,7 +8,7 @@ class Bug {
     private static func: Function[] = [
 >func : Function[]
 >Function : Function
->[     (that: Bug, name: string) => {         that.foo(name);     }    ] : Function[]
+>[     (that: Bug, name: string) => {         that.foo(name);     }    ] : { (that: Bug, name: string): void; }[]
 
      (that: Bug, name: string) => {
 >(that: Bug, name: string) => {         that.foo(name);     } : (that: Bug, name: string) => void
diff --git a/tests/baselines/reference/throwStatements.types b/tests/baselines/reference/throwStatements.types
index efc2ff2412402..7f106daced962 100644
--- a/tests/baselines/reference/throwStatements.types
+++ b/tests/baselines/reference/throwStatements.types
@@ -219,7 +219,7 @@ throw [];
 >[] : undefined[]
 
 throw ['a', ['b']];
->['a', ['b']] : {}[]
+>['a', ['b']] : Array<string | string[]>
 >['b'] : string[]
 
 throw /[a-z]/;
diff --git a/tests/baselines/reference/trailingCommaInHeterogenousArrayLiteral1.errors.txt b/tests/baselines/reference/trailingCommaInHeterogenousArrayLiteral1.errors.txt
index e1681f5cc2959..823bf93e53505 100644
--- a/tests/baselines/reference/trailingCommaInHeterogenousArrayLiteral1.errors.txt
+++ b/tests/baselines/reference/trailingCommaInHeterogenousArrayLiteral1.errors.txt
@@ -1,7 +1,9 @@
-tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts(5,19): error TS2345: Argument of type '{}[]' is not assignable to parameter of type 'number[]'.
-  Type '{}' is not assignable to type 'number'.
-tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts(6,19): error TS2345: Argument of type '{}[]' is not assignable to parameter of type 'number[]'.
-  Type '{}' is not assignable to type 'number'.
+tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts(5,19): error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+  Type 'string | number' is not assignable to type 'number':
+    Type 'string' is not assignable to type 'number'.
+tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts(6,19): error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+  Type 'string | number' is not assignable to type 'number':
+    Type 'string' is not assignable to type 'number'.
 
 
 ==== tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts (2 errors) ====
@@ -11,12 +13,14 @@ tests/cases/compiler/trailingCommaInHeterogenousArrayLiteral1.ts(6,19): error TS
             // these two should give the same error
             this.test([1, 2, "hi", 5, ]);
                       ~~~~~~~~~~~~~~~~~
-!!! error TS2345: Argument of type '{}[]' is not assignable to parameter of type 'number[]'.
-!!! error TS2345:   Type '{}' is not assignable to type 'number'.
+!!! error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+!!! error TS2345:   Type 'string | number' is not assignable to type 'number':
+!!! error TS2345:     Type 'string' is not assignable to type 'number'.
             this.test([1, 2, "hi", 5]); 
                       ~~~~~~~~~~~~~~~
-!!! error TS2345: Argument of type '{}[]' is not assignable to parameter of type 'number[]'.
-!!! error TS2345:   Type '{}' is not assignable to type 'number'.
+!!! error TS2345: Argument of type 'Array<string | number>' is not assignable to parameter of type 'number[]'.
+!!! error TS2345:   Type 'string | number' is not assignable to type 'number':
+!!! error TS2345:     Type 'string' is not assignable to type 'number'.
         }
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/tupleTypes.errors.txt b/tests/baselines/reference/tupleTypes.errors.txt
index fcc65ff5c2376..8bf6cca485517 100644
--- a/tests/baselines/reference/tupleTypes.errors.txt
+++ b/tests/baselines/reference/tupleTypes.errors.txt
@@ -1,16 +1,17 @@
 tests/cases/compiler/tupleTypes.ts(1,9): error TS1122: A tuple type element list cannot be empty.
-tests/cases/compiler/tupleTypes.ts(14,1): error TS2322: Type '{}[]' is not assignable to type '[number, string]':
-  Property '0' is missing in type '{}[]'.
+tests/cases/compiler/tupleTypes.ts(14,1): error TS2322: Type 'undefined[]' is not assignable to type '[number, string]':
+  Property '0' is missing in type 'undefined[]'.
 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'.
-tests/cases/compiler/tupleTypes.ts(41,1): error TS2323: Type '{}[]' is not assignable to type '[number, string]'.
+tests/cases/compiler/tupleTypes.ts(41,1): error TS2323: 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:
-    Type '() => {}' is not assignable to type '() => number':
-      Type '{}' is not assignable to type 'number'.
+    Type '() => string | number' is not assignable to type '() => number':
+      Type 'string | number' is not assignable to type 'number':
+        Type 'string' is not assignable to type 'number'.
 tests/cases/compiler/tupleTypes.ts(49,1): error TS2322: Type '[number, {}]' is not assignable to type 'number[]':
   Types of property 'pop' are incompatible:
     Type '() => {}' is not assignable to type '() => number':
@@ -36,13 +37,13 @@ tests/cases/compiler/tupleTypes.ts(51,1): error TS2322: Type '[number, {}]' is n
     var t0: number;
     var t1 = t[1];   // string
     var t1: string;
-    var t2 = t[2];   // {}
-    var t2: {};
+    var t2 = t[2];   // number|string
+    var t2: number|string;
     
     t = [];               // Error
     ~
-!!! error TS2322: Type '{}[]' is not assignable to type '[number, string]':
-!!! error TS2322:   Property '0' is missing in type '{}[]'.
+!!! error TS2322: Type 'undefined[]' is not assignable to type '[number, string]':
+!!! error TS2322:   Property '0' is missing in type 'undefined[]'.
     t = [1];              // Error
     ~
 !!! error TS2322: Type '[number]' is not assignable to type '[number, string]':
@@ -70,15 +71,15 @@ tests/cases/compiler/tupleTypes.ts(51,1): error TS2322: Type '[number, {}]' is n
     var tt0: number;
     var tt1 = tt[1];
     var tt1: string;
-    var tt2 = tt[2];
-    var tt2: {};
+    var tt2 = tt[2]; 
+    var tt2: number | string;
     
     tt = tuple2(1, undefined);
     tt = [1, undefined];
     tt = [undefined, undefined];
     tt = [];  // Error
     ~~
-!!! error TS2323: Type '{}[]' is not assignable to type '[number, string]'.
+!!! error TS2323: Type 'undefined[]' is not assignable to type '[number, string]'.
     
     var a: number[];
     var a1: [number, string];
@@ -88,8 +89,9 @@ tests/cases/compiler/tupleTypes.ts(51,1): error TS2322: Type '[number, {}]' is n
     ~
 !!! error TS2322: Type '[number, string]' is not assignable to type 'number[]':
 !!! error TS2322:   Types of property 'pop' are incompatible:
-!!! error TS2322:     Type '() => {}' is not assignable to type '() => number':
-!!! error TS2322:       Type '{}' is not assignable to type 'number'.
+!!! error TS2322:     Type '() => string | number' is not assignable to type '() => number':
+!!! error TS2322:       Type 'string | number' is not assignable to type 'number':
+!!! error TS2322:         Type 'string' is not assignable to type 'number'.
     a = a2;
     a = a3;   // Error
     ~
diff --git a/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.types b/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.types
index 584ae0dcb3cfa..1cee9140a012f 100644
--- a/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.types
+++ b/tests/baselines/reference/typeAnnotationBestCommonTypeInArrayLiteral.types
@@ -23,7 +23,7 @@ interface IMenuItem {
 var menuData: IMenuItem[] = [
 >menuData : IMenuItem[]
 >IMenuItem : IMenuItem
->[    {        "id": "ourLogo",        "type": "image",        "link": "",        "icon": "modules/menu/logo.svg"    }, {        "id": "productName",        "type": "default",        "link": "",        "text": "Product Name"    }] : IMenuItem[]
+>[    {        "id": "ourLogo",        "type": "image",        "link": "",        "icon": "modules/menu/logo.svg"    }, {        "id": "productName",        "type": "default",        "link": "",        "text": "Product Name"    }] : Array<{ "id": string; "type": string; "link": string; "icon": string; } | { "id": string; "type": string; "link": string; "text": string; }>
     {
 >{        "id": "ourLogo",        "type": "image",        "link": "",        "icon": "modules/menu/logo.svg"    } : { "id": string; "type": string; "link": string; "icon": string; }
 
diff --git a/tests/baselines/reference/typeArgInference2.errors.txt b/tests/baselines/reference/typeArgInference2.errors.txt
new file mode 100644
index 0000000000000..cf188972b7d79
--- /dev/null
+++ b/tests/baselines/reference/typeArgInference2.errors.txt
@@ -0,0 +1,18 @@
+tests/cases/compiler/typeArgInference2.ts(12,10): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/compiler/typeArgInference2.ts (1 errors) ====
+    interface Item {
+        name: string;
+    }
+    
+    declare function foo<T extends Item>(x?: T, y?: T): T;
+    
+    var z1 = foo(null);                   // any
+    var z2 = foo();                       // Item
+    var z3 = foo({ name: null });         // { name: any }
+    var z4 = foo({ name: "abc" });        // { name: string }
+    var z5 = foo({ name: "abc", a: 5 });  // { name: string; a: number }
+    var z6 = foo({ name: "abc", a: 5 }, { name: "def", b: 5 });  // error
+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
\ No newline at end of file
diff --git a/tests/baselines/reference/typeArgInference2.js b/tests/baselines/reference/typeArgInference2.js
index ef76c9b33e771..193345cdeb3ea 100644
--- a/tests/baselines/reference/typeArgInference2.js
+++ b/tests/baselines/reference/typeArgInference2.js
@@ -10,7 +10,7 @@ var z2 = foo();                       // Item
 var z3 = foo({ name: null });         // { name: any }
 var z4 = foo({ name: "abc" });        // { name: string }
 var z5 = foo({ name: "abc", a: 5 });  // { name: string; a: number }
-var z6 = foo({ name: "abc", a: 5 }, { name: "def", b: 5 });  // Item
+var z6 = foo({ name: "abc", a: 5 }, { name: "def", b: 5 });  // error
 
 //// [typeArgInference2.js]
 var z1 = foo(null); // any
@@ -18,4 +18,4 @@ var z2 = foo(); // Item
 var z3 = foo({ name: null }); // { name: any }
 var z4 = foo({ name: "abc" }); // { name: string }
 var z5 = foo({ name: "abc", a: 5 }); // { name: string; a: number }
-var z6 = foo({ name: "abc", a: 5 }, { name: "def", b: 5 }); // Item
+var z6 = foo({ name: "abc", a: 5 }, { name: "def", b: 5 }); // error
diff --git a/tests/baselines/reference/typeArgInference2.types b/tests/baselines/reference/typeArgInference2.types
deleted file mode 100644
index 1b94a0638bd97..0000000000000
--- a/tests/baselines/reference/typeArgInference2.types
+++ /dev/null
@@ -1,61 +0,0 @@
-=== tests/cases/compiler/typeArgInference2.ts ===
-interface Item {
->Item : Item
-
-    name: string;
->name : string
-}
-
-declare function foo<T extends Item>(x?: T, y?: T): T;
->foo : <T extends Item>(x?: T, y?: T) => T
->T : T
->Item : Item
->x : T
->T : T
->y : T
->T : T
->T : T
-
-var z1 = foo(null);                   // any
->z1 : any
->foo(null) : any
->foo : <T extends Item>(x?: T, y?: T) => T
-
-var z2 = foo();                       // Item
->z2 : Item
->foo() : Item
->foo : <T extends Item>(x?: T, y?: T) => T
-
-var z3 = foo({ name: null });         // { name: any }
->z3 : { name: any; }
->foo({ name: null }) : { name: any; }
->foo : <T extends Item>(x?: T, y?: T) => T
->{ name: null } : { name: null; }
->name : null
-
-var z4 = foo({ name: "abc" });        // { name: string }
->z4 : { name: string; }
->foo({ name: "abc" }) : { name: string; }
->foo : <T extends Item>(x?: T, y?: T) => T
->{ name: "abc" } : { name: string; }
->name : string
-
-var z5 = foo({ name: "abc", a: 5 });  // { name: string; a: number }
->z5 : { name: string; a: number; }
->foo({ name: "abc", a: 5 }) : { name: string; a: number; }
->foo : <T extends Item>(x?: T, y?: T) => T
->{ name: "abc", a: 5 } : { name: string; a: number; }
->name : string
->a : number
-
-var z6 = foo({ name: "abc", a: 5 }, { name: "def", b: 5 });  // Item
->z6 : Item
->foo({ name: "abc", a: 5 }, { name: "def", b: 5 }) : Item
->foo : <T extends Item>(x?: T, y?: T) => T
->{ name: "abc", a: 5 } : { name: string; a: number; }
->name : string
->a : number
->{ name: "def", b: 5 } : { name: string; b: number; }
->name : string
->b : number
-
diff --git a/tests/baselines/reference/typeArgInference2WithError.errors.txt b/tests/baselines/reference/typeArgInference2WithError.errors.txt
index 26259abf37b51..83fa81b552426 100644
--- a/tests/baselines/reference/typeArgInference2WithError.errors.txt
+++ b/tests/baselines/reference/typeArgInference2WithError.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/compiler/typeArgInference2WithError.ts(7,14): error TS2345: Argument of type 'string' is not assignable to parameter of type 'Item'.
+tests/cases/compiler/typeArgInference2WithError.ts(7,10): error TS2346: Supplied parameters do not match any signature of call target.
 
 
 ==== tests/cases/compiler/typeArgInference2WithError.ts (1 errors) ====
@@ -9,5 +9,5 @@ tests/cases/compiler/typeArgInference2WithError.ts(7,14): error TS2345: Argument
     declare function foo<T extends Item>(x?: T, y?: T): T;
     
     var z7 = foo("abc", 5); // Error
-                 ~~~~~
-!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'Item'.
\ No newline at end of file
+             ~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
\ No newline at end of file
diff --git a/tests/baselines/reference/typeArgumentInference.errors.txt b/tests/baselines/reference/typeArgumentInference.errors.txt
new file mode 100644
index 0000000000000..dbff8b8385446
--- /dev/null
+++ b/tests/baselines/reference/typeArgumentInference.errors.txt
@@ -0,0 +1,109 @@
+tests/cases/conformance/expressions/functionCalls/typeArgumentInference.ts(68,11): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInference.ts(82,11): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/conformance/expressions/functionCalls/typeArgumentInference.ts (2 errors) ====
+    // Generic call with no parameters
+    function noParams<T>() { }
+    noParams();
+    noParams<string>();
+    noParams<{}>();
+    
+    // Generic call with parameters but none use type parameter type
+    function noGenericParams<T>(n: string) { }
+    noGenericParams('');
+    noGenericParams<number>('');
+    noGenericParams<{}>('');
+    
+    // Generic call with multiple type parameters and only one used in parameter type annotation
+    function someGenerics1<T, U>(n: T, m: number) { }
+    someGenerics1(3, 4);
+    someGenerics1<number, {}>(3, 4);
+    
+    // Generic call with argument of function type whose parameter is of type parameter type
+    function someGenerics2a<T>(n: (x: T) => void) { }
+    someGenerics2a((n: string) => n);
+    someGenerics2a<string>((n: string) => n);
+    someGenerics2a<string>((n) => n.substr(0));
+    
+    function someGenerics2b<T, U>(n: (x: T, y: U) => void) { }
+    someGenerics2b((n: string, x: number) => n);
+    someGenerics2b<string, number>((n: string, t: number) => n);
+    someGenerics2b<string, number>((n, t) => n.substr(t * t));
+    
+    // Generic call with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter
+    function someGenerics3<T>(producer: () => T) { }
+    someGenerics3(() => '');
+    someGenerics3<Date>(() => undefined);
+    someGenerics3<number>(() => 3);
+    
+    // 2 parameter generic call with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type
+    function someGenerics4<T, U>(n: T, f: (x: U) => void) { }
+    someGenerics4(4, () => null);
+    someGenerics4<string, number>('', () => 3);
+    someGenerics4<string, number>(null, null);
+    
+    // 2 parameter generic call with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type
+    function someGenerics5<U, T>(n: T, f: (x: U) => void) { }
+    someGenerics5(4, () => null);
+    someGenerics5<number, string>('', () => 3);
+    someGenerics5<string, number>(null, null);
+    
+    // Generic call with multiple arguments of function types that each have parameters of the same generic type
+    function someGenerics6<A>(a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { }
+    someGenerics6(n => n, n => n, n => n);
+    someGenerics6<number>(n => n, n => n, n => n);
+    someGenerics6<number>((n: number) => n, (n: number) => n, (n: number) => n);
+    
+    // Generic call with multiple arguments of function types that each have parameters of different generic type
+    function someGenerics7<A, B, C>(a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { }
+    someGenerics7(n => n, n => n, n => n);
+    someGenerics7<number, string, number>(n => n, n => n, n => n);
+    someGenerics7<number, string, number>((n: number) => n, (n: string) => n, (n: number) => n);
+    
+    // Generic call with argument of generic function type
+    function someGenerics8<T>(n: T): T { return n; }
+    var x = someGenerics8(someGenerics7);
+    x<string, string, string>(null, null, null);
+    
+    // Generic call with multiple parameters of generic type passed arguments with no best common type
+    function someGenerics9<T>(a: T, b: T, c: T): T {
+        return null;
+    }
+    var a9a = someGenerics9('', 0, []);
+              ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    var a9a: {};
+    var a9b = someGenerics9<{ a?: number; b?: string; }>({ a: 0 }, { b: '' }, null);
+    var a9b: { a?: number; b?: string; };
+    
+    // Generic call with multiple parameters of generic type passed arguments with multiple best common types
+    interface A91 {
+        x: number;
+        y?: string;
+    }
+    interface A92 {
+        x: number;
+        z?: Date;
+    }
+    var a9e = someGenerics9(undefined, { x: 6, z: new Date() }, { x: 6, y: '' });
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    var a9e: {};
+    var a9f = someGenerics9<A92>(undefined, { x: 6, z: new Date() }, { x: 6, y: '' });
+    var a9f: A92;
+    
+    // Generic call with multiple parameters of generic type passed arguments with a single best common type
+    var a9d = someGenerics9({ x: 3 }, { x: 6 }, { x: 6 });
+    var a9d: { x: number; };
+    
+    // Generic call with multiple parameters of generic type where one argument is of type 'any'
+    var anyVar: any;
+    var a = someGenerics9(7, anyVar, 4);
+    var a: any;
+    
+    // Generic call with multiple parameters of generic type where one argument is [] and the other is not 'any'
+    var arr = someGenerics9([], null, undefined);
+    var arr: any[];
+    
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/typeArgumentInference.types b/tests/baselines/reference/typeArgumentInference.types
deleted file mode 100644
index 40136bd10c3f6..0000000000000
--- a/tests/baselines/reference/typeArgumentInference.types
+++ /dev/null
@@ -1,468 +0,0 @@
-=== tests/cases/conformance/expressions/functionCalls/typeArgumentInference.ts ===
-// Generic call with no parameters
-function noParams<T>() { }
->noParams : <T>() => void
->T : T
-
-noParams();
->noParams() : void
->noParams : <T>() => void
-
-noParams<string>();
->noParams<string>() : void
->noParams : <T>() => void
-
-noParams<{}>();
->noParams<{}>() : void
->noParams : <T>() => void
-
-// Generic call with parameters but none use type parameter type
-function noGenericParams<T>(n: string) { }
->noGenericParams : <T>(n: string) => void
->T : T
->n : string
-
-noGenericParams('');
->noGenericParams('') : void
->noGenericParams : <T>(n: string) => void
-
-noGenericParams<number>('');
->noGenericParams<number>('') : void
->noGenericParams : <T>(n: string) => void
-
-noGenericParams<{}>('');
->noGenericParams<{}>('') : void
->noGenericParams : <T>(n: string) => void
-
-// Generic call with multiple type parameters and only one used in parameter type annotation
-function someGenerics1<T, U>(n: T, m: number) { }
->someGenerics1 : <T, U>(n: T, m: number) => void
->T : T
->U : U
->n : T
->T : T
->m : number
-
-someGenerics1(3, 4);
->someGenerics1(3, 4) : void
->someGenerics1 : <T, U>(n: T, m: number) => void
-
-someGenerics1<number, {}>(3, 4);
->someGenerics1<number, {}>(3, 4) : void
->someGenerics1 : <T, U>(n: T, m: number) => void
-
-// Generic call with argument of function type whose parameter is of type parameter type
-function someGenerics2a<T>(n: (x: T) => void) { }
->someGenerics2a : <T>(n: (x: T) => void) => void
->T : T
->n : (x: T) => void
->x : T
->T : T
-
-someGenerics2a((n: string) => n);
->someGenerics2a((n: string) => n) : void
->someGenerics2a : <T>(n: (x: T) => void) => void
->(n: string) => n : (n: string) => string
->n : string
->n : string
-
-someGenerics2a<string>((n: string) => n);
->someGenerics2a<string>((n: string) => n) : void
->someGenerics2a : <T>(n: (x: T) => void) => void
->(n: string) => n : (n: string) => string
->n : string
->n : string
-
-someGenerics2a<string>((n) => n.substr(0));
->someGenerics2a<string>((n) => n.substr(0)) : void
->someGenerics2a : <T>(n: (x: T) => void) => void
->(n) => n.substr(0) : (n: string) => string
->n : string
->n.substr(0) : string
->n.substr : (from: number, length?: number) => string
->n : string
->substr : (from: number, length?: number) => string
-
-function someGenerics2b<T, U>(n: (x: T, y: U) => void) { }
->someGenerics2b : <T, U>(n: (x: T, y: U) => void) => void
->T : T
->U : U
->n : (x: T, y: U) => void
->x : T
->T : T
->y : U
->U : U
-
-someGenerics2b((n: string, x: number) => n);
->someGenerics2b((n: string, x: number) => n) : void
->someGenerics2b : <T, U>(n: (x: T, y: U) => void) => void
->(n: string, x: number) => n : (n: string, x: number) => string
->n : string
->x : number
->n : string
-
-someGenerics2b<string, number>((n: string, t: number) => n);
->someGenerics2b<string, number>((n: string, t: number) => n) : void
->someGenerics2b : <T, U>(n: (x: T, y: U) => void) => void
->(n: string, t: number) => n : (n: string, t: number) => string
->n : string
->t : number
->n : string
-
-someGenerics2b<string, number>((n, t) => n.substr(t * t));
->someGenerics2b<string, number>((n, t) => n.substr(t * t)) : void
->someGenerics2b : <T, U>(n: (x: T, y: U) => void) => void
->(n, t) => n.substr(t * t) : (n: string, t: number) => string
->n : string
->t : number
->n.substr(t * t) : string
->n.substr : (from: number, length?: number) => string
->n : string
->substr : (from: number, length?: number) => string
->t * t : number
->t : number
->t : number
-
-// Generic call with argument of function type whose parameter is not of type parameter type but body/return type uses type parameter
-function someGenerics3<T>(producer: () => T) { }
->someGenerics3 : <T>(producer: () => T) => void
->T : T
->producer : () => T
->T : T
-
-someGenerics3(() => '');
->someGenerics3(() => '') : void
->someGenerics3 : <T>(producer: () => T) => void
->() => '' : () => string
-
-someGenerics3<Date>(() => undefined);
->someGenerics3<Date>(() => undefined) : void
->someGenerics3 : <T>(producer: () => T) => void
->Date : Date
->() => undefined : () => any
->undefined : undefined
-
-someGenerics3<number>(() => 3);
->someGenerics3<number>(() => 3) : void
->someGenerics3 : <T>(producer: () => T) => void
->() => 3 : () => number
-
-// 2 parameter generic call with argument 1 of type parameter type and argument 2 of function type whose parameter is of type parameter type
-function someGenerics4<T, U>(n: T, f: (x: U) => void) { }
->someGenerics4 : <T, U>(n: T, f: (x: U) => void) => void
->T : T
->U : U
->n : T
->T : T
->f : (x: U) => void
->x : U
->U : U
-
-someGenerics4(4, () => null);
->someGenerics4(4, () => null) : void
->someGenerics4 : <T, U>(n: T, f: (x: U) => void) => void
->() => null : () => any
-
-someGenerics4<string, number>('', () => 3);
->someGenerics4<string, number>('', () => 3) : void
->someGenerics4 : <T, U>(n: T, f: (x: U) => void) => void
->() => 3 : () => number
-
-someGenerics4<string, number>(null, null);
->someGenerics4<string, number>(null, null) : void
->someGenerics4 : <T, U>(n: T, f: (x: U) => void) => void
-
-// 2 parameter generic call with argument 2 of type parameter type and argument 1 of function type whose parameter is of type parameter type
-function someGenerics5<U, T>(n: T, f: (x: U) => void) { }
->someGenerics5 : <U, T>(n: T, f: (x: U) => void) => void
->U : U
->T : T
->n : T
->T : T
->f : (x: U) => void
->x : U
->U : U
-
-someGenerics5(4, () => null);
->someGenerics5(4, () => null) : void
->someGenerics5 : <U, T>(n: T, f: (x: U) => void) => void
->() => null : () => any
-
-someGenerics5<number, string>('', () => 3);
->someGenerics5<number, string>('', () => 3) : void
->someGenerics5 : <U, T>(n: T, f: (x: U) => void) => void
->() => 3 : () => number
-
-someGenerics5<string, number>(null, null);
->someGenerics5<string, number>(null, null) : void
->someGenerics5 : <U, T>(n: T, f: (x: U) => void) => void
-
-// Generic call with multiple arguments of function types that each have parameters of the same generic type
-function someGenerics6<A>(a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) { }
->someGenerics6 : <A>(a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) => void
->A : A
->a : (a: A) => A
->a : A
->A : A
->A : A
->b : (b: A) => A
->b : A
->A : A
->A : A
->c : (c: A) => A
->c : A
->A : A
->A : A
-
-someGenerics6(n => n, n => n, n => n);
->someGenerics6(n => n, n => n, n => n) : void
->someGenerics6 : <A>(a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) => void
->n => n : (n: {}) => {}
->n : {}
->n : {}
->n => n : (n: {}) => {}
->n : {}
->n : {}
->n => n : (n: {}) => {}
->n : {}
->n : {}
-
-someGenerics6<number>(n => n, n => n, n => n);
->someGenerics6<number>(n => n, n => n, n => n) : void
->someGenerics6 : <A>(a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) => void
->n => n : (n: number) => number
->n : number
->n : number
->n => n : (n: number) => number
->n : number
->n : number
->n => n : (n: number) => number
->n : number
->n : number
-
-someGenerics6<number>((n: number) => n, (n: number) => n, (n: number) => n);
->someGenerics6<number>((n: number) => n, (n: number) => n, (n: number) => n) : void
->someGenerics6 : <A>(a: (a: A) => A, b: (b: A) => A, c: (c: A) => A) => void
->(n: number) => n : (n: number) => number
->n : number
->n : number
->(n: number) => n : (n: number) => number
->n : number
->n : number
->(n: number) => n : (n: number) => number
->n : number
->n : number
-
-// Generic call with multiple arguments of function types that each have parameters of different generic type
-function someGenerics7<A, B, C>(a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) { }
->someGenerics7 : <A, B, C>(a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) => void
->A : A
->B : B
->C : C
->a : (a: A) => A
->a : A
->A : A
->A : A
->b : (b: B) => B
->b : B
->B : B
->B : B
->c : (c: C) => C
->c : C
->C : C
->C : C
-
-someGenerics7(n => n, n => n, n => n);
->someGenerics7(n => n, n => n, n => n) : void
->someGenerics7 : <A, B, C>(a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) => void
->n => n : (n: {}) => {}
->n : {}
->n : {}
->n => n : (n: {}) => {}
->n : {}
->n : {}
->n => n : (n: {}) => {}
->n : {}
->n : {}
-
-someGenerics7<number, string, number>(n => n, n => n, n => n);
->someGenerics7<number, string, number>(n => n, n => n, n => n) : void
->someGenerics7 : <A, B, C>(a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) => void
->n => n : (n: number) => number
->n : number
->n : number
->n => n : (n: string) => string
->n : string
->n : string
->n => n : (n: number) => number
->n : number
->n : number
-
-someGenerics7<number, string, number>((n: number) => n, (n: string) => n, (n: number) => n);
->someGenerics7<number, string, number>((n: number) => n, (n: string) => n, (n: number) => n) : void
->someGenerics7 : <A, B, C>(a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) => void
->(n: number) => n : (n: number) => number
->n : number
->n : number
->(n: string) => n : (n: string) => string
->n : string
->n : string
->(n: number) => n : (n: number) => number
->n : number
->n : number
-
-// Generic call with argument of generic function type
-function someGenerics8<T>(n: T): T { return n; }
->someGenerics8 : <T>(n: T) => T
->T : T
->n : T
->T : T
->T : T
->n : T
-
-var x = someGenerics8(someGenerics7);
->x : <A, B, C>(a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) => void
->someGenerics8(someGenerics7) : <A, B, C>(a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) => void
->someGenerics8 : <T>(n: T) => T
->someGenerics7 : <A, B, C>(a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) => void
-
-x<string, string, string>(null, null, null);
->x<string, string, string>(null, null, null) : void
->x : <A, B, C>(a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) => void
-
-// Generic call with multiple parameters of generic type passed arguments with no best common type
-function someGenerics9<T>(a: T, b: T, c: T): T {
->someGenerics9 : <T>(a: T, b: T, c: T) => T
->T : T
->a : T
->T : T
->b : T
->T : T
->c : T
->T : T
->T : T
-
-    return null;
-}
-var a9a = someGenerics9('', 0, []);
->a9a : {}
->someGenerics9('', 0, []) : {}
->someGenerics9 : <T>(a: T, b: T, c: T) => T
->[] : undefined[]
-
-var a9a: {};
->a9a : {}
-
-var a9b = someGenerics9<{ a?: number; b?: string; }>({ a: 0 }, { b: '' }, null);
->a9b : { a?: number; b?: string; }
->someGenerics9<{ a?: number; b?: string; }>({ a: 0 }, { b: '' }, null) : { a?: number; b?: string; }
->someGenerics9 : <T>(a: T, b: T, c: T) => T
->a : number
->b : string
->{ a: 0 } : { a: number; }
->a : number
->{ b: '' } : { b: string; }
->b : string
-
-var a9b: { a?: number; b?: string; };
->a9b : { a?: number; b?: string; }
->a : number
->b : string
-
-// Generic call with multiple parameters of generic type passed arguments with multiple best common types
-interface A91 {
->A91 : A91
-
-    x: number;
->x : number
-
-    y?: string;
->y : string
-}
-interface A92 {
->A92 : A92
-
-    x: number;
->x : number
-
-    z?: Date;
->z : Date
->Date : Date
-}
-var a9e = someGenerics9(undefined, { x: 6, z: new Date() }, { x: 6, y: '' });
->a9e : {}
->someGenerics9(undefined, { x: 6, z: new Date() }, { x: 6, y: '' }) : {}
->someGenerics9 : <T>(a: T, b: T, c: T) => T
->undefined : undefined
->{ x: 6, z: new Date() } : { x: number; z: Date; }
->x : number
->z : Date
->new Date() : Date
->Date : { (): string; new (): Date; new (value: number): Date; new (value: string): Date; new (year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): Date; prototype: Date; parse(s: string): number; UTC(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number; now(): number; }
->{ x: 6, y: '' } : { x: number; y: string; }
->x : number
->y : string
-
-var a9e: {};
->a9e : {}
-
-var a9f = someGenerics9<A92>(undefined, { x: 6, z: new Date() }, { x: 6, y: '' });
->a9f : A92
->someGenerics9<A92>(undefined, { x: 6, z: new Date() }, { x: 6, y: '' }) : A92
->someGenerics9 : <T>(a: T, b: T, c: T) => T
->A92 : A92
->undefined : undefined
->{ x: 6, z: new Date() } : { x: number; z: Date; }
->x : number
->z : Date
->new Date() : Date
->Date : { (): string; new (): Date; new (value: number): Date; new (value: string): Date; new (year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): Date; prototype: Date; parse(s: string): number; UTC(year: number, month: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number; now(): number; }
->{ x: 6, y: '' } : { x: number; y: string; }
->x : number
->y : string
-
-var a9f: A92;
->a9f : A92
->A92 : A92
-
-// Generic call with multiple parameters of generic type passed arguments with a single best common type
-var a9d = someGenerics9({ x: 3 }, { x: 6 }, { x: 6 });
->a9d : { x: number; }
->someGenerics9({ x: 3 }, { x: 6 }, { x: 6 }) : { x: number; }
->someGenerics9 : <T>(a: T, b: T, c: T) => T
->{ x: 3 } : { x: number; }
->x : number
->{ x: 6 } : { x: number; }
->x : number
->{ x: 6 } : { x: number; }
->x : number
-
-var a9d: { x: number; };
->a9d : { x: number; }
->x : number
-
-// Generic call with multiple parameters of generic type where one argument is of type 'any'
-var anyVar: any;
->anyVar : any
-
-var a = someGenerics9(7, anyVar, 4);
->a : any
->someGenerics9(7, anyVar, 4) : any
->someGenerics9 : <T>(a: T, b: T, c: T) => T
->anyVar : any
-
-var a: any;
->a : any
-
-// Generic call with multiple parameters of generic type where one argument is [] and the other is not 'any'
-var arr = someGenerics9([], null, undefined);
->arr : any[]
->someGenerics9([], null, undefined) : any[]
->someGenerics9 : <T>(a: T, b: T, c: T) => T
->[] : any[]
->undefined : undefined
-
-var arr: any[];
->arr : any[]
-
-
diff --git a/tests/baselines/reference/typeArgumentInferenceConstructSignatures.errors.txt b/tests/baselines/reference/typeArgumentInferenceConstructSignatures.errors.txt
index a9de02d422613..4f11cb6135e4a 100644
--- a/tests/baselines/reference/typeArgumentInferenceConstructSignatures.errors.txt
+++ b/tests/baselines/reference/typeArgumentInferenceConstructSignatures.errors.txt
@@ -3,12 +3,14 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstruct
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(61,39): error TS2345: Argument of type '(x: string) => string' is not assignable to parameter of type '(x: number) => void'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(71,39): error TS2345: Argument of type '(x: string) => string' is not assignable to parameter of type '(x: number) => void'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(81,45): error TS2345: Argument of type '(n: string) => string' is not assignable to parameter of type '(b: number) => number'.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(106,11): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(118,9): error TS2304: Cannot find name 'Window'.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(120,11): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(120,51): error TS2304: Cannot find name 'window'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts(122,56): error TS2304: Cannot find name 'window'.
 
 
-==== tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts (8 errors) ====
+==== tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstructSignatures.ts (10 errors) ====
     // Generic call with no parameters
     interface NoParams {
         new <T>();
@@ -125,6 +127,8 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstruct
     }
     var someGenerics9: someGenerics9;
     var a9a = new someGenerics9('', 0, []);
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var a9a: {};
     var a9b = new someGenerics9<{ a?: number; b?: string; }>({ a: 0 }, { b: '' }, null);
     var a9b: { a?: number; b?: string; };
@@ -141,6 +145,8 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceConstruct
 !!! error TS2304: Cannot find name 'Window'.
     }
     var a9e = new someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
                                                       ~~~~~~
 !!! error TS2304: Cannot find name 'window'.
     var a9e: {};
diff --git a/tests/baselines/reference/typeArgumentInferenceTransitiveConstraints.errors.txt b/tests/baselines/reference/typeArgumentInferenceTransitiveConstraints.errors.txt
index e6e59308dd409..08cb5348c272e 100644
--- a/tests/baselines/reference/typeArgumentInferenceTransitiveConstraints.errors.txt
+++ b/tests/baselines/reference/typeArgumentInferenceTransitiveConstraints.errors.txt
@@ -1,9 +1,8 @@
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceTransitiveConstraints.ts(2,29): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceTransitiveConstraints.ts(2,42): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list.
-tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceTransitiveConstraints.ts(7,5): error TS2403: Subsequent variable declarations must have the same type.  Variable 'd' must be of type '{}[]', but here has type 'Date[]'.
 
 
-==== tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceTransitiveConstraints.ts (3 errors) ====
+==== tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceTransitiveConstraints.ts (2 errors) ====
     
     function fn<A extends Date, B extends A, C extends B>(a: A, b: B, c: C) {
                                 ~~~~~~~~~~~
@@ -15,6 +14,4 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceTransitiv
     
     var d = fn(new Date(), new Date(), new Date());
     var d: Date[]; // Should be OK (d should be Date[])
-        ~
-!!! error TS2403: Subsequent variable declarations must have the same type.  Variable 'd' must be of type '{}[]', but here has type 'Date[]'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/typeArgumentInferenceWithConstraintAsCommonRoot.errors.txt b/tests/baselines/reference/typeArgumentInferenceWithConstraintAsCommonRoot.errors.txt
new file mode 100644
index 0000000000000..c0ee4329c8d7d
--- /dev/null
+++ b/tests/baselines/reference/typeArgumentInferenceWithConstraintAsCommonRoot.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/compiler/typeArgumentInferenceWithConstraintAsCommonRoot.ts(7,1): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/compiler/typeArgumentInferenceWithConstraintAsCommonRoot.ts (1 errors) ====
+    interface Animal { x }
+    interface Giraffe extends Animal { y }
+    interface Elephant extends Animal { z }
+    function f<T extends Animal>(x: T, y: T): T { return undefined; }
+    var g: Giraffe;
+    var e: Elephant;
+    f(g, e); // valid because both Giraffe and Elephant satisfy the constraint. T is Animal
+    ~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
\ No newline at end of file
diff --git a/tests/baselines/reference/typeArgumentInferenceWithConstraintAsCommonRoot.types b/tests/baselines/reference/typeArgumentInferenceWithConstraintAsCommonRoot.types
deleted file mode 100644
index 35328f728035a..0000000000000
--- a/tests/baselines/reference/typeArgumentInferenceWithConstraintAsCommonRoot.types
+++ /dev/null
@@ -1,40 +0,0 @@
-=== tests/cases/compiler/typeArgumentInferenceWithConstraintAsCommonRoot.ts ===
-interface Animal { x }
->Animal : Animal
->x : any
-
-interface Giraffe extends Animal { y }
->Giraffe : Giraffe
->Animal : Animal
->y : any
-
-interface Elephant extends Animal { z }
->Elephant : Elephant
->Animal : Animal
->z : any
-
-function f<T extends Animal>(x: T, y: T): T { return undefined; }
->f : <T extends Animal>(x: T, y: T) => T
->T : T
->Animal : Animal
->x : T
->T : T
->y : T
->T : T
->T : T
->undefined : undefined
-
-var g: Giraffe;
->g : Giraffe
->Giraffe : Giraffe
-
-var e: Elephant;
->e : Elephant
->Elephant : Elephant
-
-f(g, e); // valid because both Giraffe and Elephant satisfy the constraint. T is Animal
->f(g, e) : Animal
->f : <T extends Animal>(x: T, y: T) => T
->g : Giraffe
->e : Elephant
-
diff --git a/tests/baselines/reference/typeArgumentInferenceWithConstraints.errors.txt b/tests/baselines/reference/typeArgumentInferenceWithConstraints.errors.txt
index 8cf2a2d350314..c0dbf74f66e3e 100644
--- a/tests/baselines/reference/typeArgumentInferenceWithConstraints.errors.txt
+++ b/tests/baselines/reference/typeArgumentInferenceWithConstraints.errors.txt
@@ -8,12 +8,14 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConst
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(49,15): error TS2344: Type 'string' does not satisfy the constraint 'number'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(55,41): error TS2345: Argument of type '(n: string) => string' is not assignable to parameter of type '(b: number) => number'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(66,31): error TS2345: Argument of type '<A, B extends string, C>(a: (a: A) => A, b: (b: B) => B, c: (c: C) => C) => void' is not assignable to parameter of type 'string'.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(73,11): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(85,9): error TS2304: Cannot find name 'Window'.
+tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(87,11): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(87,47): error TS2304: Cannot find name 'window'.
 tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts(89,52): error TS2304: Cannot find name 'window'.
 
 
-==== tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts (13 errors) ====
+==== tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConstraints.ts (15 errors) ====
     // Generic call with no parameters
     function noParams<T extends {}>() { }
     noParams();
@@ -107,6 +109,8 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConst
         return null;
     }
     var a9a = someGenerics9('', 0, []);
+              ~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
     var a9a: {};
     var a9b = someGenerics9<{ a?: number; b?: string; }>({ a: 0 }, { b: '' }, null);
     var a9b: { a?: number; b?: string; };
@@ -123,6 +127,8 @@ tests/cases/conformance/expressions/functionCalls/typeArgumentInferenceWithConst
 !!! error TS2304: Cannot find name 'Window'.
     }
     var a9e = someGenerics9(undefined, { x: 6, z: window }, { x: 6, y: '' });
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
                                                   ~~~~~~
 !!! error TS2304: Cannot find name 'window'.
     var a9e: {};
diff --git a/tests/baselines/reference/typeInferenceConflictingCandidates.errors.txt b/tests/baselines/reference/typeInferenceConflictingCandidates.errors.txt
new file mode 100644
index 0000000000000..5f9f980e735e5
--- /dev/null
+++ b/tests/baselines/reference/typeInferenceConflictingCandidates.errors.txt
@@ -0,0 +1,9 @@
+tests/cases/compiler/typeInferenceConflictingCandidates.ts(3,1): error TS2346: Supplied parameters do not match any signature of call target.
+
+
+==== tests/cases/compiler/typeInferenceConflictingCandidates.ts (1 errors) ====
+    declare function g<T>(a: T, b: T, c: (t: T) => T): T;
+    
+    g("", 3, a => a);
+    ~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
\ No newline at end of file
diff --git a/tests/baselines/reference/typeInferenceConflictingCandidates.types b/tests/baselines/reference/typeInferenceConflictingCandidates.types
deleted file mode 100644
index 7a77daf40924a..0000000000000
--- a/tests/baselines/reference/typeInferenceConflictingCandidates.types
+++ /dev/null
@@ -1,21 +0,0 @@
-=== tests/cases/compiler/typeInferenceConflictingCandidates.ts ===
-declare function g<T>(a: T, b: T, c: (t: T) => T): T;
->g : <T>(a: T, b: T, c: (t: T) => T) => T
->T : T
->a : T
->T : T
->b : T
->T : T
->c : (t: T) => T
->t : T
->T : T
->T : T
->T : T
-
-g("", 3, a => a);
->g("", 3, a => a) : {}
->g : <T>(a: T, b: T, c: (t: T) => T) => T
->a => a : (a: {}) => {}
->a : {}
->a : {}
-
diff --git a/tests/baselines/reference/typeParameterAsElementType.types b/tests/baselines/reference/typeParameterAsElementType.types
index 0dbbbf5ac7a02..828c7034a58bf 100644
--- a/tests/baselines/reference/typeParameterAsElementType.types
+++ b/tests/baselines/reference/typeParameterAsElementType.types
@@ -8,7 +8,7 @@ function fee<T>() {
 >T : T
 
     var arr = [t, ""];
->arr : {}[]
->[t, ""] : {}[]
+>arr : Array<string | T>
+>[t, ""] : Array<string | T>
 >t : T
 }
diff --git a/tests/baselines/reference/undefinedInferentialTyping.types b/tests/baselines/reference/undefinedInferentialTyping.types
index b5741e4d40f60..61737ac6b6cec 100644
--- a/tests/baselines/reference/undefinedInferentialTyping.types
+++ b/tests/baselines/reference/undefinedInferentialTyping.types
@@ -15,5 +15,5 @@ var a = f([], 3); // should be number
 >a : number
 >f([], 3) : number
 >f : <T>(arr: T[], elemnt: T) => T
->[] : number[]
+>[] : undefined[]
 
diff --git a/tests/baselines/reference/underscoreTest1.types b/tests/baselines/reference/underscoreTest1.types
index 115bc09195dbe..5337a4971d120 100644
--- a/tests/baselines/reference/underscoreTest1.types
+++ b/tests/baselines/reference/underscoreTest1.types
@@ -104,7 +104,7 @@ var flat = _.reduceRight(list, (a, b) => a.concat(b), []);
 >a : number[]
 >concat : { <U extends number[]>(...items: U[]): number[]; (...items: number[]): number[]; }
 >b : number[]
->[] : number[]
+>[] : undefined[]
 
 var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0);
 >even : number
@@ -176,7 +176,7 @@ _.all([true, 1, null, 'yes'], _.identity);
 >_.all : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
 >_ : Underscore.Static
 >all : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
->[true, 1, null, 'yes'] : {}[]
+>[true, 1, null, 'yes'] : Array<string | number | boolean>
 >_.identity : <T>(value: T) => T
 >_ : Underscore.Static
 >identity : <T>(value: T) => T
@@ -186,7 +186,7 @@ _.any([null, 0, 'yes', false]);
 >_.any : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
 >_ : Underscore.Static
 >any : { <T>(list: T[], iterator?: Iterator<T, boolean>, context?: any): boolean; <T>(list: Dictionary<T>, iterator?: Iterator<T, boolean>, context?: any): boolean; }
->[null, 0, 'yes', false] : {}[]
+>[null, 0, 'yes', false] : Array<string | number | boolean>
 
 _.contains([1, 2, 3], 3);
 >_.contains([1, 2, 3], 3) : boolean
@@ -200,7 +200,7 @@ _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');
 >_.invoke : { (list: any[], methodName: string, ...args: any[]): any[]; (list: Dictionary<any>, methodName: string, ...args: any[]): any[]; }
 >_ : Underscore.Static
 >invoke : { (list: any[], methodName: string, ...args: any[]): any[]; (list: Dictionary<any>, methodName: string, ...args: any[]): any[]; }
->[[5, 1, 7], [3, 2, 1]] : any[]
+>[[5, 1, 7], [3, 2, 1]] : number[][]
 >[5, 1, 7] : number[]
 >[3, 2, 1] : number[]
 
@@ -309,7 +309,7 @@ _.countBy([1, 2, 3, 4, 5], (num) => num % 2 == 0 ? 'even' : 'odd');
 >[1, 2, 3, 4, 5] : number[]
 >(num) => num % 2 == 0 ? 'even' : 'odd' : (num: number) => string
 >num : number
->num % 2 == 0 ? 'even' : 'odd' : any
+>num % 2 == 0 ? 'even' : 'odd' : string
 >num % 2 == 0 : boolean
 >num % 2 : number
 >num : number
@@ -364,25 +364,25 @@ _.rest([5, 4, 3, 2, 1]);
 >[5, 4, 3, 2, 1] : number[]
 
 _.compact([0, 1, false, 2, '', 3]);
->_.compact([0, 1, false, 2, '', 3]) : {}[]
+>_.compact([0, 1, false, 2, '', 3]) : Array<string | number | boolean>
 >_.compact : <T>(list: T[]) => T[]
 >_ : Underscore.Static
 >compact : <T>(list: T[]) => T[]
->[0, 1, false, 2, '', 3] : {}[]
+>[0, 1, false, 2, '', 3] : Array<string | number | boolean>
 
 _.flatten([1, 2, 3, 4]);
 >_.flatten([1, 2, 3, 4]) : {}[]
 >_.flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
 >_ : Underscore.Static
 >flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
->[1, 2, 3, 4] : any[]
+>[1, 2, 3, 4] : number[]
 
 _.flatten([1, [2]]);
 >_.flatten([1, [2]]) : {}[]
 >_.flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
 >_ : Underscore.Static
 >flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
->[1, [2]] : any[]
+>[1, [2]] : Array<number | number[]>
 >[2] : number[]
 
 // typescript doesn't like the elements being different
@@ -391,9 +391,9 @@ _.flatten([1, [2], [3, [[4]]]]);
 >_.flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
 >_ : Underscore.Static
 >flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
->[1, [2], [3, [[4]]]] : any[]
+>[1, [2], [3, [[4]]]] : Array<number | Array<number | number[][]>>
 >[2] : number[]
->[3, [[4]]] : {}[]
+>[3, [[4]]] : Array<number | number[][]>
 >[[4]] : number[][]
 >[4] : number[]
 
@@ -402,9 +402,9 @@ _.flatten([1, [2], [3, [[4]]]], true);
 >_.flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
 >_ : Underscore.Static
 >flatten : { <T>(list: T[][]): T[]; <T>(array: any[], shallow?: boolean): T[]; }
->[1, [2], [3, [[4]]]] : any[]
+>[1, [2], [3, [[4]]]] : Array<number | Array<number | number[][]>>
 >[2] : number[]
->[3, [[4]]] : {}[]
+>[3, [[4]]] : Array<number | number[][]>
 >[[4]] : number[][]
 >[4] : number[]
 
@@ -463,17 +463,17 @@ _.object(['moe', 'larry', 'curly'], [30, 40, 50]);
 >_ : Underscore.Static
 >object : { (list: any[][]): any; (keys: string[], values: any[]): any; }
 >['moe', 'larry', 'curly'] : string[]
->[30, 40, 50] : any[]
+>[30, 40, 50] : number[]
 
 _.object([['moe', 30], ['larry', 40], ['curly', 50]]);
 >_.object([['moe', 30], ['larry', 40], ['curly', 50]]) : any
 >_.object : { (list: any[][]): any; (keys: string[], values: any[]): any; }
 >_ : Underscore.Static
 >object : { (list: any[][]): any; (keys: string[], values: any[]): any; }
->[['moe', 30], ['larry', 40], ['curly', 50]] : any[][]
->['moe', 30] : any[]
->['larry', 40] : any[]
->['curly', 50] : any[]
+>[['moe', 30], ['larry', 40], ['curly', 50]] : Array<string | number>[]
+>['moe', 30] : Array<string | number>
+>['larry', 40] : Array<string | number>
+>['curly', 50] : Array<string | number>
 
 _.indexOf([1, 2, 3], 2);
 >_.indexOf([1, 2, 3], 2) : number
diff --git a/tests/baselines/reference/validMultipleVariableDeclarations.types b/tests/baselines/reference/validMultipleVariableDeclarations.types
index 89d3702a702d6..4bbd46bab2bb4 100644
--- a/tests/baselines/reference/validMultipleVariableDeclarations.types
+++ b/tests/baselines/reference/validMultipleVariableDeclarations.types
@@ -117,11 +117,11 @@ var a = ['a', 'b']
 var a = <string[]>[];
 >a : string[]
 ><string[]>[] : string[]
->[] : string[]
+>[] : undefined[]
 
 var a: string[] = [];
 >a : string[]
->[] : string[]
+>[] : undefined[]
 
 var a = new Array<string>();
 >a : string[]
diff --git a/tests/cases/compiler/arrayBestCommonTypes.ts b/tests/cases/compiler/arrayBestCommonTypes.ts
index ee09c4d07f6a2..c7466b5181e92 100644
--- a/tests/cases/compiler/arrayBestCommonTypes.ts
+++ b/tests/cases/compiler/arrayBestCommonTypes.ts
@@ -1,52 +1,106 @@
-interface iface { }
-class base implements iface { }
-class base2 implements iface { }
-class derived extends base { }
-
-
-class f {
-    public voidIfAny(x: boolean, y?: boolean): number;
-    public voidIfAny(x: string, y?: boolean): number;
-    public voidIfAny(x: number, y?: boolean): number;
-    public voidIfAny(x: any, y =false): any { return null; }
-    
-    public x() {
-        <number>(this.voidIfAny([4, 2][0]));
-        <number>(this.voidIfAny([4, 2, undefined][0]));
-        <number>(this.voidIfAny([undefined, 2, 4][0]));
-        <number>(this.voidIfAny([null, 2, 4][0]));
-        <number>(this.voidIfAny([2, 4, null][0]));
-        <number>(this.voidIfAny([undefined, 4, null][0]));
-
-        <number>(this.voidIfAny(['', "q"][0]));
-        <number>(this.voidIfAny(['', "q", undefined][0]));
-        <number>(this.voidIfAny([undefined, "q", ''][0]));
-        <number>(this.voidIfAny([null, "q", ''][0]));
-        <number>(this.voidIfAny(["q", '', null][0]));
-        <number>(this.voidIfAny([undefined, '', null][0]));
-
-        <number>(this.voidIfAny([[3,4],[null]][0][0]));
-        
-        
-        var t1: { x: number; y: base; }[] = [ { x: 7, y: new derived() }, { x: 5, y: new base() } ];
-        var t2: { x: boolean; y: base; }[] = [ { x: true, y: new derived() }, { x: false, y: new base() } ];
-        var t3: { x: string; y: base; }[] = [ { x: undefined, y: new base() }, { x: '', y: new derived() } ];
-
-        var anyObj: any = null;
-        // Order matters here so test all the variants
-        var a1 = [ {x: 0, y: 'a'}, {x: 'a', y: 'a'}, {x: anyObj, y: 'a'} ];
-        var a2 = [ {x: anyObj, y: 'a'}, {x: 0, y: 'a'}, {x: 'a', y: 'a'} ];
-        var a3 = [ {x: 0, y: 'a'}, {x: anyObj, y: 'a'}, {x: 'a', y: 'a'} ];
-        
-        var ifaceObj: iface = null;
-        var baseObj = new base();
-        var base2Obj = new base2();
-
-        var b1 = [ baseObj, base2Obj, ifaceObj ];
-        var b2 = [ base2Obj, baseObj, ifaceObj ];
-        var b3 = [ baseObj, ifaceObj, base2Obj ];
-        var b4 = [ ifaceObj, baseObj, base2Obj ];
+module EmptyTypes {
+    interface iface { }
+    class base implements iface { }
+    class base2 implements iface { }
+    class derived extends base { }
+
+
+    class f {
+        public voidIfAny(x: boolean, y?: boolean): number;
+        public voidIfAny(x: string, y?: boolean): number;
+        public voidIfAny(x: number, y?: boolean): number;
+        public voidIfAny(x: any, y = false): any { return null; }
+
+        public x() {
+            <number>(this.voidIfAny([4, 2][0]));
+            <number>(this.voidIfAny([4, 2, undefined][0]));
+            <number>(this.voidIfAny([undefined, 2, 4][0]));
+            <number>(this.voidIfAny([null, 2, 4][0]));
+            <number>(this.voidIfAny([2, 4, null][0]));
+            <number>(this.voidIfAny([undefined, 4, null][0]));
+
+            <number>(this.voidIfAny(['', "q"][0]));
+            <number>(this.voidIfAny(['', "q", undefined][0]));
+            <number>(this.voidIfAny([undefined, "q", ''][0]));
+            <number>(this.voidIfAny([null, "q", ''][0]));
+            <number>(this.voidIfAny(["q", '', null][0]));
+            <number>(this.voidIfAny([undefined, '', null][0]));
+
+            <number>(this.voidIfAny([[3, 4], [null]][0][0]));
+
+
+            var t1: { x: number; y: base; }[] = [{ x: 7, y: new derived() }, { x: 5, y: new base() }];
+            var t2: { x: boolean; y: base; }[] = [{ x: true, y: new derived() }, { x: false, y: new base() }];
+            var t3: { x: string; y: base; }[] = [{ x: undefined, y: new base() }, { x: '', y: new derived() }];
+
+            var anyObj: any = null;
+            // Order matters here so test all the variants
+            var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
+            var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
+            var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
+
+            var ifaceObj: iface = null;
+            var baseObj = new base();
+            var base2Obj = new base2();
+
+            var b1 = [baseObj, base2Obj, ifaceObj];
+            var b2 = [base2Obj, baseObj, ifaceObj];
+            var b3 = [baseObj, ifaceObj, base2Obj];
+            var b4 = [ifaceObj, baseObj, base2Obj];
+        }
     }
 }
 
+module NonEmptyTypes {
+    interface iface { x: string; }
+    class base implements iface { x: string; y: string; }
+    class base2 implements iface { x: string; z: string; }
+    class derived extends base { a: string; }
+
+
+    class f {
+        public voidIfAny(x: boolean, y?: boolean): number;
+        public voidIfAny(x: string, y?: boolean): number;
+        public voidIfAny(x: number, y?: boolean): number;
+        public voidIfAny(x: any, y = false): any { return null; }
+
+        public x() {
+            <number>(this.voidIfAny([4, 2][0]));
+            <number>(this.voidIfAny([4, 2, undefined][0]));
+            <number>(this.voidIfAny([undefined, 2, 4][0]));
+            <number>(this.voidIfAny([null, 2, 4][0]));
+            <number>(this.voidIfAny([2, 4, null][0]));
+            <number>(this.voidIfAny([undefined, 4, null][0]));
+
+            <number>(this.voidIfAny(['', "q"][0]));
+            <number>(this.voidIfAny(['', "q", undefined][0]));
+            <number>(this.voidIfAny([undefined, "q", ''][0]));
+            <number>(this.voidIfAny([null, "q", ''][0]));
+            <number>(this.voidIfAny(["q", '', null][0]));
+            <number>(this.voidIfAny([undefined, '', null][0]));
+
+            <number>(this.voidIfAny([[3, 4], [null]][0][0]));
+
+
+            var t1: { x: number; y: base; }[] = [{ x: 7, y: new derived() }, { x: 5, y: new base() }];
+            var t2: { x: boolean; y: base; }[] = [{ x: true, y: new derived() }, { x: false, y: new base() }];
+            var t3: { x: string; y: base; }[] = [{ x: undefined, y: new base() }, { x: '', y: new derived() }];
+
+            var anyObj: any = null;
+            // Order matters here so test all the variants
+            var a1 = [{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }];
+            var a2 = [{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }];
+            var a3 = [{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }];
+
+            var ifaceObj: iface = null;
+            var baseObj = new base();
+            var base2Obj = new base2();
+
+            var b1 = [baseObj, base2Obj, ifaceObj];
+            var b2 = [base2Obj, baseObj, ifaceObj];
+            var b3 = [baseObj, ifaceObj, base2Obj];
+            var b4 = [ifaceObj, baseObj, base2Obj];
+        }
+    }
+}
 
diff --git a/tests/cases/compiler/arrayLiteralContextualType.ts b/tests/cases/compiler/arrayLiteralContextualType.ts
index 1518d2e4ac0ba..be05929e8e7f3 100644
--- a/tests/cases/compiler/arrayLiteralContextualType.ts
+++ b/tests/cases/compiler/arrayLiteralContextualType.ts
@@ -25,5 +25,5 @@ bar([
 ]); // Legal because of the contextual type IAnimal provided by the parameter
 
 var arr = [new Giraffe(), new Elephant()];
-foo(arr); // Error because of no contextual type
-bar(arr); // Error because of no contextual type
\ No newline at end of file
+foo(arr); // ok because arr is Array<Giraffe|Elephant> not {}[]
+bar(arr); // ok because arr is Array<Giraffe|Elephant> not {}[]
\ No newline at end of file
diff --git a/tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts b/tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts
index bd1f22f44dcf7..1ea001057a98f 100644
--- a/tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts
+++ b/tests/cases/compiler/contextualTypingWithFixedTypeParameters1.ts
@@ -1,3 +1,3 @@
 var f10: <T>(x: T, b: () => (a: T) => void, y: T) => T;
-f10('', () => a => a.foo, ''); // a is string, fixed by first parameter
-var r9 = f10('', () => (a => a.foo), 1); // now a should be any
\ No newline at end of file
+f10('', () => a => a.foo, ''); // a is string
+var r9 = f10('', () => (a => a.foo), 1); // error
\ No newline at end of file
diff --git a/tests/cases/compiler/defaultBestCommonTypesHaveDecls.ts b/tests/cases/compiler/defaultBestCommonTypesHaveDecls.ts
index b9fecdc6ffc28..254197bf30986 100644
--- a/tests/cases/compiler/defaultBestCommonTypesHaveDecls.ts
+++ b/tests/cases/compiler/defaultBestCommonTypesHaveDecls.ts
@@ -1,18 +1,14 @@
-
 var obj1: {};
-
 obj1.length;
- 
- 
 
 var obj2: Object;
-
 obj2.length;
- 
- 
 
 function concat<T>(x: T, y: T): T { return null; }
+var result = concat(1, ""); // error
+var elementCount = result.length; 
 
-var result = concat(1, "");
+function concat2<T, U>(x: T, y: U) { return null; }
+var result2 = concat2(1, ""); // result2 will be number|string
+var elementCount2 = result.length; 
 
-var elementCount = result.length; // would like to get an error by now
diff --git a/tests/cases/compiler/nonContextuallyTypedLogicalOr.ts b/tests/cases/compiler/nonContextuallyTypedLogicalOr.ts
index f77ad5105ab34..cadd60ea398bb 100644
--- a/tests/cases/compiler/nonContextuallyTypedLogicalOr.ts
+++ b/tests/cases/compiler/nonContextuallyTypedLogicalOr.ts
@@ -11,6 +11,4 @@ interface Ellement {
 var c: Contextual;
 var e: Ellement;
 
-// This should error. Even though we are contextually typing e with Contextual, the RHS still
-// needs to be a supertype of the LHS to win as the best common type.
 (c || e).dummy;
\ No newline at end of file
diff --git a/tests/cases/compiler/promisePermutations.ts b/tests/cases/compiler/promisePermutations.ts
index c5091aaa630fc..0ce62be8181a0 100644
--- a/tests/cases/compiler/promisePermutations.ts
+++ b/tests/cases/compiler/promisePermutations.ts
@@ -11,7 +11,7 @@ interface IPromise<T> {
     then<U>(success?: (value: T) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
     then<U>(success?: (value: T) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>;
     then<U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
-    done?<U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
+    done? <U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
 }
 
 declare function testFunction(): IPromise<number>;
@@ -71,7 +71,7 @@ var s3: Promise<number>;
 var s3a = s3.then(testFunction3, testFunction3, testFunction3);
 var s3b = s3.then(testFunction3P, testFunction3P, testFunction3P);
 var s3c = s3.then(testFunction3P, testFunction3, testFunction3);
-var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3);
+var s3d = s3.then(testFunction3P, testFunction3, testFunction3).then(testFunction3, testFunction3, testFunction3); // error
 
 var r4: IPromise<string>;
 var sIPromise: (x: any) => IPromise<string>;
@@ -82,7 +82,7 @@ var s4: Promise<string>;
 var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error 
 var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
-var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4); 
+var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4);
 
 var r5: IPromise<string>;
 var r5a = r5.then(testFunction5, testFunction5, testFunction5); // error
@@ -134,7 +134,7 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 var s9e = s9.then(nPromise, nPromise, nPromise); // ok
-var s9f = s9.then(testFunction, sIPromise, nIPromise); // ok
+var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 
 var r10 = testFunction10(x => x);
@@ -149,15 +149,15 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
-var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // ok
+var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
 
 var r11: IPromise<number>;
-var r11a = r11.then(testFunction11, testFunction11, testFunction11); // ok
+var r11a = r11.then(testFunction11, testFunction11, testFunction11); // error
 var s11: Promise<number>;
 var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
-var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
-var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // ok
+var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error
+var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error
 
 var r12 = testFunction12(x => x);
 var r12a = r12.then(testFunction12, testFunction12, testFunction12); // ok
diff --git a/tests/cases/compiler/promisePermutations2.ts b/tests/cases/compiler/promisePermutations2.ts
index 66f9806de00de..05a60860929fb 100644
--- a/tests/cases/compiler/promisePermutations2.ts
+++ b/tests/cases/compiler/promisePermutations2.ts
@@ -10,7 +10,7 @@ interface IPromise<T> {
     then<U>(success?: (value: T) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
     then<U>(success?: (value: T) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>;
     then<U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
-    done?<U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
+    done? <U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
 }
 
 declare function testFunction(): IPromise<number>;
@@ -81,7 +81,7 @@ var s4: Promise<string>;
 var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error 
 var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
-var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4); 
+var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4);
 
 var r5: IPromise<string>;
 var r5a = r5.then(testFunction5, testFunction5, testFunction5); // error
@@ -125,7 +125,7 @@ var r9: IPromise<number>;
 var r9a = r9.then(testFunction9, testFunction9, testFunction9); // error
 var r9b = r9.then(sIPromise, sIPromise, sIPromise); // ok
 var r9c = r9.then(nIPromise, nIPromise, nIPromise); // ok
-var r9d = r9.then(testFunction, sIPromise, nIPromise); // ok
+var r9d = r9.then(testFunction, sIPromise, nIPromise); // error
 var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var s9: Promise<number>;
 var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
@@ -133,14 +133,14 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 var s9e = s9.then(nPromise, nPromise, nPromise); // ok
-var s9f = s9.then(testFunction, sIPromise, nIPromise); // ok
+var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 
 var r10 = testFunction10(x => x);
 var r10a = r10.then(testFunction10, testFunction10, testFunction10); // ok
 var r10b = r10.then(sIPromise, sIPromise, sIPromise); // ok
 var r10c = r10.then(nIPromise, nIPromise, nIPromise); // ok
-var r10d = r10.then(testFunction, sIPromise, nIPromise); // ok
+var r10d = r10.then(testFunction, sIPromise, nIPromise); // error
 var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var s10 = testFunction10P(x => x);
 var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
@@ -148,11 +148,11 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
-var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // ok
+var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
 
 var r11: IPromise<number>;
-var r11a = r11.then(testFunction11, testFunction11, testFunction11); // ok
+var r11a = r11.then(testFunction11, testFunction11, testFunction11); // error
 var s11: Promise<number>;
 var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
 var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
diff --git a/tests/cases/compiler/promisePermutations3.ts b/tests/cases/compiler/promisePermutations3.ts
index 78d6b17c9ec48..3aab00b0ed030 100644
--- a/tests/cases/compiler/promisePermutations3.ts
+++ b/tests/cases/compiler/promisePermutations3.ts
@@ -10,7 +10,7 @@ interface Promise<T> {
 
 interface IPromise<T> {
     then<U>(success?: (value: T) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>;
-    done?<U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
+    done? <U>(success?: (value: T) => any, error?: (error: any) => any, progress?: (progress: any) => void): void;
 }
 
 declare function testFunction(): IPromise<number>;
@@ -81,7 +81,7 @@ var s4: Promise<string>;
 var s4a = s4.then(testFunction4, testFunction4, testFunction4); // error
 var s4b = s4.then(testFunction4P, testFunction4P, testFunction4P); // error 
 var s4c = s4.then(testFunction4P, testFunction4, testFunction4); // error
-var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4); 
+var s4d = s4.then(sIPromise, testFunction4P, testFunction4).then(sIPromise, testFunction4P, testFunction4);
 
 var r5: IPromise<string>;
 var r5a = r5.then(testFunction5, testFunction5, testFunction5); // error
@@ -125,7 +125,7 @@ var r9: IPromise<number>;
 var r9a = r9.then(testFunction9, testFunction9, testFunction9); // error
 var r9b = r9.then(sIPromise, sIPromise, sIPromise); // ok
 var r9c = r9.then(nIPromise, nIPromise, nIPromise); // ok
-var r9d = r9.then(testFunction, sIPromise, nIPromise); // ok
+var r9d = r9.then(testFunction, sIPromise, nIPromise); // error
 var r9e = r9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var s9: Promise<number>;
 var s9a = s9.then(testFunction9, testFunction9, testFunction9); // error
@@ -133,14 +133,14 @@ var s9b = s9.then(testFunction9P, testFunction9P, testFunction9P); // error
 var s9c = s9.then(testFunction9P, testFunction9, testFunction9); // error
 var s9d = s9.then(sPromise, sPromise, sPromise); // ok
 var s9e = s9.then(nPromise, nPromise, nPromise); // ok
-var s9f = s9.then(testFunction, sIPromise, nIPromise); // ok
+var s9f = s9.then(testFunction, sIPromise, nIPromise); // error
 var s9g = s9.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 
 var r10 = testFunction10(x => x);
 var r10a = r10.then(testFunction10, testFunction10, testFunction10); // ok
 var r10b = r10.then(sIPromise, sIPromise, sIPromise); // ok
 var r10c = r10.then(nIPromise, nIPromise, nIPromise); // ok
-var r10d = r10.then(testFunction, sIPromise, nIPromise); // ok
+var r10d = r10.then(testFunction, sIPromise, nIPromise); // error
 var r10e = r10.then(testFunction, nIPromise, sIPromise).then(sIPromise, sIPromise, sIPromise); // ok
 var s10 = testFunction10P(x => x);
 var s10a = s10.then(testFunction10, testFunction10, testFunction10); // ok
@@ -148,15 +148,15 @@ var s10b = s10.then(testFunction10P, testFunction10P, testFunction10P); // ok
 var s10c = s10.then(testFunction10P, testFunction10, testFunction10); // ok
 var s10d = s10.then(sPromise, sPromise, sPromise); // ok
 var s10e = s10.then(nIPromise, nPromise, nIPromise); // ok
-var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // ok
+var s10f = s10.then(testFunctionP, sIPromise, nIPromise); // error
 var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
 
 var r11: IPromise<number>;
 var r11a = r11.then(testFunction11, testFunction11, testFunction11); // ok
 var s11: Promise<number>;
 var s11a = s11.then(testFunction11, testFunction11, testFunction11); // ok
-var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // ok
-var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // ok
+var s11b = s11.then(testFunction11P, testFunction11P, testFunction11P); // error
+var s11c = s11.then(testFunction11P, testFunction11, testFunction11); // error
 
 var r12 = testFunction12(x => x);
 var r12a = r12.then(testFunction12, testFunction12, testFunction12); // ok
diff --git a/tests/cases/compiler/tupleTypes.ts b/tests/cases/compiler/tupleTypes.ts
index 3b22c284cb1c8..80181f8b33279 100644
--- a/tests/cases/compiler/tupleTypes.ts
+++ b/tests/cases/compiler/tupleTypes.ts
@@ -8,8 +8,8 @@ var t0 = t[0];   // number
 var t0: number;
 var t1 = t[1];   // string
 var t1: string;
-var t2 = t[2];   // {}
-var t2: {};
+var t2 = t[2];   // number|string
+var t2: number|string;
 
 t = [];               // Error
 t = [1];              // Error
@@ -32,8 +32,8 @@ var tt0 = tt[0];
 var tt0: number;
 var tt1 = tt[1];
 var tt1: string;
-var tt2 = tt[2];
-var tt2: {};
+var tt2 = tt[2]; 
+var tt2: number | string;
 
 tt = tuple2(1, undefined);
 tt = [1, undefined];
diff --git a/tests/cases/compiler/typeArgInference2.ts b/tests/cases/compiler/typeArgInference2.ts
index 523d1eab506cf..5bf8599996e1c 100644
--- a/tests/cases/compiler/typeArgInference2.ts
+++ b/tests/cases/compiler/typeArgInference2.ts
@@ -1,12 +1,12 @@
-interface Item {
-    name: string;
-}
-
-declare function foo<T extends Item>(x?: T, y?: T): T;
-
-var z1 = foo(null);                   // any
-var z2 = foo();                       // Item
-var z3 = foo({ name: null });         // { name: any }
-var z4 = foo({ name: "abc" });        // { name: string }
-var z5 = foo({ name: "abc", a: 5 });  // { name: string; a: number }
-var z6 = foo({ name: "abc", a: 5 }, { name: "def", b: 5 });  // Item
\ No newline at end of file
+interface Item {
+    name: string;
+}
+
+declare function foo<T extends Item>(x?: T, y?: T): T;
+
+var z1 = foo(null);                   // any
+var z2 = foo();                       // Item
+var z3 = foo({ name: null });         // { name: any }
+var z4 = foo({ name: "abc" });        // { name: string }
+var z5 = foo({ name: "abc", a: 5 });  // { name: string; a: number }
+var z6 = foo({ name: "abc", a: 5 }, { name: "def", b: 5 });  // error
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/arrayLiterals/arrayLiterals.ts b/tests/cases/conformance/expressions/arrayLiterals/arrayLiterals.ts
index b4b855737554f..41c5a0b8100bf 100644
--- a/tests/cases/conformance/expressions/arrayLiterals/arrayLiterals.ts
+++ b/tests/cases/conformance/expressions/arrayLiterals/arrayLiterals.ts
@@ -1,28 +1,21 @@
 // Empty array literal with no contextual type has type Undefined[]
 
 var arr1= [[], [1], ['']];
-var arr1: {}[]; // Bug 825172: Error ({}[] does not match {}[]), but should be OK
 
 var arr2 = [[null], [1], ['']];
-var arr2: {}[]; // Bug 825172: Error ({}[] does not match {}[]), but should be OK
 
 
 // Array literal with elements of only EveryType E has type E[]
 var stringArrArr = [[''], [""]];
-var stringArrArr: string[][];
 
 var stringArr = ['', ""];
-var stringArr: string[];
 
 var numberArr = [0, 0.0, 0x00, 1e1];
-var numberArr: number[];
 
 var boolArr = [false, true, false, true];
-var boolArr: boolean[];
 
 class C { private p; }
 var classArr = [new C(), new C()];
-var classArr: C[]; // Should be OK
 
 var classTypeArray = [C, C, C];
 var classTypeArray: Array<typeof C>; // Should OK, not be a parse error
@@ -30,7 +23,6 @@ var classTypeArray: Array<typeof C>; // Should OK, not be a parse error
 // Contextual type C with numeric index signature makes array literal of EveryType E of type BCT(E,C)[]
 var context1: { [n: number]: { a: string; b: number; }; } = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
 var context2 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
-var context2: Array<{}>; // Should be OK
 
 // Contextual type C with numeric index signature of type Base makes array literal of Derived have type Base[]
 class Base { private p; }
diff --git a/tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts b/tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts
index 34ef4b3ca8cd0..feaa3c5a28013 100644
--- a/tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts
+++ b/tests/cases/conformance/expressions/conditonalOperator/conditionalOperatorWithoutIdenticalBCT.ts
@@ -1,21 +1,20 @@
-//Cond ? Expr1 : Expr2,  Expr1 and Expr2 have no identical best common type
-class X { propertyX: any; propertyX1: number; propertyX2: string };
-class A extends X { propertyA: number };
-class B extends X { propertyB: string };
-
-var x: X;
-var a: A;
-var b: B;
-
-//Expect to have compiler errors
-//Be not contextually typed
-true ? a : b;
-var result1 = true ? a : b;
-
-//Be contextually typed and and bct is not identical
-var result2: A = true ? a : b;
-var result3: B = true ? a : b;
-
-var result4: (t: X) => number = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
-var result5: (t: X) => string = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
+//Cond ? Expr1 : Expr2,  Expr1 and Expr2 have no identical best common type
+class X { propertyX: any; propertyX1: number; propertyX2: string };
+class A extends X { propertyA: number };
+class B extends X { propertyB: string };
+
+var x: X;
+var a: A;
+var b: B;
+
+// No errors anymore, uses union types
+true ? a : b;
+var result1 = true ? a : b;
+
+//Be contextually typed and and bct is not identical, results in errors that union type is not assignable to target
+var result2: A = true ? a : b;
+var result3: B = true ? a : b;
+
+var result4: (t: X) => number = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
+var result5: (t: X) => string = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
 var result6: (t: X) => boolean = true ? (m) => m.propertyX1 : (n) => n.propertyX2;
\ No newline at end of file
diff --git a/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts b/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts
index 68ac4cff026b8..9edf4f5f41736 100644
--- a/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts
+++ b/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints2.ts
@@ -15,8 +15,8 @@ function f2<T extends U, U extends V, V>(x: T, y: U, z: V) {
     var r2 = true ? y : z;
 
     // ok
-    var r2 = true ? z : x;
-    var r2 = true ? x : z;
+    var r2a = true ? z : x;
+    var r2b = true ? x : z;
 }
 
 // Date > U > T
@@ -57,18 +57,18 @@ function f4<T extends Number>(x: T) {
 }
 
 function f5<T extends Number>(x: T) {
-    var r1 = true ? 1 : x; // error
-    var r1 = true ? x : 1; // error
+    var r1 = true ? 1 : x; // ok
+    var r1 = true ? x : 1; // ok
 }
 
 function f6<T extends String>(x: T) {
-    var r2 = true ? '' : x; // error
-    var r2 = true ? x : ''; // error
+    var r2 = true ? '' : x; // ok
+    var r2 = true ? x : ''; // ok
 }
 
 function f7<T extends Boolean>(x: T) {
-    var r3 = true ? true : x; // error
-    var r3 = true ? x : true; // error
+    var r3 = true ? true : x; // ok
+    var r3 = true ? x : true; // ok
 }
 
 function f8<T extends Date>(x: T) {
@@ -115,11 +115,11 @@ function f15<T extends C2<number>>(x: T) {
 }
 
 function f16<T extends E>(x: T) {
-    var r13 = true ? E : x; // BUG 831833
-    var r13 = true ? x : E; // BUG 831833
+    var r13 = true ? E : x; // ok
+    var r13 = true ? x : E; // ok
 
-    var r14 = true ? E.A : x; // BUG 831833
-    var r14 = true ? x : E.A; // BUG 831833
+    var r14 = true ? E.A : x; // ok
+    var r14 = true ? x : E.A; // ok
 }
 
 function f17<T extends typeof f>(x: T) {
diff --git a/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints3.ts b/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints3.ts
index 10021cdcc0602..96218dce43ec9 100644
--- a/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints3.ts
+++ b/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints3.ts
@@ -5,11 +5,11 @@ function f<T extends U, U, V>(t: T, u: U, v: V) {
     var r = true ? t : u;
     var r = true ? u : t;
 
-    // error
+    // ok
     var r2 = true ? t : v;
     var r2 = true ? v : t;
 
-    // error
+    // ok
     var r3 = true ? v : u;
     var r3 = true ? u : v;
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts b/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts
index a4e691edbb433..0dc53908ea329 100644
--- a/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts
+++ b/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithConstraints4.ts
@@ -2,15 +2,15 @@
 
 class Foo { foo: number; }
 function f<T extends Foo, U extends Foo, V>(t: T, u: U, v: V) {
-    // error
+    // ok
     var r = true ? t : u;
     var r = true ? u : t;
 
-    // error
+    // ok
     var r2 = true ? t : v;
     var r2 = true ? v : t;
 
-    // error
+    // ok
     var r3 = true ? v : u;
     var r3 = true ? u : v;
 
@@ -22,7 +22,7 @@ function f<T extends Foo, U extends Foo, V>(t: T, u: U, v: V) {
     var r5 = true ? u : new Foo();
     var r5 = true ? new Foo() : u;
 
-    // BUG, should be error
+    // ok
     var r6 = true ? v : new Foo();
     var r6 = true ? new Foo() : v;
 
diff --git a/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts b/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts
index dc3f2917ec12e..f63b63432e549 100644
--- a/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts
+++ b/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypesOfTypeParameterWithRecursiveConstraints.ts
@@ -2,53 +2,53 @@
 
 class Foo<T> { foo: T; }
 function f<T extends Foo<U>, U extends Foo<T>, V extends Foo<V>>(t: T, u: U, v: V) {
-    // error
+    // ok
     var r1 = true ? t : u;
     var r1 = true ? u : t;
 
-    // error
+    // ok
     var r2 = true ? t : v;
     var r2 = true ? v : t;
 
-    // error
+    // ok
     var r3 = true ? v : u;
     var r3 = true ? u : v;
 
-    // ok?
+    // ok
     var r4 = true ? t : new Foo<T>();
     var r4 = true ? new Foo<T>() : t;
 
-    // ok?
+    // ok
     var r5 = true ? u : new Foo<T>();
     var r5 = true ? new Foo<T>() : u;
 
-    // ok?
+    // ok
     var r6 = true ? v : new Foo<T>();
     var r6 = true ? new Foo<T>() : v;
 
 
-    // ok?
+    // ok
     var r7 = true ? t : new Foo<U>();
     var r7 = true ? new Foo<U>() : t;
 
-    // ok?
+    // ok
     var r8 = true ? u : new Foo<U>();
     var r8 = true ? new Foo<U>() : u;
 
-    // ok?
+    // ok
     var r9 = true ? v : new Foo<U>();
     var r9 = true ? new Foo<U>() : v;
 
 
-    // ok?
+    // ok
     var r10 = true ? t : new Foo<V>();
     var r10 = true ? new Foo<V>() : t;
 
-    // ok?
+    // ok
     var r11 = true ? u : new Foo<V>();
     var r11 = true ? new Foo<V>() : u;
 
-    // ok?
+    // ok
     var r12 = true ? v : new Foo<V>();
     var r12 = true ? new Foo<V>() : v;
 }
diff --git a/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembersOptionality2.ts b/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembersOptionality2.ts
index 601d85704eb01..ac8f5642f7084 100644
--- a/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembersOptionality2.ts
+++ b/tests/cases/conformance/types/typeRelationships/subtypesAndSuperTypes/subtypingWithObjectMembersOptionality2.ts
@@ -30,4 +30,4 @@ interface S3 extends T3 {
 // object literal case
 var a: { Foo: Base; }
 var b: { Foo?: Derived; }
-var r = true ? a : b; // error
\ No newline at end of file
+var r = true ? a : b; // ok
\ No newline at end of file
diff --git a/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments.ts b/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments.ts
index 3f2e17c6b05fd..97359cde959c1 100644
--- a/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments.ts
+++ b/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments.ts
@@ -23,14 +23,14 @@ function foo3<T, U>(x: T, cb: (a: T) => U, y: U) {
 
 var r7 = foo3(1, <Z>(a: Z) => '', ''); // string
 
-var r8 = foo3(1, function (a) { return '' }, 1); // {}
+var r8 = foo3(1, function (a) { return '' }, 1); // error
 var r9 = foo3<number, string>(1, (a) => '', ''); // string
 
 function other<T, U>(t: T, u: U) {
-    var r10 = foo2(1, (x: T) => ''); // string, non-generic signature allows inferences to be made
+    var r10 = foo2(1, (x: T) => ''); // error
     var r10 = foo2(1, (x) => ''); // string
 
-    var r11 = foo3(1, (x: T) => '', ''); // string
-    var r11b = foo3(1, (x: T) => '', 1); // {}
-    var r12 = foo3(1, function (a) { return '' }, 1); // {}
+    var r11 = foo3(1, (x: T) => '', ''); // error
+    var r11b = foo3(1, (x: T) => '', 1); // error
+    var r12 = foo3(1, function (a) { return '' }, 1); // error
 }
\ No newline at end of file
diff --git a/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments2.ts b/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments2.ts
index f313d638bfb23..0d02afe9c880a 100644
--- a/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments2.ts
+++ b/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithFunctionTypedArguments2.ts
@@ -26,7 +26,7 @@ function foo2<T, U>(x: T, cb: new(a: T) => U) {
     return new cb(x);
 }
 
-var r4 = foo2(1, i2); // string, instantiated generic
+var r4 = foo2(1, i2); // error
 var r4b = foo2(1, a); // any
 var r5 = foo2(1, i); // any
 var r6 = foo2<string, string>('', i2); // string
@@ -37,5 +37,5 @@ function foo3<T, U>(x: T, cb: new(a: T) => U, y: U) {
 
 var r7 = foo3(null, i, ''); // any
 var r7b = foo3(null, a, ''); // any
-var r8 = foo3(1, i2, 1); // {}
+var r8 = foo3(1, i2, 1); // error
 var r9 = foo3<string, string>('', i2, ''); // string
\ No newline at end of file
diff --git a/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts b/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts
index 54a7cf7ebc641..c37b2e31333ff 100644
--- a/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts
+++ b/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments2.ts
@@ -1,36 +1,73 @@
 // When a function expression is inferentially typed (section 4.9.3) and a type assigned to a parameter in that expression references type parameters for which inferences are being made, 
 // the corresponding inferred type arguments to become fixed and no further candidate inferences are made for them.
 
-function foo<T>(a: (x: T) => T, b: (x: T) => T) {
-    var r: (x: T) => T;
-    return r;
-}
+module onlyT {
+    function foo<T>(a: (x: T) => T, b: (x: T) => T) {
+        var r: (x: T) => T;
+        return r;
+    }
 
-var r1: (x: {}) => {} = foo((x: number) => 1, (x: string) => '');
+    var r1: (x: {}) => {} = foo((x: number) => 1, (x: string) => '');
 
-function other2<T extends Date>(x: T) {
-    var r7 = foo((a: T) => a, (b: T) => b); // T => T
-    // BUG 835518
-    var r9 = r7(new Date()); // should be ok
-    var r10 = r7(1); // error
-}
+    function other2<T extends Date>(x: T) {
+        var r7 = foo((a: T) => a, (b: T) => b); // T => T
+        // BUG 835518
+        var r9 = r7(new Date()); // should be ok
+        var r10 = r7(1); // error
+    }
 
-function foo2<T extends Date>(a: (x: T) => T, b: (x: T) => T) {
-    var r: (x: T) => T;
-    return r;
-}
+    function foo2<T extends Date>(a: (x: T) => T, b: (x: T) => T) {
+        var r: (x: T) => T;
+        return r;
+    }
 
-function other3<T extends RegExp>(x: T) {
-    var r7 = foo2((a: T) => a, (b: T) => b); // error
-    var r7b = foo2((a) => a, (b) => b); // valid, T is inferred to be Date
-}
+    function other3<T extends RegExp>(x: T) {
+        var r7 = foo2((a: T) => a, (b: T) => b); // error
+        var r7b = foo2((a) => a, (b) => b); // valid, T is inferred to be Date
+    }
+
+    enum E { A }
+    enum F { A }
 
-enum E { A }
-enum F { A }
+    function foo3<T>(x: T, a: (x: T) => T, b: (x: T) => T) {
+        var r: (x: T) => T;
+        return r;
+    }
 
-function foo3<T>(x: T, a: (x: T) => T, b: (x: T) => T) {
-    var r: (x: T) => T;
-    return r;
+    var r7 = foo3(E.A, (x) => E.A, (x) => F.A); // error
 }
 
-var r7 = foo3(E.A, (x) => E.A, (x) => F.A); // error
\ No newline at end of file
+module TU {
+    function foo<T, U>(a: (x: T) => T, b: (x: U) => U) {
+        var r: (x: T) => T;
+        return r;
+    }
+
+    var r1: (x: {}) => {} = foo((x: number) => 1, (x: string) => '');
+
+    function other2<T extends Date>(x: T) {
+        var r7 = foo((a: T) => a, (b: T) => b); 
+        var r9 = r7(new Date()); 
+        var r10 = r7(1); 
+    }
+
+    function foo2<T extends Date, U extends Date>(a: (x: T) => T, b: (x: U) => U) {
+        var r: (x: T) => T;
+        return r;
+    }
+
+    function other3<T extends RegExp>(x: T) {
+        var r7 = foo2((a: T) => a, (b: T) => b); 
+        var r7b = foo2((a) => a, (b) => b); 
+    }
+
+    enum E { A }
+    enum F { A }
+
+    function foo3<T>(x: T, a: (x: T) => T, b: (x: U) => U) {
+        var r: (x: T) => T;
+        return r;
+    }
+
+    var r7 = foo3(E.A, (x) => E.A, (x) => F.A);
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments3.ts b/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments3.ts
index 65f22a3fd3f12..82b917efa3e27 100644
--- a/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments3.ts
+++ b/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithGenericSignatureArguments3.ts
@@ -29,5 +29,5 @@ var r9 = foo2(null, (x) => '', (x) => ''); // any => any
 var r10 = foo2(null, (x: Object) => '', (x: string) => ''); // Object => Object
 
 var x: (a: string) => boolean;
-var r11 = foo2(x, (a1: (y: string) => string) => (n: Object) => 1, (a2: (z: string) => string) => 2); // {} => {}
-var r12 = foo2(x, (a1: (y: string) => boolean) => (n: Object) => 1, (a2: (z: string) => boolean) => 2); // (string => boolean) => {}
\ No newline at end of file
+var r11 = foo2(x, (a1: (y: string) => string) => (n: Object) => 1, (a2: (z: string) => string) => 2); // error
+var r12 = foo2(x, (a1: (y: string) => boolean) => (n: Object) => 1, (a2: (z: string) => boolean) => 2); // error
\ No newline at end of file
diff --git a/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObjectLiteralArgs.ts b/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObjectLiteralArgs.ts
index 1e5976b33e5a7..75b0462b68934 100644
--- a/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObjectLiteralArgs.ts
+++ b/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithObjectLiteralArgs.ts
@@ -2,7 +2,7 @@ function foo<T>(x: { bar: T; baz: T }) {
     return x;
 }
 
-var r = foo({ bar: 1, baz: '' }); // T = {}
+var r = foo({ bar: 1, baz: '' }); // error
 var r2 = foo({ bar: 1, baz: 1 }); // T = number
 var r3 = foo({ bar: foo, baz: foo }); // T = typeof foo
 var r4 = foo<Object>({ bar: 1, baz: '' }); // T = Object
\ No newline at end of file
diff --git a/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithOverloadedConstructorTypedArguments.ts b/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithOverloadedConstructorTypedArguments.ts
index 8bb5d234bb5c7..527286e6ee220 100644
--- a/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithOverloadedConstructorTypedArguments.ts
+++ b/tests/cases/conformance/types/typeRelationships/typeInference/genericCallWithOverloadedConstructorTypedArguments.ts
@@ -33,7 +33,7 @@ module GenericParameter {
         return cb;
     }
 
-    var r8 = foo6(a); // new{} => string; new(x:{}, y?:{}) => string
+    var r8 = foo6(a); // error
     var r9 = foo6(b); // new any => string; new(x:any, y?:any) => string
 
     function foo7<T>(x:T, cb: { new(x: T): string; new(x: T, y?: T): string }) {
diff --git a/tests/cases/conformance/types/typeRelationships/typeInference/genericClassWithFunctionTypedMemberArguments.ts b/tests/cases/conformance/types/typeRelationships/typeInference/genericClassWithFunctionTypedMemberArguments.ts
index a3b02eaf4e415..f429cd5169d69 100644
--- a/tests/cases/conformance/types/typeRelationships/typeInference/genericClassWithFunctionTypedMemberArguments.ts
+++ b/tests/cases/conformance/types/typeRelationships/typeInference/genericClassWithFunctionTypedMemberArguments.ts
@@ -54,11 +54,11 @@ module WithCandidates {
     var c3: C3<number, string>;
 
     function other<T, U>(t: T, u: U) {
-        var r10 = c.foo2(1, (x: T) => ''); // string, non-generic signature allows inferences to be made
+        var r10 = c.foo2(1, (x: T) => ''); // error
         var r10 = c.foo2(1, (x) => ''); // string
 
-        var r11 = c3.foo3(1, (x: T) => '', ''); // string
-        var r11b = c3.foo3(1, (x: T) => '', 1); // {}
-        var r12 = c3.foo3(1, function (a) { return '' }, 1); // {}
+        var r11 = c3.foo3(1, (x: T) => '', ''); // error
+        var r11b = c3.foo3(1, (x: T) => '', 1); // error
+        var r12 = c3.foo3(1, function (a) { return '' }, 1); // error
     }
 }
\ No newline at end of file
diff --git a/tests/cases/fourslash/bestCommonTypeObjectLiterals1.ts b/tests/cases/fourslash/bestCommonTypeObjectLiterals1.ts
index 1632fff5df875..917ed526d699e 100644
--- a/tests/cases/fourslash/bestCommonTypeObjectLiterals1.ts
+++ b/tests/cases/fourslash/bestCommonTypeObjectLiterals1.ts
@@ -28,10 +28,19 @@ goTo.marker('2');
 verify.quickInfoIs('(var) c1: {\n    name: string;\n    age: number;\n}[]');
 
 goTo.marker('3');
-verify.quickInfoIs('(var) c2: {}[]');
+verify.quickInfoIs('(var) c2: Array<{\n\
+    name: string;\n\
+    age: number;\n\
+    address: string;\n\
+} | {\n\
+    name: string;\n\
+    age: number;\n\
+    dob: Date;\n\
+}>');
 
 goTo.marker('4');
 verify.quickInfoIs('(var) c2a: {\n    name: string;\n    age: number;\n}[]');
 
 goTo.marker('5');
-verify.quickInfoIs('(var) c3: I[]');
\ No newline at end of file
+verify.quickInfoIs('(var) c3: I[]');
+
diff --git a/tests/cases/fourslash/completionEntryForUnionProperty.ts b/tests/cases/fourslash/completionEntryForUnionProperty.ts
new file mode 100644
index 0000000000000..bc0f9405a1ba8
--- /dev/null
+++ b/tests/cases/fourslash/completionEntryForUnionProperty.ts
@@ -0,0 +1,20 @@
+///<reference path="fourslash.ts" />
+
+////interface One {
+////    commonProperty: number;
+////    commonFunction(): number;
+////}
+////
+////interface Two {
+////    commonProperty: string
+////    commonFunction(): number;
+////}
+////
+////var x : One | Two;
+////
+////x./**/
+
+goTo.marker();
+verify.memberListContains("commonProperty", "(property) commonProperty: string | number");
+verify.memberListContains("commonFunction", "(method) commonFunction(): number");
+verify.memberListCount(2);
\ No newline at end of file
diff --git a/tests/cases/fourslash/completionEntryForUnionProperty2.ts b/tests/cases/fourslash/completionEntryForUnionProperty2.ts
new file mode 100644
index 0000000000000..b32e6d0534584
--- /dev/null
+++ b/tests/cases/fourslash/completionEntryForUnionProperty2.ts
@@ -0,0 +1,19 @@
+///<reference path="fourslash.ts" />
+
+////interface One {
+////    commonProperty: number;
+////    commonFunction(): number;
+////}
+////
+////interface Two {
+////    commonProperty: string
+////    commonFunction(): number;
+////}
+////
+////var x : One | Two;
+////
+////x.commonProperty./**/
+
+goTo.marker();
+verify.memberListContains("toString", "(method) toString(): string");
+verify.memberListCount(1);
\ No newline at end of file
diff --git a/tests/cases/fourslash/contextualTypingOfArrayLiterals1.ts b/tests/cases/fourslash/contextualTypingOfArrayLiterals1.ts
index 9e59d21c53b5f..128f801300b50 100644
--- a/tests/cases/fourslash/contextualTypingOfArrayLiterals1.ts
+++ b/tests/cases/fourslash/contextualTypingOfArrayLiterals1.ts
@@ -43,7 +43,7 @@ goTo.marker('4');
 verify.quickInfoIs('(var) r4: C');
 
 goTo.marker('5');
-verify.quickInfoIs('(var) x5: {\n    name: string;\n    age: number;\n}[]');
+verify.quickInfoIs('(var) x5: C[]');
 
 goTo.marker('6');
-verify.quickInfoIs('(var) r5: {\n    name: string;\n    age: number;\n}');
\ No newline at end of file
+verify.quickInfoIs('(var) r5: C');
\ No newline at end of file
diff --git a/tests/cases/fourslash/genericTypeArgumentInference1.ts b/tests/cases/fourslash/genericTypeArgumentInference1.ts
index 96d603b939cbb..eadec7ad0ce27 100644
--- a/tests/cases/fourslash/genericTypeArgumentInference1.ts
+++ b/tests/cases/fourslash/genericTypeArgumentInference1.ts
@@ -18,9 +18,9 @@
 ////var /*4*/r4 = _./*41*/all([<any>true], _.identity);
 
 goTo.marker('1');
-verify.quickInfoIs('(var) r: {}');
+verify.quickInfoIs('(var) r: string | number | boolean');
 goTo.marker('11');
-verify.quickInfoIs('(method) Underscore.Static.all<{}>(list: {}[], iterator?: Underscore.Iterator<{}, boolean>, context?: any): {}');
+verify.quickInfoIs('(method) Underscore.Static.all<string | number | boolean>(list: Array<string | number | boolean>, iterator?: Underscore.Iterator<string | number | boolean, boolean>, context?: any): string | number | boolean');
 
 goTo.marker('2');
 verify.quickInfoIs('(var) r2: boolean');
@@ -37,4 +37,4 @@ verify.quickInfoIs('(var) r4: any');
 goTo.marker('41');
 verify.quickInfoIs('(method) Underscore.Static.all<any>(list: any[], iterator?: Underscore.Iterator<any, boolean>, context?: any): any');
 
-verify.numberOfErrorsInCurrentFile(0);
+verify.numberOfErrorsInCurrentFile(0);
\ No newline at end of file
diff --git a/tests/cases/fourslash/genericTypeArgumentInference2.ts b/tests/cases/fourslash/genericTypeArgumentInference2.ts
index 0ae5114b1338f..a660675c51e06 100644
--- a/tests/cases/fourslash/genericTypeArgumentInference2.ts
+++ b/tests/cases/fourslash/genericTypeArgumentInference2.ts
@@ -18,9 +18,9 @@
 ////var /*4*/r4 = _./*41*/all([<any>true], _.identity);
 
 goTo.marker('1');
-verify.quickInfoIs('(var) r: {}');
+verify.quickInfoIs('(var) r: string | number | boolean');
 goTo.marker('11');
-verify.quickInfoIs('(method) Underscore.Static.all<{}>(list: {}[], iterator?: Underscore.Iterator<{}, boolean>, context?: any): {}');
+verify.quickInfoIs('(method) Underscore.Static.all<string | number | boolean>(list: Array<string | number | boolean>, iterator?: Underscore.Iterator<string | number | boolean, boolean>, context?: any): string | number | boolean');
 
 goTo.marker('2');
 verify.quickInfoIs('(var) r2: boolean');
diff --git a/tests/cases/fourslash/goToDefinitionUnionTypeProperty.ts b/tests/cases/fourslash/goToDefinitionUnionTypeProperty.ts
new file mode 100644
index 0000000000000..74b5e2aad8a9f
--- /dev/null
+++ b/tests/cases/fourslash/goToDefinitionUnionTypeProperty.ts
@@ -0,0 +1,24 @@
+/// <reference path='fourslash.ts' />
+
+////interface One {
+////    /*propertyDefinition1*/commonProperty: number;
+////    commonFunction(): number;
+////}
+////
+////interface Two {
+////    /*propertyDefinition2*/commonProperty: string
+////    commonFunction(): number;
+////}
+////
+////var x : One | Two;
+////
+////x./*propertyReference*/commonProperty;
+////x./*3*/commonFunction;
+
+goTo.marker("propertyReference");
+goTo.definition(0);
+verify.caretAtMarker("propertyDefinition1");
+
+goTo.marker("propertyReference");
+goTo.definition(1);
+verify.caretAtMarker("propertyDefinition2");
diff --git a/tests/cases/fourslash/goToDefinitionUnionTypeProperty2.ts b/tests/cases/fourslash/goToDefinitionUnionTypeProperty2.ts
new file mode 100644
index 0000000000000..6536bb76e7dda
--- /dev/null
+++ b/tests/cases/fourslash/goToDefinitionUnionTypeProperty2.ts
@@ -0,0 +1,25 @@
+/// <reference path='fourslash.ts' />
+////interface HasAOrB {
+////    /*propertyDefinition1*/a: string;
+////    b: string;
+////}
+////
+////interface One {
+////    common: { /*propertyDefinition2*/a : number; };
+////}
+////
+////interface Two {
+////    common: HasAOrB;
+////}
+////
+////var x : One | Two;
+////
+////x.common./*propertyReference*/a;
+
+goTo.marker("propertyReference");
+goTo.definition(0);
+verify.caretAtMarker("propertyDefinition1");
+
+goTo.marker("propertyReference");
+goTo.definition(1);
+verify.caretAtMarker("propertyDefinition2");
diff --git a/tests/cases/fourslash/quickinfoForUnionProperty.ts b/tests/cases/fourslash/quickinfoForUnionProperty.ts
new file mode 100644
index 0000000000000..b5c7dc0a01c0f
--- /dev/null
+++ b/tests/cases/fourslash/quickinfoForUnionProperty.ts
@@ -0,0 +1,27 @@
+/// <reference path="fourslash.ts"/>
+
+////interface One {
+////    commonProperty: number;
+////    commonFunction(): number;
+////}
+////
+////interface Two {
+////    commonProperty: string
+////    commonFunction(): number;
+////}
+////
+////var /*1*/x : One | Two;
+////
+////x./*2*/commonProperty;
+////x./*3*/commonFunction;
+
+
+goTo.marker("1");
+verify.quickInfoIs('(var) x: One | Two');
+
+
+goTo.marker("2");
+verify.quickInfoIs('(property) commonProperty: string | number');
+
+goTo.marker("3");
+verify.quickInfoIs('(method) commonFunction(): number');
diff --git a/tests/cases/fourslash/referencesForContextuallyTypedObjectLiteralProperties.ts b/tests/cases/fourslash/referencesForContextuallyTypedObjectLiteralProperties.ts
index f21f6cc3936e2..15dd57200194c 100644
--- a/tests/cases/fourslash/referencesForContextuallyTypedObjectLiteralProperties.ts
+++ b/tests/cases/fourslash/referencesForContextuallyTypedObjectLiteralProperties.ts
@@ -1,5 +1,5 @@
-/// <reference path='fourslash.ts'/>
-
+/// <reference path='fourslash.ts'/>
+
 ////interface IFoo { /*1*/xy: number; }
 ////
 ////// Assignment
@@ -23,10 +23,10 @@
 ////var w: IFoo = { /*4*/xy: undefined };
 ////
 ////// Untped -- should not be included
-////var u = { xy: 0 };
-
-
-test.markers().forEach((m) => {
-    goTo.position(m.position, m.fileName);
-    verify.referencesCountIs(9);
-});
+////var u = { xy: 0 };
+
+
+test.markers().forEach((m) => {
+    goTo.position(m.position, m.fileName);
+    verify.referencesCountIs(9);
+});
diff --git a/tests/cases/fourslash/referencesForContextuallyTypedUnionProperties.ts b/tests/cases/fourslash/referencesForContextuallyTypedUnionProperties.ts
new file mode 100644
index 0000000000000..f9c479de7698f
--- /dev/null
+++ b/tests/cases/fourslash/referencesForContextuallyTypedUnionProperties.ts
@@ -0,0 +1,40 @@
+/// <reference path='fourslash.ts'/>
+
+////interface A {
+////    a: number;
+////    common: string;
+////}
+////
+////interface B {
+////    b: number;
+////    common: number;
+////}
+////
+////// Assignment
+////var v1: A | B = { a: 0, /*1*/common: "" };
+////var v2: A | B = { b: 0, /*2*/common: 3 };
+////
+////// Function call
+////function consumer(f:  A | B) { }
+////consumer({ a: 0, b: 0, /*3*/common: 1 });
+////
+////// Type cast 
+////var c = <A | B> { /*4*/common: 0, b: 0 };
+////
+////// Array literal
+////var ar: Array<A|B> = [{ a: 0, /*5*/common: "" }, { b: 0, /*6*/common: 0 }];
+////
+////// Nested object literal
+////var ob: { aorb: A|B } = { aorb: { b: 0, /*7*/common: 0 } };
+////
+////// Widened type
+////var w: A|B = { a:0, /*8*/common: undefined };
+////
+////// Untped -- should not be included
+////var u1 = { a: 0, b: 0, common: "" };
+////var u2 = { b: 0, common: 0 };
+
+test.markers().forEach((m) => {
+    goTo.position(m.position, m.fileName);
+    verify.referencesCountIs(10); // 8 contextually typed common, and 2 in definition (A.common, B.common)
+});
diff --git a/tests/cases/fourslash/referencesForContextuallyTypedUnionProperties2.ts b/tests/cases/fourslash/referencesForContextuallyTypedUnionProperties2.ts
new file mode 100644
index 0000000000000..bbcc482a6e7ed
--- /dev/null
+++ b/tests/cases/fourslash/referencesForContextuallyTypedUnionProperties2.ts
@@ -0,0 +1,40 @@
+/// <reference path='fourslash.ts'/>
+
+////interface A {
+////    a: number;
+////    common: string;
+////}
+////
+////interface B {
+////    /*1*/b: number;
+////    common: number;
+////}
+////
+////// Assignment
+////var v1: A | B = { a: 0, common: "" };
+////var v2: A | B = { /*2*/b: 0, common: 3 };
+////
+////// Function call
+////function consumer(f:  A | B) { }
+////consumer({ a: 0, /*3*/b: 0, common: 1 });
+////
+////// Type cast 
+////var c = <A | B> { common: 0, /*4*/b: 0 };
+////
+////// Array literal
+////var ar: Array<A|B> = [{ a: 0, common: "" }, { /*5*/b: 0, common: 0 }];
+////
+////// Nested object literal
+////var ob: { aorb: A|B } = { aorb: { /*6*/b: 0, common: 0 } };
+////
+////// Widened type
+////var w: A|B = { /*7*/b:undefined, common: undefined };
+////
+////// Untped -- should not be included
+////var u1 = { a: 0, b: 0, common: "" };
+////var u2 = { b: 0, common: 0 };
+
+test.markers().forEach((m) => {
+    goTo.position(m.position, m.fileName);
+    verify.referencesCountIs(7); 
+});
diff --git a/tests/cases/fourslash/referencesForUnionProperties.ts b/tests/cases/fourslash/referencesForUnionProperties.ts
new file mode 100644
index 0000000000000..f4ef85e8e4efb
--- /dev/null
+++ b/tests/cases/fourslash/referencesForUnionProperties.ts
@@ -0,0 +1,35 @@
+/// <reference path='fourslash.ts'/>
+
+////interface One {
+////    common: { /*1*/a: number; };
+////}
+////
+////interface Base {
+////    /*2*/a: string;
+////    b: string;
+////}
+////
+////interface HasAOrB extends Base {
+////    /*3*/a: string;
+////    b: string;
+////}
+////
+////interface Two {
+////    common: HasAOrB;
+////}
+////
+////var x : One | Two;
+////
+////x.common./*4*/a;
+
+goTo.marker("1");
+verify.referencesCountIs(2); // One.common.a, x.common.a
+
+goTo.marker("2");
+verify.referencesCountIs(3); // Base.a, HasAOrB.a, x.common.a
+
+goTo.marker("3");
+verify.referencesCountIs(3); // Base.a, HasAOrB.a, x.common.a
+
+goTo.marker("4");
+verify.referencesCountIs(4); // One.common.a, Base.a, HasAOrB.a, x.common.a
\ No newline at end of file