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

src/compiler/binder.ts

@@ -518,15 +518,21 @@ namespace ts {
                 }
                 else {
                     declareSymbolAndAddToSymbolTable(node, SymbolFlags.ValueModule, SymbolFlags.ValueModuleExcludes);
-
-                    let currentModuleIsConstEnumOnly = state === ModuleInstanceState.ConstEnumOnly;
-                    if (node.symbol.constEnumOnlyModule === undefined) {
-                        // non-merged case - use the current state
-                        node.symbol.constEnumOnlyModule = currentModuleIsConstEnumOnly;
+                    if (node.symbol.flags & (SymbolFlags.Function | SymbolFlags.Class | SymbolFlags.RegularEnum)) {
+                        // if module was already merged with some function, class or non-const enum
+                        // treat is a non-const-enum-only
+                        node.symbol.constEnumOnlyModule = false;
                     }
                     else {
-                        // merged case: module is const enum only if all its pieces are non-instantiated or const enum
-                        node.symbol.constEnumOnlyModule = node.symbol.constEnumOnlyModule && currentModuleIsConstEnumOnly;
+                        let currentModuleIsConstEnumOnly = state === ModuleInstanceState.ConstEnumOnly;
+                        if (node.symbol.constEnumOnlyModule === undefined) {
+                            // non-merged case - use the current state
+                            node.symbol.constEnumOnlyModule = currentModuleIsConstEnumOnly;
+                        }
+                        else {
+                            // merged case: module is const enum only if all its pieces are non-instantiated or const enum
+                            node.symbol.constEnumOnlyModule = node.symbol.constEnumOnlyModule && currentModuleIsConstEnumOnly;
+                        }
                     }
                 }
             }
@@ -1056,4 +1062,4 @@ namespace ts {
                 : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
         }
     }
-}
+}

src/compiler/checker.ts

@@ -59,7 +59,10 @@ namespace ts {
             isArgumentsSymbol: symbol => symbol === argumentsSymbol,
             getDiagnostics,
             getGlobalDiagnostics,
-            getTypeOfSymbolAtLocation,
+
+            // The language service will always care about the narrowed type of a symbol, because that is
+            // the type the language says the symbol should have.
+            getTypeOfSymbolAtLocation: getNarrowedTypeOfSymbol,
             getDeclaredTypeOfSymbol,
             getPropertiesOfType,
             getPropertyOfType,
@@ -69,7 +72,7 @@ namespace ts {
             getSymbolsInScope,
             getSymbolAtLocation,
             getShorthandAssignmentValueSymbol,
-            getTypeAtLocation,
+            getTypeAtLocation: getTypeOfNode,
             typeToString,
             getSymbolDisplayBuilder,
             symbolToString,
@@ -159,8 +162,9 @@ namespace ts {
         let emitAwaiter = false;
         let emitGenerator = false;
 
-        let resolutionTargets: Object[] = [];
+        let resolutionTargets: TypeSystemEntity[] = [];
         let resolutionResults: boolean[] = [];
+        let resolutionPropertyNames: TypeSystemPropertyName[] = [];
 
         let mergedSymbols: Symbol[] = [];
         let symbolLinks: SymbolLinks[] = [];
@@ -201,6 +205,15 @@ namespace ts {
         let assignableRelation: Map<RelationComparisonResult> = {};
         let identityRelation: Map<RelationComparisonResult> = {};
 
+        type TypeSystemEntity = Symbol | Type | Signature;
+
+        const enum TypeSystemPropertyName {
+            Type,
+            ResolvedBaseConstructorType,
+            DeclaredType,
+            ResolvedReturnType
+        }
+
         initializeTypeChecker();
 
         return checker;
@@ -1980,15 +1993,12 @@ namespace ts {
             }
 
             return _displayBuilder || (_displayBuilder = {
-                symbolToString: symbolToString,
-                typeToString: typeToString,
                 buildSymbolDisplay: buildSymbolDisplay,
                 buildTypeDisplay: buildTypeDisplay,
                 buildTypeParameterDisplay: buildTypeParameterDisplay,
                 buildParameterDisplay: buildParameterDisplay,
                 buildDisplayForParametersAndDelimiters: buildDisplayForParametersAndDelimiters,
                 buildDisplayForTypeParametersAndDelimiters: buildDisplayForTypeParametersAndDelimiters,
-                buildDisplayForTypeArgumentsAndDelimiters: buildDisplayForTypeArgumentsAndDelimiters,
                 buildTypeParameterDisplayFromSymbol: buildTypeParameterDisplayFromSymbol,
                 buildSignatureDisplay: buildSignatureDisplay,
                 buildReturnTypeDisplay: buildReturnTypeDisplay
@@ -2177,35 +2187,69 @@ namespace ts {
             }
         }
 
-        // Push an entry on the type resolution stack. If an entry with the given target is not already on the stack,
-        // a new entry with that target and an associated result value of true is pushed on the stack, and the value
-        // true is returned. Otherwise, a circularity has occurred and the result values of the existing entry and
-        // all entries pushed after it are changed to false, and the value false is returned. The target object provides
-        // a unique identity for a particular type resolution result: Symbol instances are used to track resolution of
-        // SymbolLinks.type, SymbolLinks instances are used to track resolution of SymbolLinks.declaredType, and
-        // Signature instances are used to track resolution of Signature.resolvedReturnType.
-        function pushTypeResolution(target: Object): boolean {
-            let i = 0;
-            let count = resolutionTargets.length;
-            while (i < count && resolutionTargets[i] !== target) {
-                i++;
-            }
-            if (i < count) {
-                do {
-                    resolutionResults[i++] = false;
+        /**
+         * Push an entry on the type resolution stack. If an entry with the given target and the given property name
+         * is already on the stack, and no entries in between already have a type, then a circularity has occurred. 
+         * In this case, the result values of the existing entry and all entries pushed after it are changed to false,
+         * and the value false is returned. Otherwise, the new entry is just pushed onto the stack, and true is returned.
+         * In order to see if the same query has already been done before, the target object and the propertyName both
+         * must match the one passed in.
+         *
+         * @param target The symbol, type, or signature whose type is being queried
+         * @param propertyName The property name that should be used to query the target for its type
+         */
+        function pushTypeResolution(target: TypeSystemEntity, propertyName: TypeSystemPropertyName): boolean {
+            let resolutionCycleStartIndex = findResolutionCycleStartIndex(target, propertyName);
+            if (resolutionCycleStartIndex >= 0) {
+                // A cycle was found
+                let { length } = resolutionTargets;
+                for (let i = resolutionCycleStartIndex; i < length; i++) {
+                    resolutionResults[i] = false;
                 }
-                while (i < count);
                 return false;
             }
             resolutionTargets.push(target);
             resolutionResults.push(true);
+            resolutionPropertyNames.push(propertyName);
             return true;
         }
 
+        function findResolutionCycleStartIndex(target: TypeSystemEntity, propertyName: TypeSystemPropertyName): number {
+            for (let i = resolutionTargets.length - 1; i >= 0; i--) {
+                if (hasType(resolutionTargets[i], resolutionPropertyNames[i])) {
+                    return -1;
+                }
+                if (resolutionTargets[i] === target && resolutionPropertyNames[i] === propertyName) {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        function hasType(target: TypeSystemEntity, propertyName: TypeSystemPropertyName): Type {
+            if (propertyName === TypeSystemPropertyName.Type) {
+                return getSymbolLinks(<Symbol>target).type;
+            }
+            if (propertyName === TypeSystemPropertyName.DeclaredType) {
+                return getSymbolLinks(<Symbol>target).declaredType;
+            }
+            if (propertyName === TypeSystemPropertyName.ResolvedBaseConstructorType) {
+                Debug.assert(!!((<Type>target).flags & TypeFlags.Class));
+                return (<InterfaceType>target).resolvedBaseConstructorType;
+            }
+            if (propertyName === TypeSystemPropertyName.ResolvedReturnType) {
+                return (<Signature>target).resolvedReturnType;
+            }
+
+            Debug.fail("Unhandled TypeSystemPropertyName " + propertyName);
+        }
+
         // Pop an entry from the type resolution stack and return its associated result value. The result value will
         // be true if no circularities were detected, or false if a circularity was found.
         function popTypeResolution(): boolean {
             resolutionTargets.pop();
+            resolutionPropertyNames.pop();
             return resolutionResults.pop();
         }
 
@@ -2274,10 +2318,6 @@ namespace ts {
                 // fact an iterable or array (depending on target language).
                 let elementType = checkIteratedTypeOrElementType(parentType, pattern, /*allowStringInput*/ false);
                 if (!declaration.dotDotDotToken) {
-                    if (isTypeAny(elementType)) {
-                        return elementType;
-                    }
-
                     // Use specific property type when parent is a tuple or numeric index type when parent is an array
                     let propName = "" + indexOf(pattern.elements, declaration);
                     type = isTupleLikeType(parentType)
@@ -2307,6 +2347,7 @@ namespace ts {
             if (declaration.parent.parent.kind === SyntaxKind.ForInStatement) {
                 return anyType;
             }
+
             if (declaration.parent.parent.kind === SyntaxKind.ForOfStatement) {
                 // checkRightHandSideOfForOf will return undefined if the for-of expression type was
                 // missing properties/signatures required to get its iteratedType (like
@@ -2314,13 +2355,16 @@ namespace ts {
                 // or it may have led to an error inside getElementTypeOfIterable.
                 return checkRightHandSideOfForOf((<ForOfStatement>declaration.parent.parent).expression) || anyType;
             }
+
             if (isBindingPattern(declaration.parent)) {
                 return getTypeForBindingElement(<BindingElement>declaration);
             }
+            
             // Use type from type annotation if one is present
             if (declaration.type) {
                 return getTypeFromTypeNode(declaration.type);
             }
+
             if (declaration.kind === SyntaxKind.Parameter) {
                 let func = <FunctionLikeDeclaration>declaration.parent;
                 // For a parameter of a set accessor, use the type of the get accessor if one is present
@@ -2336,14 +2380,22 @@ namespace ts {
                     return type;
                 }
             }
+            
             // Use the type of the initializer expression if one is present
             if (declaration.initializer) {
                 return checkExpressionCached(declaration.initializer);
             }
+            
             // If it is a short-hand property assignment, use the type of the identifier
             if (declaration.kind === SyntaxKind.ShorthandPropertyAssignment) {
                 return checkIdentifier(<Identifier>declaration.name);
             }
+
+            // If the declaration specifies a binding pattern, use the type implied by the binding pattern
+            if (isBindingPattern(declaration.name)) {
+                return getTypeFromBindingPattern(<BindingPattern>declaration.name);
+            }
+
             // No type specified and nothing can be inferred
             return undefined;
         }
@@ -2429,13 +2481,10 @@ namespace ts {
                 // tools see the actual type.
                 return declaration.kind !== SyntaxKind.PropertyAssignment ? getWidenedType(type) : type;
             }
-            // If no type was specified and nothing could be inferred, and if the declaration specifies a binding pattern, use
-            // the type implied by the binding pattern
-            if (isBindingPattern(declaration.name)) {
-                return getTypeFromBindingPattern(<BindingPattern>declaration.name);
-            }
+            
             // Rest parameters default to type any[], other parameters default to type any
             type = declaration.dotDotDotToken ? anyArrayType : anyType;
+            
             // Report implicit any errors unless this is a private property within an ambient declaration
             if (reportErrors && compilerOptions.noImplicitAny) {
                 let root = getRootDeclaration(declaration);
@@ -2463,7 +2512,7 @@ namespace ts {
                     return links.type = checkExpression((<ExportAssignment>declaration).expression);
                 }
                 // Handle variable, parameter or property
-                if (!pushTypeResolution(symbol)) {
+                if (!pushTypeResolution(symbol, TypeSystemPropertyName.Type)) {
                     return unknownType;
                 }
                 let type = getWidenedTypeForVariableLikeDeclaration(<VariableLikeDeclaration>declaration, /*reportErrors*/ true);
@@ -2504,7 +2553,7 @@ namespace ts {
         function getTypeOfAccessors(symbol: Symbol): Type {
             let links = getSymbolLinks(symbol);
             if (!links.type) {
-                if (!pushTypeResolution(symbol)) {
+                if (!pushTypeResolution(symbol, TypeSystemPropertyName.Type)) {
                     return unknownType;
                 }
                 let getter = <AccessorDeclaration>getDeclarationOfKind(symbol, SyntaxKind.GetAccessor);
@@ -2720,7 +2769,7 @@ namespace ts {
                 if (!baseTypeNode) {
                     return type.resolvedBaseConstructorType = undefinedType;
                 }
-                if (!pushTypeResolution(type)) {
+                if (!pushTypeResolution(type, TypeSystemPropertyName.ResolvedBaseConstructorType)) {
                     return unknownType;
                 }
                 let baseConstructorType = checkExpression(baseTypeNode.expression);
@@ -2847,7 +2896,7 @@ namespace ts {
             if (!links.declaredType) {
                 // Note that we use the links object as the target here because the symbol object is used as the unique
                 // identity for resolution of the 'type' property in SymbolLinks.
-                if (!pushTypeResolution(links)) {
+                if (!pushTypeResolution(symbol, TypeSystemPropertyName.DeclaredType)) {
                     return unknownType;
                 }
                 let declaration = <TypeAliasDeclaration>getDeclarationOfKind(symbol, SyntaxKind.TypeAliasDeclaration);
@@ -3063,44 +3112,57 @@ namespace ts {
             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 (let i = 0; i < s.length; i++) {
-                if (!compareSignatures(s[i], t[i], /*compareReturnTypes*/ false, compareTypes)) {
-                    return false;
+        function findMatchingSignature(signature: Signature, signatureList: Signature[]): Signature {
+            for (let s of signatureList) {
+                // Only signatures with no type parameters may differ in return types
+                if (compareSignatures(signature, s, /*compareReturnTypes*/ !!signature.typeParameters, compareTypes)) {
+                    return s;
                 }
             }
-            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[] {
-            let signatureLists = map(types, t => getSignaturesOfType(t, kind));
-            let signatures = signatureLists[0];
-            for (let signature of signatures) {
-                if (signature.typeParameters) {
-                    return emptyArray;
-                }
-            }
+        function findMatchingSignatures(signature: Signature, signatureLists: Signature[][]): Signature[] {
+            let result: Signature[] = undefined;
             for (let i = 1; i < signatureLists.length; i++) {
-                if (!signatureListsIdentical(signatures, signatureLists[i])) {
-                    return emptyArray;
+                let match = findMatchingSignature(signature, signatureLists[i]);
+                if (!match) {
+                    return undefined;
+                }
+                if (!result) {
+                    result = [signature];
+                }
+                if (match !== signature) {
+                    result.push(match);
                 }
-            }
-            let result = map(signatures, cloneSignature);
-            for (var i = 0; i < result.length; i++) {
-                let s = result[i];
-                // Clear resolved return type we possibly got from cloneSignature
-                s.resolvedReturnType = undefined;
-                s.unionSignatures = map(signatureLists, signatures => signatures[i]);
             }
             return result;
         }
 
+        // The signatures of a union type are those signatures that are present and identical in each of the
+        // constituent types, except that non-generic signatures may differ in return types. When signatures
+        // differ in return types, the resulting return type is the union of the constituent return types.
+        function getUnionSignatures(types: Type[], kind: SignatureKind): Signature[] {
+            let signatureLists = map(types, t => getSignaturesOfType(t, kind));
+            let result: Signature[] = undefined;
+            for (let source of signatureLists[0]) {
+                let unionSignatures = findMatchingSignatures(source, signatureLists);
+                if (unionSignatures) {
+                    let signature: Signature = undefined;
+                    if (unionSignatures.length === 1 || source.typeParameters) {
+                        signature = source;
+                    }
+                    else {
+                        signature = cloneSignature(source);
+                        // Clear resolved return type we possibly got from cloneSignature
+                        signature.resolvedReturnType = undefined;
+                        signature.unionSignatures = unionSignatures;
+                    }
+                    (result || (result = [])).push(signature);
+                }
+            }
+            return result || emptyArray;
+        }
+
         function getUnionIndexType(types: Type[], kind: IndexKind): Type {
             let indexTypes: Type[] = [];
             for (let type of types) {
@@ -3258,9 +3320,6 @@ namespace ts {
          * type itself. Note that the apparent type of a union type is the union type itself.
          */
         function getApparentType(type: Type): Type {
-            if (type.flags & TypeFlags.Union) {
-                type = getReducedTypeOfUnionType(<UnionType>type);
-            }
             if (type.flags & TypeFlags.TypeParameter) {
                 do {
                     type = getConstraintOfTypeParameter(<TypeParameter>type);
@@ -3365,6 +3424,29 @@ namespace ts {
             return undefined;
         }
 
+        // Check if a property with the given name is known anywhere in the given type. In an object
+        // type, a property is considered known if the object type is empty, if it has any index
+        // signatures, or if the property is actually declared in the type. In a union or intersection
+        // type, a property is considered known if it is known in any constituent type.
+        function isKnownProperty(type: Type, name: string): boolean {
+            if (type.flags & TypeFlags.ObjectType && type !== globalObjectType) {
+                var resolved = resolveStructuredTypeMembers(type);
+                return !!(resolved.properties.length === 0 ||
+                    resolved.stringIndexType ||
+                    resolved.numberIndexType ||
+                    getPropertyOfType(type, name));
+            }
+            if (type.flags & TypeFlags.UnionOrIntersection) {
+                for (let t of (<UnionOrIntersectionType>type).types) {
+                    if (isKnownProperty(t, name)) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            return true;
+        }
+
         function getSignaturesOfStructuredType(type: Type, kind: SignatureKind): Signature[] {
             if (type.flags & TypeFlags.StructuredType) {
                 let resolved = resolveStructuredTypeMembers(<ObjectType>type);
@@ -3534,7 +3616,7 @@ namespace ts {
 
         function getReturnTypeOfSignature(signature: Signature): Type {
             if (!signature.resolvedReturnType) {
-                if (!pushTypeResolution(signature)) {
+                if (!pushTypeResolution(signature, TypeSystemPropertyName.ResolvedReturnType)) {
                     return unknownType;
                 }
                 let type: Type;
@@ -3974,26 +4056,79 @@ namespace ts {
             }
         }
 
-        function isSubtypeOfAny(candidate: Type, types: Type[]): boolean {
+        function isObjectLiteralTypeDuplicateOf(source: ObjectType, target: ObjectType): boolean {
+            let sourceProperties = getPropertiesOfObjectType(source);
+            let targetProperties = getPropertiesOfObjectType(target);
+            if (sourceProperties.length !== targetProperties.length) {
+                return false;
+            }
+            for (let sourceProp of sourceProperties) {
+                let targetProp = getPropertyOfObjectType(target, sourceProp.name);
+                if (!targetProp ||
+                    getDeclarationFlagsFromSymbol(targetProp) & (NodeFlags.Private | NodeFlags.Protected) ||
+                    !isTypeDuplicateOf(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp))) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        function isTupleTypeDuplicateOf(source: TupleType, target: TupleType): boolean {
+            let sourceTypes = source.elementTypes;
+            let targetTypes = target.elementTypes;
+            if (sourceTypes.length !== targetTypes.length) {
+                return false;
+            }
+            for (var i = 0; i < sourceTypes.length; i++) {
+                if (!isTypeDuplicateOf(sourceTypes[i], targetTypes[i])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        // Returns true if the source type is a duplicate of the target type. A source type is a duplicate of
+        // a target type if the the two are identical, with the exception that the source type may have null or
+        // undefined in places where the target type doesn't. This is by design an asymmetric relationship.
+        function isTypeDuplicateOf(source: Type, target: Type): boolean {
+            if (source === target) {
+                return true;
+            }
+            if (source.flags & TypeFlags.Undefined || source.flags & TypeFlags.Null && !(target.flags & TypeFlags.Undefined)) {
+                return true;
+            }
+            if (source.flags & TypeFlags.ObjectLiteral && target.flags & TypeFlags.ObjectType) {
+                return isObjectLiteralTypeDuplicateOf(<ObjectType>source, <ObjectType>target);
+            }
+            if (isArrayType(source) && isArrayType(target)) {
+                return isTypeDuplicateOf((<TypeReference>source).typeArguments[0], (<TypeReference>target).typeArguments[0]);
+            }
+            if (isTupleType(source) && isTupleType(target)) {
+                return isTupleTypeDuplicateOf(<TupleType>source, <TupleType>target);
+            }
+            return isTypeIdenticalTo(source, target);
+        }
+
+        function isTypeDuplicateOfSomeType(candidate: Type, types: Type[]): boolean {
             for (let type of types) {
-                if (candidate !== type && isTypeSubtypeOf(candidate, type)) {
+                if (candidate !== type && isTypeDuplicateOf(candidate, type)) {
                     return true;
                 }
             }
             return false;
         }
 
-        function removeSubtypes(types: Type[]) {
+        function removeDuplicateTypes(types: Type[]) {
             let i = types.length;
             while (i > 0) {
                 i--;
-                if (isSubtypeOfAny(types[i], types)) {
+                if (isTypeDuplicateOfSomeType(types[i], types)) {
                     types.splice(i, 1);
                 }
             }
         }
 
-        function containsTypeAny(types: Type[]) {
+        function containsTypeAny(types: Type[]): boolean {
             for (let type of types) {
                 if (isTypeAny(type)) {
                     return true;
@@ -4012,30 +4147,26 @@ namespace ts {
             }
         }
 
-        function compareTypeIds(type1: Type, type2: Type): number {
-            return type1.id - type2.id;
-        }
-
-        // The noSubtypeReduction flag is there because it isn't possible to always do subtype reduction. The flag
-        // is true when creating a union type from a type node and when instantiating a union type. In both of those
-        // cases subtype reduction has to be deferred to properly support recursive union types. For example, a
-        // type alias of the form "type Item = string | (() => Item)" cannot be reduced during its declaration.
-        function getUnionType(types: Type[], noSubtypeReduction?: boolean): Type {
+        // We always deduplicate the constituent type set based on object identity, but we'll also deduplicate
+        // based on the structure of the types unless the noDeduplication flag is true, which is the case when
+        // creating a union type from a type node and when instantiating a union type. In both of those cases,
+        // structural deduplication has to be deferred to properly support recursive union types. For example,
+        // a type of the form "type Item = string | (() => Item)" cannot be deduplicated during its declaration.
+        function getUnionType(types: Type[], noDeduplication?: boolean): Type {
             if (types.length === 0) {
                 return emptyObjectType;
             }
             let typeSet: Type[] = [];
             addTypesToSet(typeSet, types, TypeFlags.Union);
-            typeSet.sort(compareTypeIds);
-            if (noSubtypeReduction) {
-                if (containsTypeAny(typeSet)) {
-                    return anyType;
-                }
+            if (containsTypeAny(typeSet)) {
+                return anyType;
+            }
+            if (noDeduplication) {
                 removeAllButLast(typeSet, undefinedType);
                 removeAllButLast(typeSet, nullType);
             }
             else {
-                removeSubtypes(typeSet);
+                removeDuplicateTypes(typeSet);
             }
             if (typeSet.length === 1) {
                 return typeSet[0];
@@ -4045,38 +4176,19 @@ namespace ts {
             if (!type) {
                 type = unionTypes[id] = <UnionType>createObjectType(TypeFlags.Union | getWideningFlagsOfTypes(typeSet));
                 type.types = typeSet;
-                type.reducedType = noSubtypeReduction ? undefined : type;
             }
             return type;
         }
 
-        // Subtype reduction is basically an optimization we do to avoid excessively large union types, which take longer
-        // to process and look strange in quick info and error messages. Semantically there is no difference between the
-        // reduced type and the type itself. So, when we detect a circularity we simply say that the reduced type is the
-        // type itself.
-        function getReducedTypeOfUnionType(type: UnionType): Type {
-            if (!type.reducedType) {
-                type.reducedType = circularType;
-                let reducedType = getUnionType(type.types, /*noSubtypeReduction*/ false);
-                if (type.reducedType === circularType) {
-                    type.reducedType = reducedType;
-                }
-            }
-            else if (type.reducedType === circularType) {
-                type.reducedType = type;
-            }
-            return type.reducedType;
-        }
-
         function getTypeFromUnionTypeNode(node: UnionTypeNode): Type {
             let links = getNodeLinks(node);
             if (!links.resolvedType) {
-                links.resolvedType = getUnionType(map(node.types, getTypeFromTypeNode), /*noSubtypeReduction*/ true);
+                links.resolvedType = getUnionType(map(node.types, getTypeFromTypeNode), /*noDeduplication*/ true);
             }
             return links.resolvedType;
         }
 
-        // We do not perform supertype reduction on intersection types. Intersection types are created only by the &
+        // We do not perform structural deduplication on intersection types. Intersection types are created only by the &
         // type operator and we can't reduce those because we want to support recursive intersection types. For example,
         // a type alias of the form "type List<T> = T & { next: List<T> }" cannot be reduced during its declaration.
         // Also, unlike union types, the order of the constituent types is preserved in order that overload resolution
@@ -4179,7 +4291,7 @@ namespace ts {
                 // Callers should first ensure this by calling isTypeNode
                 case SyntaxKind.Identifier:
                 case SyntaxKind.QualifiedName:
-                    let symbol = getSymbolInfo(node);
+                    let symbol = getSymbolAtLocation(node);
                     return symbol && getDeclaredTypeOfSymbol(symbol);
                 default:
                     return unknownType;
@@ -4244,15 +4356,18 @@ namespace ts {
         }
 
         function createInferenceMapper(context: InferenceContext): TypeMapper {
-            return t => {
+            let mapper: TypeMapper = t => {
                 for (let i = 0; i < context.typeParameters.length; i++) {
                     if (t === context.typeParameters[i]) {
                         context.inferences[i].isFixed = true;
                         return getInferredType(context, i);
                     }
                 }
-                return t;
+                return t;
             };
+            
+            mapper.context = context;
+            return mapper;
         }
 
         function identityMapper(type: Type): Type {
@@ -4354,7 +4469,7 @@ namespace ts {
                     return createTupleType(instantiateList((<TupleType>type).elementTypes, mapper, instantiateType));
                 }
                 if (type.flags & TypeFlags.Union) {
-                    return getUnionType(instantiateList((<UnionType>type).types, mapper, instantiateType), /*noSubtypeReduction*/ true);
+                    return getUnionType(instantiateList((<UnionType>type).types, mapper, instantiateType), /*noDeduplication*/ true);
                 }
                 if (type.flags & TypeFlags.Intersection) {
                     return getIntersectionType(instantiateList((<IntersectionType>type).types, mapper, instantiateType));
@@ -4499,6 +4614,16 @@ namespace ts {
                 errorInfo = chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2);
             }
 
+            function reportRelationError(message: DiagnosticMessage, source: Type, target: Type) {
+                let sourceType = typeToString(source);
+                let targetType = typeToString(target);
+                if (sourceType === targetType) {
+                    sourceType = typeToString(source, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType);
+                    targetType = typeToString(target, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType);
+                }
+                reportError(message || Diagnostics.Type_0_is_not_assignable_to_type_1, sourceType, targetType);
+            }
+
             // Compare two types and return
             // Ternary.True if they are related with no assumptions,
             // Ternary.Maybe if they are related with assumptions of other relationships, or
@@ -4518,7 +4643,23 @@ namespace ts {
                         if (source === numberType && target.flags & TypeFlags.Enum) return Ternary.True;
                     }
                 }
+
+                if (relation !== identityRelation && source.flags & TypeFlags.FreshObjectLiteral) {
+                    if (hasExcessProperties(<FreshObjectLiteralType>source, target, reportErrors)) {
+                        if (reportErrors) {
+                            reportRelationError(headMessage, source, target);
+                        }
+                        return Ternary.False;
+                    }
+                    // Above we check for excess properties with respect to the entire target type. When union
+                    // and intersection types are further deconstructed on the target side, we don't want to
+                    // make the check again (as it might fail for a partial target type). Therefore we obtain
+                    // the regular source type and proceed with that.
+                    source = getRegularTypeOfObjectLiteral(source);
+                }
+
                 let saveErrorInfo = errorInfo;
+
                 if (source.flags & TypeFlags.Reference && target.flags & TypeFlags.Reference && (<TypeReference>source).target === (<TypeReference>target).target) {
                     // We have type references to same target type, see if relationship holds for all type arguments
                     if (result = typesRelatedTo((<TypeReference>source).typeArguments, (<TypeReference>target).typeArguments, reportErrors)) {
@@ -4595,18 +4736,22 @@ namespace ts {
                 }
 
                 if (reportErrors) {
-                    headMessage = headMessage || Diagnostics.Type_0_is_not_assignable_to_type_1;
-                    let sourceType = typeToString(source);
-                    let targetType = typeToString(target);
-                    if (sourceType === targetType) {
-                        sourceType = typeToString(source, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType);
-                        targetType = typeToString(target, /*enclosingDeclaration*/ undefined, TypeFormatFlags.UseFullyQualifiedType);
-                    }
-                    reportError(headMessage, sourceType, targetType);
+                    reportRelationError(headMessage, source, target);
                 }
                 return Ternary.False;
             }
 
+            function hasExcessProperties(source: FreshObjectLiteralType, target: Type, reportErrors: boolean): boolean {
+                for (let prop of getPropertiesOfObjectType(source)) {
+                    if (!isKnownProperty(target, prop.name)) {
+                        if (reportErrors) {
+                            reportError(Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(prop), typeToString(target));
+                        }
+                        return true;
+                    }
+                }
+            }
+
             function eachTypeRelatedToSomeType(source: UnionOrIntersectionType, target: UnionOrIntersectionType): Ternary {
                 let result = Ternary.True;
                 let sourceTypes = source.types;
@@ -5303,6 +5448,24 @@ namespace ts {
             return !!(type.flags & TypeFlags.Tuple);
         }
 
+        function getRegularTypeOfObjectLiteral(type: Type): Type {
+            if (type.flags & TypeFlags.FreshObjectLiteral) {
+                let regularType = (<FreshObjectLiteralType>type).regularType;
+                if (!regularType) {
+                    regularType = <ResolvedType>createType((<ResolvedType>type).flags & ~TypeFlags.FreshObjectLiteral);
+                    regularType.symbol = (<ResolvedType>type).symbol;
+                    regularType.members = (<ResolvedType>type).members;
+                    regularType.properties = (<ResolvedType>type).properties;
+                    regularType.callSignatures = (<ResolvedType>type).callSignatures;
+                    regularType.constructSignatures = (<ResolvedType>type).constructSignatures;
+                    regularType.stringIndexType = (<ResolvedType>type).stringIndexType;
+                    regularType.numberIndexType = (<ResolvedType>type).numberIndexType;
+                }
+                return regularType;
+            }
+            return type;
+        }
+
         function getWidenedTypeOfObjectLiteral(type: Type): Type {
             let properties = getPropertiesOfObjectType(type);
             let members: SymbolTable = {};
@@ -5463,7 +5626,9 @@ namespace ts {
         function createInferenceContext(typeParameters: TypeParameter[], inferUnionTypes: boolean): InferenceContext {
             let inferences: TypeInferences[] = [];
             for (let unused of typeParameters) {
-                inferences.push({ primary: undefined, secondary: undefined, isFixed: false });
+                inferences.push({
+                    primary: undefined, secondary: undefined, isFixed: false
+                });
             }
             return {
                 typeParameters,
@@ -5831,47 +5996,6 @@ namespace ts {
             }
         }
 
-        function resolveLocation(node: Node) {
-            // Resolve location from top down towards node if it is a context sensitive expression
-            // That helps in making sure not assigning types as any when resolved out of order
-            let containerNodes: Node[] = [];
-            for (let parent = node.parent; parent; parent = parent.parent) {
-                if ((isExpression(parent) || isObjectLiteralMethod(node)) &&
-                    isContextSensitive(<Expression>parent)) {
-                    containerNodes.unshift(parent);
-                }
-            }
-
-            ts.forEach(containerNodes, node => { getTypeOfNode(node); });
-        }
-
-        function getSymbolAtLocation(node: Node): Symbol {
-            resolveLocation(node);
-            return getSymbolInfo(node);
-        }
-
-        function getTypeAtLocation(node: Node): Type {
-            resolveLocation(node);
-            return getTypeOfNode(node);
-        }
-
-        function getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type {
-            resolveLocation(node);
-            // Get the narrowed type of symbol at given location instead of just getting
-            // the type of the symbol.
-            // eg.
-            // function foo(a: string | number) {
-            //     if (typeof a === "string") {
-            //         a/**/
-            //     }
-            // }
-            // getTypeOfSymbol for a would return type of parameter symbol string | number
-            // Unless we provide location /**/, checker wouldn't know how to narrow the type
-            // By using getNarrowedTypeOfSymbol would return string since it would be able to narrow
-            // it by typeguard in the if true condition
-            return getNarrowedTypeOfSymbol(symbol, node);
-        }
-
         // Get the narrowed type of a given symbol at a given location
         function getNarrowedTypeOfSymbol(symbol: Symbol, node: Node) {
             let type = getTypeOfSymbol(symbol);
@@ -6764,10 +6888,23 @@ namespace ts {
             return result;
         }
 
-        // Presence of a contextual type mapper indicates inferential typing, except the identityMapper object is
-        // used as a special marker for other purposes.
+        /**
+         * Detect if the mapper implies an inference context. Specifically, there are 4 possible values
+         * for a mapper. Let's go through each one of them:
+         *
+         *    1. undefined - this means we are not doing inferential typing, but we may do contextual typing,
+         *       which could cause us to assign a parameter a type
+         *    2. identityMapper - means we want to avoid assigning a parameter a type, whether or not we are in
+         *       inferential typing (context is undefined for the identityMapper)
+         *    3. a mapper created by createInferenceMapper - we are doing inferential typing, we want to assign
+         *       types to parameters and fix type parameters (context is defined)
+         *    4. an instantiation mapper created by createTypeMapper or createTypeEraser - this should never be
+         *       passed as the contextual mapper when checking an expression (context is undefined for these)
+         *
+         * isInferentialContext is detecting if we are in case 3
+         */
         function isInferentialContext(mapper: TypeMapper) {
-            return mapper && mapper !== identityMapper;
+            return mapper && mapper.context;
         }
 
         // A node is an assignment target if it is on the left hand side of an '=' token, if it is parented by a property
@@ -6955,7 +7092,7 @@ namespace ts {
             let stringIndexType = getIndexType(IndexKind.String);
             let numberIndexType = getIndexType(IndexKind.Number);
             let result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexType, numberIndexType);
-            result.flags |= TypeFlags.ObjectLiteral | TypeFlags.ContainsObjectLiteral | (typeFlags & TypeFlags.ContainsUndefinedOrNull);
+            result.flags |= TypeFlags.ObjectLiteral | TypeFlags.FreshObjectLiteral | TypeFlags.ContainsObjectLiteral | (typeFlags & TypeFlags.ContainsUndefinedOrNull);
             return result;
 
             function getIndexType(kind: IndexKind) {
@@ -8487,6 +8624,9 @@ namespace ts {
             if (!produceDiagnostics) {
                 for (let candidate of candidates) {
                     if (hasCorrectArity(node, args, candidate)) {
+                        if (candidate.typeParameters && typeArguments) {
+                            candidate = getSignatureInstantiation(candidate, map(typeArguments, getTypeFromTypeNode));
+                        }
                         return candidate;
                     }
                 }
@@ -8835,7 +8975,7 @@ namespace ts {
         }
 
         function checkAssertion(node: AssertionExpression) {
-            let exprType = checkExpression(node.expression);
+            let exprType = getRegularTypeOfObjectLiteral(checkExpression(node.expression));
             let targetType = getTypeFromTypeNode(node.type);
             if (produceDiagnostics && targetType !== unknownType) {
                 let widenedType = getWidenedType(exprType);
@@ -8856,13 +8996,52 @@ namespace ts {
             let len = signature.parameters.length - (signature.hasRestParameter ? 1 : 0);
             for (let i = 0; i < len; i++) {
                 let parameter = signature.parameters[i];
-                let links = getSymbolLinks(parameter);
-                links.type = instantiateType(getTypeAtPosition(context, i), mapper);
+                let contextualParameterType = getTypeAtPosition(context, i);
+                assignTypeToParameterAndFixTypeParameters(parameter, contextualParameterType, mapper);
             }
             if (signature.hasRestParameter && context.hasRestParameter && signature.parameters.length >= context.parameters.length) {
                 let parameter = lastOrUndefined(signature.parameters);
-                let links = getSymbolLinks(parameter);
-                links.type = instantiateType(getTypeOfSymbol(lastOrUndefined(context.parameters)), mapper);
+                let contextualParameterType = getTypeOfSymbol(lastOrUndefined(context.parameters));
+                assignTypeToParameterAndFixTypeParameters(parameter, contextualParameterType, mapper);
+            }
+        }
+
+        function assignTypeToParameterAndFixTypeParameters(parameter: Symbol, contextualType: Type, mapper: TypeMapper) {
+            let links = getSymbolLinks(parameter);
+            if (!links.type) {
+                links.type = instantiateType(contextualType, mapper);
+            }
+            else if (isInferentialContext(mapper)) {
+                // Even if the parameter already has a type, it might be because it was given a type while
+                // processing the function as an argument to a prior signature during overload resolution.
+                // If this was the case, it may have caused some type parameters to be fixed. So here,
+                // we need to ensure that type parameters at the same positions get fixed again. This is
+                // done by calling instantiateType to attach the mapper to the contextualType, and then
+                // calling inferTypes to force a walk of contextualType so that all the correct fixing
+                // happens. The choice to pass in links.type may seem kind of arbitrary, but it serves
+                // to make sure that all the correct positions in contextualType are reached by the walk.
+                // Here is an example:
+                //
+                //      interface Base {
+                //          baseProp;
+                //      }
+                //      interface Derived extends Base {
+                //          toBase(): Base;
+                //      }
+                //
+                //      var derived: Derived;
+                //
+                //      declare function foo<T>(x: T, func: (p: T) => T): T;
+                //      declare function foo<T>(x: T, func: (p: T) => T): T;
+                //
+                //      var result = foo(derived, d => d.toBase());
+                //
+                // We are typing d while checking the second overload. But we've already given d
+                // a type (Derived) from the first overload. However, we still want to fix the
+                // T in the second overload so that we do not infer Base as a candidate for T
+                // (inferring Base would make type argument inference inconsistent between the two
+                // overloads).
+                inferTypes(mapper.context, links.type, instantiateType(contextualType, mapper));
             }
         }
 
@@ -9082,27 +9261,36 @@ namespace ts {
 
             let links = getNodeLinks(node);
             let type = getTypeOfSymbol(node.symbol);
-            // Check if function expression is contextually typed and assign parameter types if so
-            if (!(links.flags & NodeCheckFlags.ContextChecked)) {
+            let contextSensitive = isContextSensitive(node);
+            let mightFixTypeParameters = contextSensitive && isInferentialContext(contextualMapper);
+
+            // Check if function expression is contextually typed and assign parameter types if so.
+            // See the comment in assignTypeToParameterAndFixTypeParameters to understand why we need to
+            // check mightFixTypeParameters.
+            if (mightFixTypeParameters || !(links.flags & NodeCheckFlags.ContextChecked)) {
                 let contextualSignature = getContextualSignature(node);
                 // If a type check is started at a function expression that is an argument of a function call, obtaining the
                 // contextual type may recursively get back to here during overload resolution of the call. If so, we will have
                 // already assigned contextual types.
-                if (!(links.flags & NodeCheckFlags.ContextChecked)) {
+                let contextChecked = !!(links.flags & NodeCheckFlags.ContextChecked);
+                if (mightFixTypeParameters || !contextChecked) {
                     links.flags |= NodeCheckFlags.ContextChecked;
                     if (contextualSignature) {
                         let signature = getSignaturesOfType(type, SignatureKind.Call)[0];
-                        if (isContextSensitive(node)) {
+                        if (contextSensitive) {
                             assignContextualParameterTypes(signature, contextualSignature, contextualMapper || identityMapper);
                         }
-                        if (!node.type && !signature.resolvedReturnType) {
+                        if (mightFixTypeParameters || !node.type && !signature.resolvedReturnType) {
                             let returnType = getReturnTypeFromBody(node, contextualMapper);
                             if (!signature.resolvedReturnType) {
                                 signature.resolvedReturnType = returnType;
                             }
                         }
                     }
-                    checkSignatureDeclaration(node);
+
+                    if (!contextChecked) {
+                        checkSignatureDeclaration(node);
+                    }
                 }
             }
 
@@ -9612,7 +9800,7 @@ namespace ts {
                     return getUnionType([leftType, rightType]);
                 case SyntaxKind.EqualsToken:
                     checkAssignmentOperator(rightType);
-                    return rightType;
+                    return getRegularTypeOfObjectLiteral(rightType);
                 case SyntaxKind.CommaToken:
                     return rightType;
             }
@@ -9792,7 +9980,7 @@ namespace ts {
         }
 
         function instantiateTypeWithSingleGenericCallSignature(node: Expression | MethodDeclaration, type: Type, contextualMapper?: TypeMapper) {
-            if (contextualMapper && contextualMapper !== identityMapper) {
+            if (isInferentialContext(contextualMapper)) {
                 let signature = getSingleCallSignature(type);
                 if (signature && signature.typeParameters) {
                     let contextualType = getContextualType(<Expression>node);
@@ -10037,7 +10225,7 @@ namespace ts {
                             }
                             else {
                                 checkTypeAssignableTo(typePredicate.type,
-                                    getTypeAtLocation(node.parameters[typePredicate.parameterIndex]),
+                                    getTypeOfNode(node.parameters[typePredicate.parameterIndex]),
                                     typePredicateNode.type);
                             }
                         }
@@ -13669,7 +13857,7 @@ namespace ts {
             return undefined;
         }
 
-        function getSymbolInfo(node: Node) {
+        function getSymbolAtLocation(node: Node) {
             if (isInsideWithStatementBody(node)) {
                 // We cannot answer semantic questions within a with block, do not proceed any further
                 return undefined;
@@ -13680,10 +13868,22 @@ namespace ts {
                 return getSymbolOfNode(node.parent);
             }
 
-            if (node.kind === SyntaxKind.Identifier && isInRightSideOfImportOrExportAssignment(<Identifier>node)) {
-                return node.parent.kind === SyntaxKind.ExportAssignment
-                    ? getSymbolOfEntityNameOrPropertyAccessExpression(<Identifier>node)
-                    : getSymbolOfPartOfRightHandSideOfImportEquals(<Identifier>node);
+            if (node.kind === SyntaxKind.Identifier) {
+                if (isInRightSideOfImportOrExportAssignment(<Identifier>node)) {
+                    return node.parent.kind === SyntaxKind.ExportAssignment
+                        ? getSymbolOfEntityNameOrPropertyAccessExpression(<Identifier>node)
+                        : getSymbolOfPartOfRightHandSideOfImportEquals(<Identifier>node);
+                }
+                else if (node.parent.kind === SyntaxKind.BindingElement &&
+                        node.parent.parent.kind === SyntaxKind.ObjectBindingPattern &&
+                        node === (<BindingElement>node.parent).propertyName) {
+                    let typeOfPattern = getTypeOfNode(node.parent.parent);
+                    let propertyDeclaration = typeOfPattern && getPropertyOfType(typeOfPattern, (<Identifier>node).text);
+
+                    if (propertyDeclaration) {
+                        return propertyDeclaration;
+                    }
+                }
             }
 
             switch (node.kind) {
@@ -13760,24 +13960,24 @@ namespace ts {
             }
 
             if (isTypeDeclaration(node)) {
-                // In this case, we call getSymbolOfNode instead of getSymbolInfo because it is a declaration
+                // In this case, we call getSymbolOfNode instead of getSymbolAtLocation because it is a declaration
                 let symbol = getSymbolOfNode(node);
                 return getDeclaredTypeOfSymbol(symbol);
             }
 
             if (isTypeDeclarationName(node)) {
-                let symbol = getSymbolInfo(node);
+                let symbol = getSymbolAtLocation(node);
                 return symbol && getDeclaredTypeOfSymbol(symbol);
             }
 
             if (isDeclaration(node)) {
-                // In this case, we call getSymbolOfNode instead of getSymbolInfo because it is a declaration
+                // In this case, we call getSymbolOfNode instead of getSymbolAtLocation because it is a declaration
                 let symbol = getSymbolOfNode(node);
                 return getTypeOfSymbol(symbol);
             }
 
             if (isDeclarationName(node)) {
-                let symbol = getSymbolInfo(node);
+                let symbol = getSymbolAtLocation(node);
                 return symbol && getTypeOfSymbol(symbol);
             }
 
@@ -13786,7 +13986,7 @@ namespace ts {
             }
 
             if (isInRightSideOfImportOrExportAssignment(<Identifier>node)) {
-                let symbol = getSymbolInfo(node);
+                let symbol = getSymbolAtLocation(node);
                 let declaredType = symbol && getDeclaredTypeOfSymbol(symbol);
                 return declaredType !== unknownType ? declaredType : getTypeOfSymbol(symbol);
             }
@@ -13955,7 +14155,11 @@ namespace ts {
                 return true;
             }
             // const enums and modules that contain only const enums are not considered values from the emit perespective
-            return target !== unknownSymbol && target && target.flags & SymbolFlags.Value && !isConstEnumOrConstEnumOnlyModule(target);
+            // unless 'preserveConstEnums' option is set to true
+            return target !== unknownSymbol && 
+                target && 
+                target.flags & SymbolFlags.Value && 
+                (compilerOptions.preserveConstEnums || !isConstEnumOrConstEnumOnlyModule(target));
         }
 
         function isConstEnumOrConstEnumOnlyModule(s: Symbol): boolean {

src/compiler/diagnosticInformationMap.generated.ts

@@ -254,6 +254,7 @@ namespace ts {
         Only_a_void_function_can_be_called_with_the_new_keyword: { code: 2350, category: DiagnosticCategory.Error, key: "Only a void function can be called with the 'new' keyword." },
         Cannot_use_new_with_an_expression_whose_type_lacks_a_call_or_construct_signature: { code: 2351, category: DiagnosticCategory.Error, key: "Cannot use 'new' with an expression whose type lacks a call or construct signature." },
         Neither_type_0_nor_type_1_is_assignable_to_the_other: { code: 2352, category: DiagnosticCategory.Error, key: "Neither type '{0}' nor type '{1}' is assignable to the other." },
+        Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1: { code: 2353, category: DiagnosticCategory.Error, key: "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'." },
         No_best_common_type_exists_among_return_expressions: { code: 2354, category: DiagnosticCategory.Error, key: "No best common type exists among return expressions." },
         A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2355, category: DiagnosticCategory.Error, key: "A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement." },
         An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type: { code: 2356, category: DiagnosticCategory.Error, key: "An arithmetic operand must be of type 'any', 'number' or an enum type." },

src/compiler/diagnosticMessages.json

@@ -1005,6 +1005,10 @@
         "category": "Error",
         "code": 2352
     },
+    "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'.": {
+        "category": "Error",
+        "code": 2353
+    },
     "No best common type exists among return expressions.": {
         "category": "Error",
         "code": 2354

src/compiler/emitter.ts

@@ -1425,6 +1425,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     case SyntaxKind.IfStatement:
                     case SyntaxKind.JsxSelfClosingElement:
                     case SyntaxKind.JsxOpeningElement:
+                    case SyntaxKind.JsxExpression:
                     case SyntaxKind.NewExpression:
                     case SyntaxKind.ParenthesizedExpression:
                     case SyntaxKind.PostfixUnaryExpression:
@@ -3012,6 +3013,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 return result;
             }
 
+            function emitEs6ExportDefaultCompat(node: Node) {
+                if (node.parent.kind === SyntaxKind.SourceFile) {
+                    Debug.assert(!!(node.flags & NodeFlags.Default) || node.kind === SyntaxKind.ExportAssignment);
+                    // only allow export default at a source file level
+                    if (compilerOptions.module === ModuleKind.CommonJS || compilerOptions.module === ModuleKind.AMD || compilerOptions.module === ModuleKind.UMD) {
+                        if (!currentSourceFile.symbol.exports["___esModule"]) {
+                            if (languageVersion === ScriptTarget.ES5) {
+                                // default value of configurable, enumerable, writable are `false`. 
+                                write("Object.defineProperty(exports, \"__esModule\", { value: true });");
+                                writeLine();
+                            }
+                            else if (languageVersion === ScriptTarget.ES3) {
+                                write("exports.__esModule = true;");
+                                writeLine();
+                            }
+                        }
+                    }
+                }
+            }
+
             function emitExportMemberAssignment(node: FunctionLikeDeclaration | ClassDeclaration) {
                 if (node.flags & NodeFlags.Export) {
                     writeLine();
@@ -3034,9 +3055,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     }
                     else {
                         if (node.flags & NodeFlags.Default) {
+                            emitEs6ExportDefaultCompat(node);
                             if (languageVersion === ScriptTarget.ES3) {
                                 write("exports[\"default\"]");
-                            } else {
+                            }
+                            else {
                                 write("exports.default");
                             }
                         }
@@ -3249,7 +3272,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 function emitAssignmentExpression(root: BinaryExpression) {
                     let target = root.left;
                     let value = root.right;
-                    if (isAssignmentExpressionStatement) {
+
+                    if (isEmptyObjectLiteralOrArrayLiteral(target)) {
+                        emit(value);
+                    }
+                    else if (isAssignmentExpressionStatement) {
                         emitDestructuringAssignment(target, value);
                     }
                     else {
@@ -4215,10 +4242,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     }
                 }
 
+                let startIndex = 0;
+
                 write(" {");
                 scopeEmitStart(node, "constructor");
                 increaseIndent();
                 if (ctor) {
+                    // Emit all the directive prologues (like "use strict").  These have to come before
+                    // any other preamble code we write (like parameter initializers).
+                    startIndex = emitDirectivePrologues(ctor.body.statements, /*startWithNewLine*/ true);                    
                     emitDetachedComments(ctor.body.statements);
                 }
                 emitCaptureThisForNodeIfNecessary(node);
@@ -4253,7 +4285,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     if (superCall) {
                         statements = statements.slice(1);
                     }
-                    emitLines(statements);
+                    emitLinesStartingAt(statements, startIndex);
                 }
                 emitTempDeclarations(/*newLine*/ true);
                 writeLine();
@@ -5398,17 +5430,43 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     (!isExternalModule(currentSourceFile) && resolver.isTopLevelValueImportEqualsWithEntityName(node))) {
                     emitLeadingComments(node);
                     emitStart(node);
-                    if (isES6ExportedDeclaration(node)) {
-                        write("export ");
-                        write("var ");
+                    
+                    // variable declaration for import-equals declaration can be hoisted in system modules
+                    // in this case 'var' should be omitted and emit should contain only initialization
+                    let variableDeclarationIsHoisted = shouldHoistVariable(node, /*checkIfSourceFileLevelDecl*/ true);
+                    
+                    // is it top level export import v = a.b.c in system module?
+                    // if yes - it needs to be rewritten as exporter('v', v = a.b.c)
+                    let isExported = isSourceFileLevelDeclarationInSystemJsModule(node, /*isExported*/ true);
+                    
+                    if (!variableDeclarationIsHoisted) {
+                        Debug.assert(!isExported);
+                                                
+                        if (isES6ExportedDeclaration(node)) {
+                            write("export ");
+                            write("var ");
+                        }
+                        else if (!(node.flags & NodeFlags.Export)) {
+                            write("var ");
+                        }
                     }
-                    else if (!(node.flags & NodeFlags.Export)) {
-                        write("var ");
+                                       
+                    
+                    if (isExported) {
+                        write(`${exportFunctionForFile}("`);
+                        emitNodeWithoutSourceMap(node.name);
+                        write(`", `);
                     }
+
                     emitModuleMemberName(node);
                     write(" = ");
                     emit(node.moduleReference);
-                    write(";");
+
+                    if (isExported) {
+                        write(")");
+                    }
+                                        
+                    write(";");                    
                     emitEnd(node);
                     emitExportImportAssignments(node);
                     emitTrailingComments(node);
@@ -5529,6 +5587,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                             write(")");
                         }
                         else {
+                            emitEs6ExportDefaultCompat(node);
                             emitContainingModuleName(node);
                             if (languageVersion === ScriptTarget.ES3) {
                                 write("[\"default\"] = ");
@@ -5747,6 +5806,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     write(`function ${exportStarFunction}(m) {`);
                     increaseIndent();
                     writeLine();
+                    write(`var exports = {};`);
+                    writeLine();
                     write(`for(var n in m) {`);
                     increaseIndent();
                     writeLine();
@@ -5754,10 +5815,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     if (localNames) {
                         write(`&& !${localNames}.hasOwnProperty(n)`);
                     }
-                    write(`) ${exportFunctionForFile}(n, m[n]);`);
+                    write(`) exports[n] = m[n];`);
                     decreaseIndent();
                     writeLine();
                     write("}");
+                    writeLine();
+                    write(`${exportFunctionForFile}(exports);`)
                     decreaseIndent();
                     writeLine();
                     write("}");
@@ -5929,6 +5992,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         }
                         return;
                     }
+                    
+                    if (isInternalModuleImportEqualsDeclaration(node)) {
+                        if (!hoistedVars) {
+                            hoistedVars = [];
+                        }
+                        
+                        hoistedVars.push(node.name);
+                        return;
+                    }
 
                     if (isBindingPattern(node)) {
                         forEach((<BindingPattern>node).elements, visit);
@@ -6090,16 +6162,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                             if ((<ExportDeclaration>importNode).exportClause) {
                                 // export {a, b as c} from 'foo'
                                 // emit as:
-                                // exports('a', _foo["a"])
-                                // exports('c', _foo["b"])
+                                // var reexports = {}
+                                // reexports['a'] = _foo["a"];
+                                // reexports['c'] = _foo["b"];
+                                // exports_(reexports);
+                                let reexportsVariableName = makeUniqueName("reexports");
+                                writeLine();
+                                write(`var ${reexportsVariableName} = {};`)
+                                writeLine();
                                 for (let e of (<ExportDeclaration>importNode).exportClause.elements) {
-                                    writeLine();
-                                    write(`${exportFunctionForFile}("`);
+                                    write(`${reexportsVariableName}["`);
                                     emitNodeWithoutSourceMap(e.name);
-                                    write(`", ${parameterName}["`);
+                                    write(`"] = ${parameterName}["`);
                                     emitNodeWithoutSourceMap(e.propertyName || e.name);
-                                    write(`"]);`);
+                                    write(`"];`);
+                                    writeLine();
                                 }
+                                write(`${exportFunctionForFile}(${reexportsVariableName});`);
                             }
                             else {
                                 writeLine();
@@ -6126,14 +6205,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 writeLine();
                 for (let i = startIndex; i < node.statements.length; ++i) {
                     let statement = node.statements[i];
-                    // - imports/exports are not emitted for system modules
+                    // - external module related imports/exports are not emitted for system modules
                     // - function declarations are not emitted because they were already hoisted
                     switch (statement.kind) {
                         case SyntaxKind.ExportDeclaration:
                         case SyntaxKind.ImportDeclaration:
-                        case SyntaxKind.ImportEqualsDeclaration:
                         case SyntaxKind.FunctionDeclaration:
                             continue;
+                        case SyntaxKind.ImportEqualsDeclaration:
+                            if (!isInternalModuleImportEqualsDeclaration(statement)) {
+                                continue;
+                            }
                     }
                     writeLine();
                     emit(statement);

src/compiler/parser.ts

@@ -3295,7 +3295,7 @@ namespace ts {
 
         function parseSuperExpression(): MemberExpression {
             let expression = parseTokenNode<PrimaryExpression>();
-            if (token === SyntaxKind.OpenParenToken || token === SyntaxKind.DotToken) {
+            if (token === SyntaxKind.OpenParenToken || token === SyntaxKind.DotToken || token === SyntaxKind.OpenBracketToken) {
                 return expression;
             }
 

src/compiler/types.ts

@@ -1762,10 +1762,12 @@ namespace ts {
         FromSignature           = 0x00040000,  // Created for signature assignment check
         ObjectLiteral           = 0x00080000,  // Originates in an object literal
         /* @internal */
-        ContainsUndefinedOrNull = 0x00100000,  // Type is or contains Undefined or Null type
+        FreshObjectLiteral      = 0x00100000,  // Fresh object literal type
         /* @internal */
-        ContainsObjectLiteral   = 0x00200000,  // Type is or contains object literal type
-        ESSymbol                = 0x00400000,  // Type of symbol primitive introduced in ES6
+        ContainsUndefinedOrNull = 0x00200000,  // Type is or contains Undefined or Null type
+        /* @internal */
+        ContainsObjectLiteral   = 0x00400000,  // Type is or contains object literal type
+        ESSymbol                = 0x00800000,  // Type of symbol primitive introduced in ES6
 
         /* @internal */
         Intrinsic = Any | String | Number | Boolean | ESSymbol | Void | Undefined | Null,
@@ -1858,6 +1860,14 @@ namespace ts {
         numberIndexType?: Type;            // Numeric index type
     }
 
+    /* @internal */
+    // Object literals are initially marked fresh. Freshness disappears following an assignment,
+    // before a type assertion, or when when an object literal's type is widened. The regular
+    // version of a fresh type is identical except for the TypeFlags.FreshObjectLiteral flag.
+    export interface FreshObjectLiteralType extends ResolvedType {
+        regularType: ResolvedType;  // Regular version of fresh type
+    }
+
     // Just a place to cache element types of iterables and iterators
     /* @internal */
     export interface IterableOrIteratorType extends ObjectType, UnionType {
@@ -1912,6 +1922,9 @@ namespace ts {
     /* @internal */
     export interface TypeMapper {
         (t: TypeParameter): Type;
+        context?: InferenceContext; // The inference context this mapper was created from.
+                                    // Only inference mappers have this set (in createInferenceMapper).
+                                    // The identity mapper and regular instantiation mappers do not need it.
     }
 
     /* @internal */
@@ -2208,6 +2221,7 @@ namespace ts {
 
     export interface CompilerHost {
         getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile;
+        getCancellationToken?(): CancellationToken;
         getDefaultLibFileName(options: CompilerOptions): string;
         writeFile: WriteFileCallback;
         getCurrentDirectory(): string;

src/compiler/utilities.ts

@@ -568,7 +568,7 @@ namespace ts {
         }
     }
 
-    export function isVariableLike(node: Node): boolean {
+    export function isVariableLike(node: Node): node is VariableLikeDeclaration {
         if (node) {
             switch (node.kind) {
                 case SyntaxKind.BindingElement:
@@ -965,7 +965,7 @@ namespace ts {
         return (<ExternalModuleReference>(<ImportEqualsDeclaration>node).moduleReference).expression;
     }
 
-    export function isInternalModuleImportEqualsDeclaration(node: Node) {
+    export function isInternalModuleImportEqualsDeclaration(node: Node): node is ImportEqualsDeclaration {
         return node.kind === SyntaxKind.ImportEqualsDeclaration && (<ImportEqualsDeclaration>node).moduleReference.kind !== SyntaxKind.ExternalModuleReference;
     }
 
@@ -1981,6 +1981,17 @@ namespace ts {
             (node.parent.kind === SyntaxKind.PropertyAccessExpression && (<PropertyAccessExpression>node.parent).name === node);
     }
 
+    export function isEmptyObjectLiteralOrArrayLiteral(expression: Node): boolean {
+        let kind = expression.kind;
+        if (kind === SyntaxKind.ObjectLiteralExpression) {
+            return (<ObjectLiteralExpression>expression).properties.length === 0;
+        }
+        if (kind === SyntaxKind.ArrayLiteralExpression) {
+            return (<ArrayLiteralExpression>expression).elements.length === 0;
+        }
+        return false;
+    }
+
     export function getLocalSymbolForExportDefault(symbol: Symbol) {
         return symbol && symbol.valueDeclaration && (symbol.valueDeclaration.flags & NodeFlags.Default) ? symbol.valueDeclaration.localSymbol : undefined;
     }

src/harness/fourslash.ts

@@ -26,9 +26,8 @@ module FourSlash {
     export interface FourSlashFile {
         // The contents of the file (with markers, etc stripped out)
         content: string;
-
         fileName: string;
-
+        version: number;
         // File-specific options (name/value pairs)
         fileOptions: { [index: string]: string; };
     }
@@ -671,20 +670,20 @@ module FourSlash {
 
             let completions = this.getCompletionListAtCaret();
             if ((!completions || completions.entries.length === 0) && negative) {
-                this.raiseError("Completion list is empty at Caret");
-            } else if ((completions && completions.entries.length !== 0) && !negative) {
-
+                this.raiseError("Completion list is empty at caret at position " + this.activeFile.fileName + " " + this.currentCaretPosition);
+            }
+            else if (completions && completions.entries.length !== 0 && !negative) {
                 let errorMsg = "\n" + "Completion List contains: [" + completions.entries[0].name;
                 for (let i = 1; i < completions.entries.length; i++) {
                     errorMsg += ", " + completions.entries[i].name;
                 }
                 errorMsg += "]\n";
 
-                Harness.IO.log(errorMsg);
-                this.raiseError("Completion list is not empty at Caret");
+                this.raiseError("Completion list is not empty at caret at position " + this.activeFile.fileName + " " + this.currentCaretPosition + errorMsg);
             }
         }
 
+
         public verifyCompletionListAllowsNewIdentifier(negative: boolean) {
             let completions = this.getCompletionListAtCaret();
 

src/harness/loggedIO.ts

@@ -12,6 +12,7 @@ interface FindFileResult {
 }
 
 interface IOLog {
+    timestamp: string;
     arguments: string[];
     executingPath: string;
     currentDirectory: string;

src/harness/runnerbase.ts

@@ -1,6 +1,6 @@
 /// <reference path="harness.ts" />
 
-class RunnerBase {
+abstract class RunnerBase {
     constructor() { }
 
     // contains the tests to run
@@ -18,9 +18,7 @@ class RunnerBase {
     /** Setup the runner's tests so that they are ready to be executed by the harness 
      *  The first test should be a describe/it block that sets up the harness's compiler instance appropriately
      */
-    public initializeTests(): void {
-        throw new Error('method not implemented');
-    }
+    public abstract initializeTests(): void;
 
     /** Replaces instances of full paths with fileNames only */
     static removeFullPaths(path: string) {

src/harness/rwcRunner.ts

@@ -123,7 +123,7 @@ module RWC {
                         content = ts.sys.readFile(unitName);
                     }
                     catch (e) {
-                        // Leave content undefined.
+                        content = ts.sys.readFile(fileName);
                     }
                     return { unitName, content };
                 }

src/lib/core.d.ts

@@ -971,14 +971,14 @@ interface JSON {
       * @param replacer A function that transforms the results.
       * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
       */
-    stringify(value: any, replacer: (key: string, value: any) => any, space: any): string;
+    stringify(value: any, replacer: (key: string, value: any) => any, space: string | number): string;
     /**
       * Converts a JavaScript value to a JavaScript Object Notation (JSON) string.
       * @param value A JavaScript value, usually an object or array, to be converted.
       * @param replacer Array that transforms the results.
       * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
       */
-    stringify(value: any, replacer: any[], space: any): string;
+    stringify(value: any, replacer: any[], space: string | number): string;
 }
 /**
   * An intrinsic object that provides functions to convert JavaScript values to and from the JavaScript Object Notation (JSON) format.
@@ -1181,4 +1181,4 @@ interface PromiseLike<T> {
     */
     then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): PromiseLike<TResult>;
     then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): PromiseLike<TResult>;
-}
+}

src/lib/es6.d.ts

@@ -377,7 +377,7 @@ interface String {
       * @param searchString search string 
       * @param position If position is undefined, 0 is assumed, so as to search all of the String.
       */
-    contains(searchString: string, position?: number): boolean;
+    includes(searchString: string, position?: number): boolean;
 
     /**
       * Returns true if the sequence of elements of searchString converted to a String is the 

src/server/client.ts

@@ -202,9 +202,7 @@ namespace ts.server {
             return  {
                 isMemberCompletion: false,
                 isNewIdentifierLocation: false,
-                entries: response.body,
-                fileName: fileName,
-                position: position
+                entries: response.body
             };
         }
      

src/server/session.ts

@@ -842,53 +842,53 @@ namespace ts.server {
         private handlers : Map<(request: protocol.Request) => {response?: any, responseRequired?: boolean}> = {
             [CommandNames.Exit]: () => {
                 this.exit();
-                return {};
+                return { responseRequired: false};
             },
             [CommandNames.Definition]: (request: protocol.Request) => {
                 var defArgs = <protocol.FileLocationRequestArgs>request.arguments;
-                return {response: this.getDefinition(defArgs.line, defArgs.offset, defArgs.file)};
+                return {response: this.getDefinition(defArgs.line, defArgs.offset, defArgs.file), responseRequired: true};
             },
             [CommandNames.TypeDefinition]: (request: protocol.Request) => {
                 var defArgs = <protocol.FileLocationRequestArgs>request.arguments;
-                return {response: this.getTypeDefinition(defArgs.line, defArgs.offset, defArgs.file)};
+                return {response: this.getTypeDefinition(defArgs.line, defArgs.offset, defArgs.file), responseRequired: true};
             },
             [CommandNames.References]: (request: protocol.Request) => {
                 var defArgs = <protocol.FileLocationRequestArgs>request.arguments;
-                return {response: this.getReferences(defArgs.line, defArgs.offset, defArgs.file)};
+                return {response: this.getReferences(defArgs.line, defArgs.offset, defArgs.file), responseRequired: true};
             },
             [CommandNames.Rename]: (request: protocol.Request) => {
                 var renameArgs = <protocol.RenameRequestArgs>request.arguments;
-                return {response: this.getRenameLocations(renameArgs.line, renameArgs.offset, renameArgs.file, renameArgs.findInComments, renameArgs.findInStrings)}
+                return {response: this.getRenameLocations(renameArgs.line, renameArgs.offset, renameArgs.file, renameArgs.findInComments, renameArgs.findInStrings), responseRequired: true}
             },
             [CommandNames.Open]: (request: protocol.Request) => {
                 var openArgs = <protocol.OpenRequestArgs>request.arguments;
                 this.openClientFile(openArgs.file);
-                return {}
+                return {responseRequired: false}
             },
             [CommandNames.Quickinfo]: (request: protocol.Request) => {
                 var quickinfoArgs = <protocol.FileLocationRequestArgs>request.arguments;
-                return {response: this.getQuickInfo(quickinfoArgs.line, quickinfoArgs.offset, quickinfoArgs.file)};
+                return {response: this.getQuickInfo(quickinfoArgs.line, quickinfoArgs.offset, quickinfoArgs.file), responseRequired: true};
             },
             [CommandNames.Format]: (request: protocol.Request) => {
                 var formatArgs = <protocol.FormatRequestArgs>request.arguments;
-                return {response: this.getFormattingEditsForRange(formatArgs.line, formatArgs.offset, formatArgs.endLine, formatArgs.endOffset, formatArgs.file)};
+                return {response: this.getFormattingEditsForRange(formatArgs.line, formatArgs.offset, formatArgs.endLine, formatArgs.endOffset, formatArgs.file), responseRequired: true};
             },
             [CommandNames.Formatonkey]: (request: protocol.Request) => {
                 var formatOnKeyArgs = <protocol.FormatOnKeyRequestArgs>request.arguments;
-                return {response: this.getFormattingEditsAfterKeystroke(formatOnKeyArgs.line, formatOnKeyArgs.offset, formatOnKeyArgs.key, formatOnKeyArgs.file)};
+                return {response: this.getFormattingEditsAfterKeystroke(formatOnKeyArgs.line, formatOnKeyArgs.offset, formatOnKeyArgs.key, formatOnKeyArgs.file), responseRequired: true};
             },
             [CommandNames.Completions]: (request: protocol.Request) => {
                 var completionsArgs = <protocol.CompletionsRequestArgs>request.arguments;
-                return {response: this.getCompletions(completionsArgs.line, completionsArgs.offset, completionsArgs.prefix, completionsArgs.file)}
+                return {response: this.getCompletions(completionsArgs.line, completionsArgs.offset, completionsArgs.prefix, completionsArgs.file), responseRequired: true}
             },
             [CommandNames.CompletionDetails]: (request: protocol.Request) => {
                 var completionDetailsArgs = <protocol.CompletionDetailsRequestArgs>request.arguments;
                 return {response: this.getCompletionEntryDetails(completionDetailsArgs.line,completionDetailsArgs.offset,
-                                                                  completionDetailsArgs.entryNames,completionDetailsArgs.file)}
+                                                                  completionDetailsArgs.entryNames,completionDetailsArgs.file), responseRequired: true}
             },
             [CommandNames.SignatureHelp]: (request: protocol.Request) => {
                 var signatureHelpArgs = <protocol.SignatureHelpRequestArgs>request.arguments;
-                return {response: this.getSignatureHelpItems(signatureHelpArgs.line, signatureHelpArgs.offset, signatureHelpArgs.file)}
+                return {response: this.getSignatureHelpItems(signatureHelpArgs.line, signatureHelpArgs.offset, signatureHelpArgs.file), responseRequired: true}
             },
             [CommandNames.Geterr]: (request: protocol.Request) => {
                 var geterrArgs = <protocol.GeterrRequestArgs>request.arguments;
@@ -923,23 +923,23 @@ namespace ts.server {
             },
             [CommandNames.Navto]: (request: protocol.Request) => {
                 var navtoArgs = <protocol.NavtoRequestArgs>request.arguments;
-                return {response: this.getNavigateToItems(navtoArgs.searchValue, navtoArgs.file, navtoArgs.maxResultCount)};
+                return {response: this.getNavigateToItems(navtoArgs.searchValue, navtoArgs.file, navtoArgs.maxResultCount), responseRequired: true};
             },
             [CommandNames.Brace]: (request: protocol.Request) => {
                 var braceArguments = <protocol.FileLocationRequestArgs>request.arguments;
-                return {response: this.getBraceMatching(braceArguments.line, braceArguments.offset, braceArguments.file)};
+                return {response: this.getBraceMatching(braceArguments.line, braceArguments.offset, braceArguments.file), responseRequired: true};
             },
             [CommandNames.NavBar]: (request: protocol.Request) => {
                 var navBarArgs = <protocol.FileRequestArgs>request.arguments;
-                return {response: this.getNavigationBarItems(navBarArgs.file)};
+                return {response: this.getNavigationBarItems(navBarArgs.file), responseRequired: true};
             },
             [CommandNames.Occurrences]: (request: protocol.Request) => {
                 var { line, offset, file: fileName } = <protocol.FileLocationRequestArgs>request.arguments;
-                return {response: this.getOccurrences(line, offset, fileName)};
+                return {response: this.getOccurrences(line, offset, fileName), responseRequired: true};
             },
             [CommandNames.ProjectInfo]: (request: protocol.Request) => {
                 var { file, needFileNameList } = <protocol.ProjectInfoRequestArgs>request.arguments;
-                return {response: this.getProjectInfo(file, needFileNameList)};
+                return {response: this.getProjectInfo(file, needFileNameList), responseRequired: true};
             },
         };
         addProtocolHandler(command: string, handler: (request: protocol.Request) => {response?: any, responseRequired: boolean}) {

src/services/services.ts

@@ -1105,6 +1105,7 @@ namespace ts {
     }
 
     export interface HighlightSpan {
+        fileName?: string;
         textSpan: TextSpan;
         kind: string;
     }
@@ -1411,7 +1412,9 @@ namespace ts {
           * @param fileName The name of the file to be released
           * @param compilationSettings The compilation settings used to acquire the file
           */
-        releaseDocument(fileName: string, compilationSettings: CompilerOptions): void
+        releaseDocument(fileName: string, compilationSettings: CompilerOptions): void;
+
+        reportStats(): string;
     }
 
     // TODO: move these to enums
@@ -3234,8 +3237,19 @@ namespace ts {
                     // We are *only* completing on properties from the type being destructured.
                     isNewIdentifierLocation = false;
 
-                    typeForObject = typeChecker.getTypeAtLocation(objectLikeContainer);
-                    existingMembers = (<BindingPattern>objectLikeContainer).elements;
+                    let rootDeclaration = getRootDeclaration(objectLikeContainer.parent);
+                    if (isVariableLike(rootDeclaration)) {
+                        // We don't want to complete using the type acquired by the shape 
+                        // of the binding pattern; we are only interested in types acquired
+                        // through type declaration or inference.
+                        if (rootDeclaration.initializer || rootDeclaration.type) {
+                            typeForObject = typeChecker.getTypeAtLocation(objectLikeContainer);
+                            existingMembers = (<BindingPattern>objectLikeContainer).elements;
+                        }
+                    }
+                    else {
+                        Debug.fail("Root declaration is not variable-like.")
+                    }
                 }
                 else {
                     Debug.fail("Expected object literal or binding pattern, got " + objectLikeContainer.kind);

src/services/shims.ts

@@ -64,8 +64,13 @@ namespace ts {
 
     /** Public interface of the the of a config service shim instance.*/
     export interface CoreServicesShimHost extends Logger {
-        /** Returns a JSON-encoded value of the type: string[] */
-        readDirectory(rootDir: string, extension: string): string;
+        /**
+         * Returns a JSON-encoded value of the type: string[]
+         *
+         * @param exclude A JSON encoded string[] containing the paths to exclude
+         *  when enumerating the directory.
+         */
+        readDirectory(rootDir: string, extension: string, exclude?: string): string;
     }
 
     ///
@@ -386,8 +391,18 @@ namespace ts {
         constructor(private shimHost: CoreServicesShimHost) {
         }
 
-        public readDirectory(rootDir: string, extension: string): string[] {
-            var encoded = this.shimHost.readDirectory(rootDir, extension);
+        public readDirectory(rootDir: string, extension: string, exclude: string[]): string[] {
+            // Wrap the API changes for 1.5 release. This try/catch
+            // should be removed once TypeScript 1.5 has shipped.
+            // Also consider removing the optional designation for
+            // the exclude param at this time.
+            var encoded: string;
+            try {
+                encoded = this.shimHost.readDirectory(rootDir, extension, JSON.stringify(exclude));
+            }
+            catch (e) {
+                encoded = this.shimHost.readDirectory(rootDir, extension);
+            }
             return JSON.parse(encoded);
         }
     }
@@ -439,11 +454,11 @@ namespace ts {
         }
     }
 
-    export function realizeDiagnostics(diagnostics: Diagnostic[], newLine: string): { message: string; start: number; length: number; category: string; } []{
+    export function realizeDiagnostics(diagnostics: Diagnostic[], newLine: string): { message: string; start: number; length: number; category: string; code: number; } []{
         return diagnostics.map(d => realizeDiagnostic(d, newLine));
     }
 
-    function realizeDiagnostic(diagnostic: Diagnostic, newLine: string): { message: string; start: number; length: number; category: string; } {
+    function realizeDiagnostic(diagnostic: Diagnostic, newLine: string): { message: string; start: number; length: number; category: string; code: number; } {
         return {
             message: flattenDiagnosticMessageText(diagnostic.messageText, newLine),
             start: diagnostic.start,

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

@@ -1,4 +1,4 @@
-tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,6): error TS2461: Type 'string | number' is not an array type.
+tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,6): error TS2461: Type 'number | string' is not an array type.
 tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,7): error TS2322: Type 'number' is not assignable to type 'string'.
 tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,14): error TS2322: Type 'string' is not assignable to type 'number'.
 
@@ -8,7 +8,7 @@ tests/cases/conformance/statements/for-ofStatements/ES5For-of30.ts(3,14): error
     var tuple: [number, string] = [2, "3"];
     for ([a = 1, b = ""] of tuple) {
          ~~~~~~~~~~~~~~~
-!!! error TS2461: Type 'string | number' is not an array type.
+!!! error TS2461: Type 'number | string' is not an array type.
           ~
 !!! error TS2322: Type 'number' is not assignable to type 'string'.
                  ~

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

@@ -1,4 +1,4 @@
-tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck11.ts(3,6): error TS2322: Type 'string | number' is not assignable to type 'string'.
+tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck11.ts(3,6): error TS2322: Type 'number | string' is not assignable to type 'string'.
   Type 'number' is not assignable to type 'string'.
 
 
@@ -7,5 +7,5 @@ tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck11.ts(3,6)
     var v: string;
     for (v of union) { }
          ~
-!!! error TS2322: Type 'string | number' is not assignable to type 'string'.
+!!! error TS2322: Type 'number | string' is not assignable to type 'string'.
 !!! error TS2322:   Type 'number' is not assignable to type 'string'.

tests/baselines/reference/ES5For-ofTypeCheck5.types

@@ -3,6 +3,6 @@ var union: string | number[];
 >union : string | number[]
 
 for (var v of union) { }
->v : string | number
+>v : number | string
 >union : string | number[]
 

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

@@ -1,8 +1,8 @@
-tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck9.ts(2,15): error TS2461: Type 'number | symbol | string[]' is not an array type.
+tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck9.ts(2,15): error TS2461: Type 'string[] | number | symbol' is not an array type.
 
 
 ==== tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck9.ts (1 errors) ====
     var union: string | string[] | number | symbol;
     for (let v of union) { }
                   ~~~~~
-!!! error TS2461: Type 'number | symbol | string[]' is not an array type.
+!!! error TS2461: Type 'string[] | number | symbol' is not an array type.

tests/baselines/reference/TypeGuardWithEnumUnion.types

@@ -6,14 +6,14 @@ enum Color { R, G, B }
 >B : Color
 
 function f1(x: Color | string) {
->f1 : (x: string | Color) => void
->x : string | Color
+>f1 : (x: Color | string) => void
+>x : Color | string
 >Color : Color
 
     if (typeof x === "number") {
 >typeof x === "number" : boolean
 >typeof x : string
->x : string | Color
+>x : Color | string
 >"number" : string
 
         var y = x;
@@ -35,14 +35,14 @@ function f1(x: Color | string) {
 }
 
 function f2(x: Color | string | string[]) {
->f2 : (x: string | Color | string[]) => void
->x : string | Color | string[]
+>f2 : (x: Color | string | string[]) => void
+>x : Color | string | string[]
 >Color : Color
 
     if (typeof x === "object") {
 >typeof x === "object" : boolean
 >typeof x : string
->x : string | Color | string[]
+>x : Color | string | string[]
 >"object" : string
 
         var y = x;
@@ -55,7 +55,7 @@ function f2(x: Color | string | string[]) {
     if (typeof x === "number") {
 >typeof x === "number" : boolean
 >typeof x : string
->x : string | Color | string[]
+>x : Color | string | string[]
 >"number" : string
 
         var z = x;
@@ -77,7 +77,7 @@ function f2(x: Color | string | string[]) {
     if (typeof x === "string") {
 >typeof x === "string" : boolean
 >typeof x : string
->x : string | Color | string[]
+>x : Color | string | string[]
 >"string" : string
 
         var a = x;

tests/baselines/reference/aliasUsageInOrExpression.types

@@ -34,7 +34,7 @@ var d2: IHasVisualizationModel = i || moduleA;
 var d2: IHasVisualizationModel = moduleA || i;
 >d2 : IHasVisualizationModel
 >IHasVisualizationModel : IHasVisualizationModel
->moduleA || i : IHasVisualizationModel
+>moduleA || i : typeof moduleA
 >moduleA : typeof moduleA
 >i : IHasVisualizationModel
 

tests/baselines/reference/aliasesInSystemModule1.errors.txt

@@ -0,0 +1,22 @@
+tests/cases/compiler/aliasesInSystemModule1.ts(2,24): error TS2307: Cannot find module 'foo'.
+
+
+==== tests/cases/compiler/aliasesInSystemModule1.ts (1 errors) ====
+    
+    import alias = require('foo');
+                           ~~~~~
+!!! error TS2307: Cannot find module 'foo'.
+    import cls = alias.Class;
+    export import cls2 = alias.Class;
+    
+    let x = new alias.Class();
+    let y = new cls();
+    let z = new cls2();
+    
+    module M {
+      export import cls = alias.Class;
+      let x = new alias.Class();
+      let y = new cls(); 
+      let z = new cls2();
+    }
+      

tests/baselines/reference/aliasesInSystemModule1.js

@@ -0,0 +1,42 @@
+//// [aliasesInSystemModule1.ts]
+
+import alias = require('foo');
+import cls = alias.Class;
+export import cls2 = alias.Class;
+
+let x = new alias.Class();
+let y = new cls();
+let z = new cls2();
+
+module M {
+  export import cls = alias.Class;
+  let x = new alias.Class();
+  let y = new cls(); 
+  let z = new cls2();
+}
+  
+
+//// [aliasesInSystemModule1.js]
+System.register(['foo'], function(exports_1) {
+    var alias;
+    var cls, cls2, x, y, z, M;
+    return {
+        setters:[
+            function (_alias) {
+                alias = _alias;
+            }],
+        execute: function() {
+            cls = alias.Class;
+            exports_1("cls2", cls2 = alias.Class);
+            x = new alias.Class();
+            y = new cls();
+            z = new cls2();
+            (function (M) {
+                M.cls = alias.Class;
+                var x = new alias.Class();
+                var y = new M.cls();
+                var z = new cls2();
+            })(M || (M = {}));
+        }
+    }
+});

tests/baselines/reference/aliasesInSystemModule2.errors.txt

@@ -0,0 +1,21 @@
+tests/cases/compiler/aliasesInSystemModule2.ts(2,21): error TS2307: Cannot find module 'foo'.
+
+
+==== tests/cases/compiler/aliasesInSystemModule2.ts (1 errors) ====
+    
+    import {alias} from "foo";
+                        ~~~~~
+!!! error TS2307: Cannot find module 'foo'.
+    import cls = alias.Class;
+    export import cls2 = alias.Class;
+    
+    let x = new alias.Class();
+    let y = new cls();
+    let z = new cls2();
+    
+    module M {
+      export import cls = alias.Class;
+      let x = new alias.Class();
+      let y = new cls(); 
+      let z = new cls2();
+    }

tests/baselines/reference/aliasesInSystemModule2.js

@@ -0,0 +1,41 @@
+//// [aliasesInSystemModule2.ts]
+
+import {alias} from "foo";
+import cls = alias.Class;
+export import cls2 = alias.Class;
+
+let x = new alias.Class();
+let y = new cls();
+let z = new cls2();
+
+module M {
+  export import cls = alias.Class;
+  let x = new alias.Class();
+  let y = new cls(); 
+  let z = new cls2();
+}
+
+//// [aliasesInSystemModule2.js]
+System.register(["foo"], function(exports_1) {
+    var foo_1;
+    var cls, cls2, x, y, z, M;
+    return {
+        setters:[
+            function (_foo_1) {
+                foo_1 = _foo_1;
+            }],
+        execute: function() {
+            cls = foo_1.alias.Class;
+            exports_1("cls2", cls2 = foo_1.alias.Class);
+            x = new foo_1.alias.Class();
+            y = new cls();
+            z = new cls2();
+            (function (M) {
+                M.cls = foo_1.alias.Class;
+                var x = new foo_1.alias.Class();
+                var y = new M.cls();
+                var z = new cls2();
+            })(M || (M = {}));
+        }
+    }
+});

tests/baselines/reference/arityAndOrderCompatibility01.errors.txt

@@ -1,6 +1,7 @@
 tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(13,12): error TS2493: Tuple type '[string, number]' with length '2' cannot be assigned to tuple with length '3'.
 tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(14,12): error TS2460: Type 'StrNum' has no property '2'.
 tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(15,5): error TS2461: Type '{ 0: string; 1: number; }' is not an array type.
+tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(15,12): error TS2460: Type '{ 0: string; 1: number; }' has no property '2'.
 tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(16,5): error TS2322: Type '[string, number]' is not assignable to type '[number, number, number]'.
   Types of property '0' are incompatible.
     Type 'string' is not assignable to type 'number'.
@@ -46,7 +47,7 @@ tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(30,5): error
     Type 'string' is not assignable to type 'number'.
 
 
-==== tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts (18 errors) ====
+==== tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts (19 errors) ====
     interface StrNum extends Array<string|number> {
         0: string;
         1: number;
@@ -68,6 +69,8 @@ tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(30,5): error
     var [g, h, i] = z;
         ~~~~~~~~~
 !!! error TS2461: Type '{ 0: string; 1: number; }' is not an array type.
+               ~
+!!! error TS2460: Type '{ 0: string; 1: number; }' has no property '2'.
     var j1: [number, number, number] = x;
         ~~
 !!! error TS2322: Type '[string, number]' is not assignable to type '[number, number, number]'.

tests/baselines/reference/arrayBestCommonTypes.types

@@ -294,8 +294,8 @@ module EmptyTypes {
 
             // 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; }[]
+>a1 : ({ x: number; y: string; } | { x: string; y: string; } | { x: any; y: string; })[]
+>[{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }] : ({ x: number; y: string; } | { x: string; y: string; } | { x: any; y: string; })[]
 >{ x: 0, y: 'a' } : { x: number; y: string; }
 >x : number
 >0 : number
@@ -313,8 +313,8 @@ module EmptyTypes {
 >'a' : 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; }[]
+>a2 : ({ x: any; y: string; } | { x: number; y: string; } | { x: string; y: string; })[]
+>[{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }] : ({ x: any; y: string; } | { x: number; y: string; } | { x: string; y: string; })[]
 >{ x: anyObj, y: 'a' } : { x: any; y: string; }
 >x : any
 >anyObj : any
@@ -332,8 +332,8 @@ module EmptyTypes {
 >'a' : 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; }[]
+>a3 : ({ x: number; y: string; } | { x: any; y: string; } | { x: string; y: string; })[]
+>[{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }] : ({ x: number; y: string; } | { x: any; y: string; } | { x: string; y: string; })[]
 >{ x: 0, y: 'a' } : { x: number; y: string; }
 >x : number
 >0 : number
@@ -366,22 +366,22 @@ module EmptyTypes {
 >base2 : typeof base2
 
             var b1 = [baseObj, base2Obj, ifaceObj];
->b1 : iface[]
->[baseObj, base2Obj, ifaceObj] : iface[]
+>b1 : base[]
+>[baseObj, base2Obj, ifaceObj] : base[]
 >baseObj : base
 >base2Obj : base2
 >ifaceObj : iface
 
             var b2 = [base2Obj, baseObj, ifaceObj];
->b2 : iface[]
->[base2Obj, baseObj, ifaceObj] : iface[]
+>b2 : base2[]
+>[base2Obj, baseObj, ifaceObj] : base2[]
 >base2Obj : base2
 >baseObj : base
 >ifaceObj : iface
 
             var b3 = [baseObj, ifaceObj, base2Obj];
->b3 : iface[]
->[baseObj, ifaceObj, base2Obj] : iface[]
+>b3 : base[]
+>[baseObj, ifaceObj, base2Obj] : base[]
 >baseObj : base
 >ifaceObj : iface
 >base2Obj : base2
@@ -639,7 +639,7 @@ module NonEmptyTypes {
 >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: number; y: base; })[]
 >{ x: 7, y: new derived() } : { x: number; y: derived; }
 >x : number
 >7 : number
@@ -658,7 +658,7 @@ module NonEmptyTypes {
 >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: boolean; y: base; })[]
 >{ x: true, y: new derived() } : { x: boolean; y: derived; }
 >x : boolean
 >true : boolean
@@ -697,8 +697,8 @@ module NonEmptyTypes {
 
             // 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; }[]
+>a1 : ({ x: number; y: string; } | { x: string; y: string; } | { x: any; y: string; })[]
+>[{ x: 0, y: 'a' }, { x: 'a', y: 'a' }, { x: anyObj, y: 'a' }] : ({ x: number; y: string; } | { x: string; y: string; } | { x: any; y: string; })[]
 >{ x: 0, y: 'a' } : { x: number; y: string; }
 >x : number
 >0 : number
@@ -716,8 +716,8 @@ module NonEmptyTypes {
 >'a' : 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; }[]
+>a2 : ({ x: any; y: string; } | { x: number; y: string; } | { x: string; y: string; })[]
+>[{ x: anyObj, y: 'a' }, { x: 0, y: 'a' }, { x: 'a', y: 'a' }] : ({ x: any; y: string; } | { x: number; y: string; } | { x: string; y: string; })[]
 >{ x: anyObj, y: 'a' } : { x: any; y: string; }
 >x : any
 >anyObj : any
@@ -735,8 +735,8 @@ module NonEmptyTypes {
 >'a' : 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; }[]
+>a3 : ({ x: number; y: string; } | { x: any; y: string; } | { x: string; y: string; })[]
+>[{ x: 0, y: 'a' }, { x: anyObj, y: 'a' }, { x: 'a', y: 'a' }] : ({ x: number; y: string; } | { x: any; y: string; } | { x: string; y: string; })[]
 >{ x: 0, y: 'a' } : { x: number; y: string; }
 >x : number
 >0 : number
@@ -769,29 +769,29 @@ module NonEmptyTypes {
 >base2 : typeof base2
 
             var b1 = [baseObj, base2Obj, ifaceObj];
->b1 : iface[]
->[baseObj, base2Obj, ifaceObj] : iface[]
+>b1 : (base | base2 | iface)[]
+>[baseObj, base2Obj, ifaceObj] : (base | base2 | iface)[]
 >baseObj : base
 >base2Obj : base2
 >ifaceObj : iface
 
             var b2 = [base2Obj, baseObj, ifaceObj];
->b2 : iface[]
->[base2Obj, baseObj, ifaceObj] : iface[]
+>b2 : (base2 | base | iface)[]
+>[base2Obj, baseObj, ifaceObj] : (base2 | base | iface)[]
 >base2Obj : base2
 >baseObj : base
 >ifaceObj : iface
 
             var b3 = [baseObj, ifaceObj, base2Obj];
->b3 : iface[]
->[baseObj, ifaceObj, base2Obj] : iface[]
+>b3 : (base | iface | base2)[]
+>[baseObj, ifaceObj, base2Obj] : (base | iface | base2)[]
 >baseObj : base
 >ifaceObj : iface
 >base2Obj : base2
 
             var b4 = [ifaceObj, baseObj, base2Obj];
->b4 : iface[]
->[ifaceObj, baseObj, base2Obj] : iface[]
+>b4 : (iface | base | base2)[]
+>[ifaceObj, baseObj, base2Obj] : (iface | base | base2)[]
 >ifaceObj : iface
 >baseObj : base
 >base2Obj : base2

tests/baselines/reference/arrayCast.errors.txt

@@ -1,6 +1,6 @@
 tests/cases/compiler/arrayCast.ts(3,1): error TS2352: Neither type '{ foo: string; }[]' nor type '{ id: number; }[]' is assignable to the other.
   Type '{ foo: string; }' is not assignable to type '{ id: number; }'.
-    Property 'id' is missing in type '{ foo: string; }'.
+    Object literal may only specify known properties, and 'foo' does not exist in type '{ id: number; }'.
 
 
 ==== tests/cases/compiler/arrayCast.ts (1 errors) ====
@@ -10,7 +10,7 @@ tests/cases/compiler/arrayCast.ts(3,1): error TS2352: Neither type '{ foo: strin
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2352: Neither type '{ foo: string; }[]' nor type '{ id: number; }[]' is assignable to the other.
 !!! error TS2352:   Type '{ foo: string; }' is not assignable to type '{ id: number; }'.
-!!! error TS2352:     Property 'id' is missing in type '{ foo: string; }'.
+!!! error TS2352:     Object literal may only specify known properties, and 'foo' does not exist in type '{ id: number; }'.
     
     // Should succeed, as the {} element causes the type of the array to be {}[]
     <{ id: number; }[]>[{ foo: "s" }, {}]; 

tests/baselines/reference/arrayLiteralExpressionContextualTyping.errors.txt

@@ -1,7 +1,7 @@
 tests/cases/conformance/expressions/contextualTyping/arrayLiteralExpressionContextualTyping.ts(8,5): error TS2322: Type '[number, number, number, string]' is not assignable to type '[number, number, number]'.
   Types of property 'pop' are incompatible.
-    Type '() => string | number' is not assignable to type '() => number'.
-      Type 'string | number' is not assignable to type 'number'.
+    Type '() => number | string' is not assignable to type '() => number'.
+      Type 'number | string' is not assignable to type 'number'.
         Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/expressions/contextualTyping/arrayLiteralExpressionContextualTyping.ts(14,5): error TS2322: Type 'number[]' is not assignable to type '[number, number, number]'.
   Property '0' is missing in type 'number[]'.
@@ -19,8 +19,8 @@ tests/cases/conformance/expressions/contextualTyping/arrayLiteralExpressionConte
         ~~~~
 !!! error TS2322: Type '[number, number, number, string]' is not assignable to type '[number, number, number]'.
 !!! error TS2322:   Types of property 'pop' are incompatible.
-!!! 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 '() => number | string' is not assignable to type '() => number'.
+!!! error TS2322:       Type 'number | string' is not assignable to type 'number'.
 !!! error TS2322:         Type 'string' is not assignable to type 'number'.
     
     // In a contextually typed array literal expression containing one or more spread elements,

tests/baselines/reference/arrayLiteralTypeInference.errors.txt

@@ -0,0 +1,72 @@
+tests/cases/compiler/arrayLiteralTypeInference.ts(13,5): error TS2322: Type '({ id: number; trueness: boolean; } | { id: number; name: string; })[]' is not assignable to type 'Action[]'.
+  Type '{ id: number; trueness: boolean; } | { id: number; name: string; }' is not assignable to type 'Action'.
+    Type '{ id: number; trueness: boolean; }' is not assignable to type 'Action'.
+      Object literal may only specify known properties, and 'trueness' does not exist in type 'Action'.
+tests/cases/compiler/arrayLiteralTypeInference.ts(29,5): error TS2322: Type '({ id: number; trueness: boolean; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
+  Type '{ id: number; trueness: boolean; } | { id: number; name: string; }' is not assignable to type '{ id: number; }'.
+    Type '{ id: number; trueness: boolean; }' is not assignable to type '{ id: number; }'.
+      Object literal may only specify known properties, and 'trueness' does not exist in type '{ id: number; }'.
+
+
+==== tests/cases/compiler/arrayLiteralTypeInference.ts (2 errors) ====
+    class Action {
+        id: number;
+    }
+    
+    class ActionA extends Action {
+        value: string;
+    }
+    
+    class ActionB extends Action {
+        trueNess: boolean;
+    }
+    
+    var x1: Action[] = [
+        ~~
+!!! error TS2322: Type '({ id: number; trueness: boolean; } | { id: number; name: string; })[]' is not assignable to type 'Action[]'.
+!!! error TS2322:   Type '{ id: number; trueness: boolean; } | { id: number; name: string; }' is not assignable to type 'Action'.
+!!! error TS2322:     Type '{ id: number; trueness: boolean; }' is not assignable to type 'Action'.
+!!! error TS2322:       Object literal may only specify known properties, and 'trueness' does not exist in type 'Action'.
+        { id: 2, trueness: false },
+        { id: 3, name: "three" }
+    ]
+    
+    var x2: Action[] = [
+        new ActionA(),
+        new ActionB()
+    ]
+    
+    var x3: Action[] = [
+        new Action(),
+        new ActionA(),
+        new ActionB()
+    ]
+    
+    var z1: { id: number }[] =
+        ~~
+!!! error TS2322: Type '({ id: number; trueness: boolean; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
+!!! error TS2322:   Type '{ id: number; trueness: boolean; } | { id: number; name: string; }' is not assignable to type '{ id: number; }'.
+!!! error TS2322:     Type '{ id: number; trueness: boolean; }' is not assignable to type '{ id: number; }'.
+!!! error TS2322:       Object literal may only specify known properties, and 'trueness' does not exist in type '{ id: number; }'.
+        [
+            { id: 2, trueness: false },
+            { id: 3, name: "three" }
+        ]
+    
+    var z2: { id: number }[] =
+        [
+            new ActionA(),
+            new ActionB()
+        ]
+    
+    var z3: { id: number }[] =
+        [
+            new Action(),
+            new ActionA(),
+            new ActionB()
+        ]
+    
+    
+    
+    
+    

tests/baselines/reference/arrayLiteralTypeInference.symbols

@@ -1,113 +0,0 @@
-=== tests/cases/compiler/arrayLiteralTypeInference.ts ===
-class Action {
->Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0))
-
-    id: number;
->id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 0, 14))
-}
-
-class ActionA extends Action {
->ActionA : Symbol(ActionA, Decl(arrayLiteralTypeInference.ts, 2, 1))
->Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0))
-
-    value: string;
->value : Symbol(value, Decl(arrayLiteralTypeInference.ts, 4, 30))
-}
-
-class ActionB extends Action {
->ActionB : Symbol(ActionB, Decl(arrayLiteralTypeInference.ts, 6, 1))
->Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0))
-
-    trueNess: boolean;
->trueNess : Symbol(trueNess, Decl(arrayLiteralTypeInference.ts, 8, 30))
-}
-
-var x1: Action[] = [
->x1 : Symbol(x1, Decl(arrayLiteralTypeInference.ts, 12, 3))
->Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0))
-
-    { id: 2, trueness: false },
->id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 13, 5))
->trueness : Symbol(trueness, Decl(arrayLiteralTypeInference.ts, 13, 12))
-
-    { id: 3, name: "three" }
->id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 14, 5))
->name : Symbol(name, Decl(arrayLiteralTypeInference.ts, 14, 12))
-
-]
-
-var x2: Action[] = [
->x2 : Symbol(x2, Decl(arrayLiteralTypeInference.ts, 17, 3))
->Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0))
-
-    new ActionA(),
->ActionA : Symbol(ActionA, Decl(arrayLiteralTypeInference.ts, 2, 1))
-
-    new ActionB()
->ActionB : Symbol(ActionB, Decl(arrayLiteralTypeInference.ts, 6, 1))
-
-]
-
-var x3: Action[] = [
->x3 : Symbol(x3, Decl(arrayLiteralTypeInference.ts, 22, 3))
->Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0))
-
-    new Action(),
->Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0))
-
-    new ActionA(),
->ActionA : Symbol(ActionA, Decl(arrayLiteralTypeInference.ts, 2, 1))
-
-    new ActionB()
->ActionB : Symbol(ActionB, Decl(arrayLiteralTypeInference.ts, 6, 1))
-
-]
-
-var z1: { id: number }[] =
->z1 : Symbol(z1, Decl(arrayLiteralTypeInference.ts, 28, 3))
->id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 28, 9))
-
-    [
-        { id: 2, trueness: false },
->id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 30, 9))
->trueness : Symbol(trueness, Decl(arrayLiteralTypeInference.ts, 30, 16))
-
-        { id: 3, name: "three" }
->id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 31, 9))
->name : Symbol(name, Decl(arrayLiteralTypeInference.ts, 31, 16))
-
-    ]
-
-var z2: { id: number }[] =
->z2 : Symbol(z2, Decl(arrayLiteralTypeInference.ts, 34, 3))
->id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 34, 9))
-
-    [
-        new ActionA(),
->ActionA : Symbol(ActionA, Decl(arrayLiteralTypeInference.ts, 2, 1))
-
-        new ActionB()
->ActionB : Symbol(ActionB, Decl(arrayLiteralTypeInference.ts, 6, 1))
-
-    ]
-
-var z3: { id: number }[] =
->z3 : Symbol(z3, Decl(arrayLiteralTypeInference.ts, 40, 3))
->id : Symbol(id, Decl(arrayLiteralTypeInference.ts, 40, 9))
-
-    [
-        new Action(),
->Action : Symbol(Action, Decl(arrayLiteralTypeInference.ts, 0, 0))
-
-        new ActionA(),
->ActionA : Symbol(ActionA, Decl(arrayLiteralTypeInference.ts, 2, 1))
-
-        new ActionB()
->ActionB : Symbol(ActionB, Decl(arrayLiteralTypeInference.ts, 6, 1))
-
-    ]
-
-
-
-
-

tests/baselines/reference/arrayLiteralTypeInference.types

@@ -1,144 +0,0 @@
-=== tests/cases/compiler/arrayLiteralTypeInference.ts ===
-class Action {
->Action : Action
-
-    id: number;
->id : number
-}
-
-class ActionA extends Action {
->ActionA : ActionA
->Action : Action
-
-    value: string;
->value : string
-}
-
-class ActionB extends Action {
->ActionB : ActionB
->Action : Action
-
-    trueNess: boolean;
->trueNess : boolean
-}
-
-var x1: Action[] = [
->x1 : Action[]
->Action : Action
->[    { id: 2, trueness: false },    { id: 3, name: "three" }] : ({ id: number; trueness: boolean; } | { id: number; name: string; })[]
-
-    { id: 2, trueness: false },
->{ id: 2, trueness: false } : { id: number; trueness: boolean; }
->id : number
->2 : number
->trueness : boolean
->false : boolean
-
-    { id: 3, name: "three" }
->{ id: 3, name: "three" } : { id: number; name: string; }
->id : number
->3 : number
->name : string
->"three" : string
-
-]
-
-var x2: Action[] = [
->x2 : Action[]
->Action : Action
->[    new ActionA(),    new ActionB()] : (ActionA | ActionB)[]
-
-    new ActionA(),
->new ActionA() : ActionA
->ActionA : typeof ActionA
-
-    new ActionB()
->new ActionB() : ActionB
->ActionB : typeof ActionB
-
-]
-
-var x3: Action[] = [
->x3 : Action[]
->Action : Action
->[    new Action(),    new ActionA(),    new ActionB()] : Action[]
-
-    new Action(),
->new Action() : Action
->Action : typeof Action
-
-    new ActionA(),
->new ActionA() : ActionA
->ActionA : typeof ActionA
-
-    new ActionB()
->new ActionB() : ActionB
->ActionB : typeof ActionB
-
-]
-
-var z1: { id: number }[] =
->z1 : { id: number; }[]
->id : number
-
-    [
->[        { id: 2, trueness: false },        { id: 3, name: "three" }    ] : ({ id: number; trueness: boolean; } | { id: number; name: string; })[]
-
-        { id: 2, trueness: false },
->{ id: 2, trueness: false } : { id: number; trueness: boolean; }
->id : number
->2 : number
->trueness : boolean
->false : boolean
-
-        { id: 3, name: "three" }
->{ id: 3, name: "three" } : { id: number; name: string; }
->id : number
->3 : number
->name : string
->"three" : string
-
-    ]
-
-var z2: { id: number }[] =
->z2 : { id: number; }[]
->id : number
-
-    [
->[        new ActionA(),        new ActionB()    ] : (ActionA | ActionB)[]
-
-        new ActionA(),
->new ActionA() : ActionA
->ActionA : typeof ActionA
-
-        new ActionB()
->new ActionB() : ActionB
->ActionB : typeof ActionB
-
-    ]
-
-var z3: { id: number }[] =
->z3 : { id: number; }[]
->id : number
-
-    [
->[        new Action(),        new ActionA(),        new ActionB()    ] : Action[]
-
-        new Action(),
->new Action() : Action
->Action : typeof Action
-
-        new ActionA(),
->new ActionA() : ActionA
->ActionA : typeof ActionA
-
-        new ActionB()
->new ActionB() : ActionB
->ActionB : typeof ActionB
-
-    ]
-
-
-
-
-

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; y?: number; } | { x: number; z?: number; })[]
->[b, a] : ({ x: number; y?: number; } | { x: number; z?: number; })[]
+>bs : ({ x: number; z?: number; } | { x: number; y?: number; })[]
+>[b, a] : ({ x: number; z?: number; } | { x: number; y?: number; })[]
 >b : { x: number; z?: number; }
 >a : { x: number; y?: number; }
 
@@ -36,8 +36,8 @@ var cs = [a, b, c]; // { x: number; y?: number };[]
 >c : { x: number; a?: number; }
 
 var ds = [(x: Object) => 1, (x: string) => 2]; // { (x:Object) => number }[]
->ds : ((x: Object) => number)[]
->[(x: Object) => 1, (x: string) => 2] : ((x: Object) => number)[]
+>ds : (((x: Object) => number) | ((x: string) => number))[]
+>[(x: Object) => 1, (x: string) => 2] : (((x: Object) => number) | ((x: string) => number))[]
 >(x: Object) => 1 : (x: Object) => number
 >x : Object
 >Object : Object
@@ -47,8 +47,8 @@ var ds = [(x: Object) => 1, (x: string) => 2]; // { (x:Object) => number }[]
 >2 : number
 
 var es = [(x: string) => 2, (x: Object) => 1]; // { (x:string) => number }[]
->es : ((x: string) => number)[]
->[(x: string) => 2, (x: Object) => 1] : ((x: string) => number)[]
+>es : (((x: string) => number) | ((x: Object) => number))[]
+>[(x: string) => 2, (x: Object) => 1] : (((x: string) => number) | ((x: Object) => number))[]
 >(x: string) => 2 : (x: string) => number
 >x : string
 >2 : number

tests/baselines/reference/arrayLiterals.errors.txt

@@ -0,0 +1,50 @@
+tests/cases/conformance/expressions/arrayLiterals/arrayLiterals.ts(24,5): error TS2322: Type '({ a: string; b: number; c: string; } | { a: string; b: number; c: number; })[]' is not assignable to type '{ [n: number]: { a: string; b: number; }; }'.
+  Index signatures are incompatible.
+    Type '{ a: string; b: number; c: string; } | { a: string; b: number; c: number; }' is not assignable to type '{ a: string; b: number; }'.
+      Type '{ a: string; b: number; c: string; }' is not assignable to type '{ a: string; b: number; }'.
+        Object literal may only specify known properties, and 'c' does not exist in type '{ a: string; b: number; }'.
+
+
+==== tests/cases/conformance/expressions/arrayLiterals/arrayLiterals.ts (1 errors) ====
+    // Empty array literal with no contextual type has type Undefined[]
+    
+    var arr1= [[], [1], ['']];
+    
+    var arr2 = [[null], [1], ['']];
+    
+    
+    // Array literal with elements of only EveryType E has type E[]
+    var stringArrArr = [[''], [""]];
+    
+    var stringArr = ['', ""];
+    
+    var numberArr = [0, 0.0, 0x00, 1e1];
+    
+    var boolArr = [false, true, false, true];
+    
+    class C { private p; }
+    var classArr = [new C(), new C()];
+    
+    var classTypeArray = [C, C, C];
+    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 }];
+        ~~~~~~~~
+!!! error TS2322: Type '({ a: string; b: number; c: string; } | { a: string; b: number; c: number; })[]' is not assignable to type '{ [n: number]: { a: string; b: number; }; }'.
+!!! error TS2322:   Index signatures are incompatible.
+!!! error TS2322:     Type '{ a: string; b: number; c: string; } | { a: string; b: number; c: number; }' is not assignable to type '{ a: string; b: number; }'.
+!!! error TS2322:       Type '{ a: string; b: number; c: string; }' is not assignable to type '{ a: string; b: number; }'.
+!!! error TS2322:         Object literal may only specify known properties, and 'c' does not exist in type '{ a: string; b: number; }'.
+    var context2 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
+    
+    // Contextual type C with numeric index signature of type Base makes array literal of Derived have type Base[]
+    class Base { private p; }
+    class Derived1 extends Base { private m };
+    class Derived2 extends Base { private n };
+    var context3: Base[] = [new Derived1(), new Derived2()];
+    
+    // Contextual type C with numeric index signature of type Base makes array literal of Derived1 and Derived2 have type Base[]
+    var context4: Base[] = [new Derived1(), new Derived1()];
+    
+    

tests/baselines/reference/arrayLiterals.symbols

@@ -1,94 +0,0 @@
-=== tests/cases/conformance/expressions/arrayLiterals/arrayLiterals.ts ===
-// Empty array literal with no contextual type has type Undefined[]
-
-var arr1= [[], [1], ['']];
->arr1 : Symbol(arr1, Decl(arrayLiterals.ts, 2, 3))
-
-var arr2 = [[null], [1], ['']];
->arr2 : Symbol(arr2, Decl(arrayLiterals.ts, 4, 3))
-
-
-// Array literal with elements of only EveryType E has type E[]
-var stringArrArr = [[''], [""]];
->stringArrArr : Symbol(stringArrArr, Decl(arrayLiterals.ts, 8, 3))
-
-var stringArr = ['', ""];
->stringArr : Symbol(stringArr, Decl(arrayLiterals.ts, 10, 3))
-
-var numberArr = [0, 0.0, 0x00, 1e1];
->numberArr : Symbol(numberArr, Decl(arrayLiterals.ts, 12, 3))
-
-var boolArr = [false, true, false, true];
->boolArr : Symbol(boolArr, Decl(arrayLiterals.ts, 14, 3))
-
-class C { private p; }
->C : Symbol(C, Decl(arrayLiterals.ts, 14, 41))
->p : Symbol(p, Decl(arrayLiterals.ts, 16, 9))
-
-var classArr = [new C(), new C()];
->classArr : Symbol(classArr, Decl(arrayLiterals.ts, 17, 3))
->C : Symbol(C, Decl(arrayLiterals.ts, 14, 41))
->C : Symbol(C, Decl(arrayLiterals.ts, 14, 41))
-
-var classTypeArray = [C, C, C];
->classTypeArray : Symbol(classTypeArray, Decl(arrayLiterals.ts, 19, 3), Decl(arrayLiterals.ts, 20, 3))
->C : Symbol(C, Decl(arrayLiterals.ts, 14, 41))
->C : Symbol(C, Decl(arrayLiterals.ts, 14, 41))
->C : Symbol(C, Decl(arrayLiterals.ts, 14, 41))
-
-var classTypeArray: Array<typeof C>; // Should OK, not be a parse error
->classTypeArray : Symbol(classTypeArray, Decl(arrayLiterals.ts, 19, 3), Decl(arrayLiterals.ts, 20, 3))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
->C : Symbol(C, Decl(arrayLiterals.ts, 14, 41))
-
-// 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 }];
->context1 : Symbol(context1, Decl(arrayLiterals.ts, 23, 3))
->n : Symbol(n, Decl(arrayLiterals.ts, 23, 17))
->a : Symbol(a, Decl(arrayLiterals.ts, 23, 30))
->b : Symbol(b, Decl(arrayLiterals.ts, 23, 41))
->a : Symbol(a, Decl(arrayLiterals.ts, 23, 62))
->b : Symbol(b, Decl(arrayLiterals.ts, 23, 69))
->c : Symbol(c, Decl(arrayLiterals.ts, 23, 75))
->a : Symbol(a, Decl(arrayLiterals.ts, 23, 86))
->b : Symbol(b, Decl(arrayLiterals.ts, 23, 93))
->c : Symbol(c, Decl(arrayLiterals.ts, 23, 99))
-
-var context2 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
->context2 : Symbol(context2, Decl(arrayLiterals.ts, 24, 3))
->a : Symbol(a, Decl(arrayLiterals.ts, 24, 17))
->b : Symbol(b, Decl(arrayLiterals.ts, 24, 24))
->c : Symbol(c, Decl(arrayLiterals.ts, 24, 30))
->a : Symbol(a, Decl(arrayLiterals.ts, 24, 41))
->b : Symbol(b, Decl(arrayLiterals.ts, 24, 48))
->c : Symbol(c, Decl(arrayLiterals.ts, 24, 54))
-
-// Contextual type C with numeric index signature of type Base makes array literal of Derived have type Base[]
-class Base { private p; }
->Base : Symbol(Base, Decl(arrayLiterals.ts, 24, 63))
->p : Symbol(p, Decl(arrayLiterals.ts, 27, 12))
-
-class Derived1 extends Base { private m };
->Derived1 : Symbol(Derived1, Decl(arrayLiterals.ts, 27, 25))
->Base : Symbol(Base, Decl(arrayLiterals.ts, 24, 63))
->m : Symbol(m, Decl(arrayLiterals.ts, 28, 29))
-
-class Derived2 extends Base { private n };
->Derived2 : Symbol(Derived2, Decl(arrayLiterals.ts, 28, 42))
->Base : Symbol(Base, Decl(arrayLiterals.ts, 24, 63))
->n : Symbol(n, Decl(arrayLiterals.ts, 29, 29))
-
-var context3: Base[] = [new Derived1(), new Derived2()];
->context3 : Symbol(context3, Decl(arrayLiterals.ts, 30, 3))
->Base : Symbol(Base, Decl(arrayLiterals.ts, 24, 63))
->Derived1 : Symbol(Derived1, Decl(arrayLiterals.ts, 27, 25))
->Derived2 : Symbol(Derived2, Decl(arrayLiterals.ts, 28, 42))
-
-// Contextual type C with numeric index signature of type Base makes array literal of Derived1 and Derived2 have type Base[]
-var context4: Base[] = [new Derived1(), new Derived1()];
->context4 : Symbol(context4, Decl(arrayLiterals.ts, 33, 3))
->Base : Symbol(Base, Decl(arrayLiterals.ts, 24, 63))
->Derived1 : Symbol(Derived1, Decl(arrayLiterals.ts, 27, 25))
->Derived1 : Symbol(Derived1, Decl(arrayLiterals.ts, 27, 25))
-
-

tests/baselines/reference/arrayLiterals.types

@@ -1,153 +0,0 @@
-=== tests/cases/conformance/expressions/arrayLiterals/arrayLiterals.ts ===
-// Empty array literal with no contextual type has type Undefined[]
-
-var arr1= [[], [1], ['']];
->arr1 : (number[] | string[])[]
->[[], [1], ['']] : (number[] | string[])[]
->[] : undefined[]
->[1] : number[]
->1 : number
->[''] : string[]
->'' : string
-
-var arr2 = [[null], [1], ['']];
->arr2 : (number[] | string[])[]
->[[null], [1], ['']] : (number[] | string[])[]
->[null] : null[]
->null : null
->[1] : number[]
->1 : number
->[''] : string[]
->'' : string
-
-
-// Array literal with elements of only EveryType E has type E[]
-var stringArrArr = [[''], [""]];
->stringArrArr : string[][]
->[[''], [""]] : string[][]
->[''] : string[]
->'' : string
->[""] : string[]
->"" : string
-
-var stringArr = ['', ""];
->stringArr : string[]
->['', ""] : string[]
->'' : string
->"" : string
-
-var numberArr = [0, 0.0, 0x00, 1e1];
->numberArr : number[]
->[0, 0.0, 0x00, 1e1] : number[]
->0 : number
->0.0 : number
->0x00 : number
->1e1 : number
-
-var boolArr = [false, true, false, true];
->boolArr : boolean[]
->[false, true, false, true] : boolean[]
->false : boolean
->true : boolean
->false : boolean
->true : boolean
-
-class C { private p; }
->C : C
->p : any
-
-var classArr = [new C(), new C()];
->classArr : C[]
->[new C(), new C()] : C[]
->new C() : C
->C : typeof C
->new C() : C
->C : typeof C
-
-var classTypeArray = [C, C, C];
->classTypeArray : typeof C[]
->[C, C, C] : typeof C[]
->C : typeof C
->C : typeof C
->C : typeof C
-
-var classTypeArray: Array<typeof C>; // Should OK, not be a parse error
->classTypeArray : typeof C[]
->Array : T[]
->C : typeof C
-
-// 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 }];
->context1 : { [n: number]: { a: string; b: number; }; }
->n : number
->a : string
->b : number
->[{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }] : ({ a: string; b: number; c: string; } | { a: string; b: number; c: number; })[]
->{ a: '', b: 0, c: '' } : { a: string; b: number; c: string; }
->a : string
->'' : string
->b : number
->0 : number
->c : string
->'' : string
->{ a: "", b: 3, c: 0 } : { a: string; b: number; c: number; }
->a : string
->"" : string
->b : number
->3 : number
->c : number
->0 : number
-
-var context2 = [{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }];
->context2 : ({ a: string; b: number; c: string; } | { a: string; b: number; c: number; })[]
->[{ a: '', b: 0, c: '' }, { a: "", b: 3, c: 0 }] : ({ a: string; b: number; c: string; } | { a: string; b: number; c: number; })[]
->{ a: '', b: 0, c: '' } : { a: string; b: number; c: string; }
->a : string
->'' : string
->b : number
->0 : number
->c : string
->'' : string
->{ a: "", b: 3, c: 0 } : { a: string; b: number; c: number; }
->a : string
->"" : string
->b : number
->3 : number
->c : number
->0 : number
-
-// Contextual type C with numeric index signature of type Base makes array literal of Derived have type Base[]
-class Base { private p; }
->Base : Base
->p : any
-
-class Derived1 extends Base { private m };
->Derived1 : Derived1
->Base : Base
->m : any
-
-class Derived2 extends Base { private n };
->Derived2 : Derived2
->Base : Base
->n : any
-
-var context3: Base[] = [new Derived1(), new Derived2()];
->context3 : Base[]
->Base : Base
->[new Derived1(), new Derived2()] : (Derived1 | Derived2)[]
->new Derived1() : Derived1
->Derived1 : typeof Derived1
->new Derived2() : Derived2
->Derived2 : typeof Derived2
-
-// Contextual type C with numeric index signature of type Base makes array literal of Derived1 and Derived2 have type Base[]
-var context4: Base[] = [new Derived1(), new Derived1()];
->context4 : Base[]
->Base : Base
->[new Derived1(), new Derived1()] : Derived1[]
->new Derived1() : Derived1
->Derived1 : typeof Derived1
->new Derived1() : Derived1
->Derived1 : typeof Derived1
-
-

tests/baselines/reference/arrayLiterals2ES5.types

@@ -24,8 +24,8 @@ var a1 = ["hello", "world"]
 >"world" : string
 
 var a2 = [, , , ...a0, "hello"];
->a2 : (string | number)[]
->[, , , ...a0, "hello"] : (string | number)[]
+>a2 : (number | string)[]
+>[, , , ...a0, "hello"] : (number | string)[]
 > : undefined
 > : undefined
 > : undefined
@@ -151,8 +151,8 @@ interface myArray2 extends Array<Number|String> { }
 >String : String
 
 var d0 = [1, true, ...temp,];  // has type (string|number|boolean)[]
->d0 : (string | number | boolean)[]
->[1, true, ...temp,] : (string | number | boolean)[]
+>d0 : (number | boolean | string)[]
+>[1, true, ...temp,] : (number | boolean | string)[]
 >1 : number
 >true : boolean
 >...temp : string
@@ -214,8 +214,8 @@ var d8: number[][] = [[...temp1]]
 >temp1 : number[]
 
 var d9 = [[...temp1], ...["hello"]];
->d9 : (string | number[])[]
->[[...temp1], ...["hello"]] : (string | number[])[]
+>d9 : (number[] | string)[]
+>[[...temp1], ...["hello"]] : (number[] | string)[]
 >[...temp1] : number[]
 >...temp1 : number
 >temp1 : number[]

tests/baselines/reference/arrayLiterals2ES6.types

@@ -24,8 +24,8 @@ var a1 = ["hello", "world"]
 >"world" : string
 
 var a2 = [, , , ...a0, "hello"];
->a2 : (string | number)[]
->[, , , ...a0, "hello"] : (string | number)[]
+>a2 : (number | string)[]
+>[, , , ...a0, "hello"] : (number | string)[]
 > : undefined
 > : undefined
 > : undefined
@@ -140,8 +140,8 @@ interface myArray2 extends Array<Number|String> { }
 >String : String
 
 var d0 = [1, true, ...temp, ];  // has type (string|number|boolean)[]
->d0 : (string | number | boolean)[]
->[1, true, ...temp, ] : (string | number | boolean)[]
+>d0 : (number | boolean | string)[]
+>[1, true, ...temp, ] : (number | boolean | string)[]
 >1 : number
 >true : boolean
 >...temp : string
@@ -176,10 +176,10 @@ var d4: myArray2 = [...temp, ...temp1];
 >temp1 : number[]
 
 var d5 = [...a2];
->d5 : (string | number)[]
->[...a2] : (string | number)[]
->...a2 : string | number
->a2 : (string | number)[]
+>d5 : (number | string)[]
+>[...a2] : (number | string)[]
+>...a2 : number | string
+>a2 : (number | string)[]
 
 var d6 = [...a3];
 >d6 : number[]
@@ -201,8 +201,8 @@ var d8: number[][] = [[...temp1]]
 >temp1 : number[]
 
 var d9 = [[...temp1], ...["hello"]];
->d9 : (string | number[])[]
->[[...temp1], ...["hello"]] : (string | number[])[]
+>d9 : (number[] | string)[]
+>[[...temp1], ...["hello"]] : (number[] | string)[]
 >[...temp1] : number[]
 >...temp1 : number
 >temp1 : number[]

tests/baselines/reference/arrayLiterals3.errors.txt

@@ -5,18 +5,18 @@ tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(11,5): error
     Type 'string' is not assignable to type 'boolean'.
 tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(17,5): error TS2322: Type '[number, number, string, boolean]' is not assignable to type '[number, number]'.
   Types of property 'pop' are incompatible.
-    Type '() => string | number | boolean' is not assignable to type '() => number'.
-      Type 'string | number | boolean' is not assignable to type 'number'.
+    Type '() => number | string | boolean' is not assignable to type '() => number'.
+      Type 'number | string | boolean' is not assignable to type 'number'.
         Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(32,5): error TS2322: Type '(number[] | string[])[]' is not assignable to type 'tup'.
   Property '0' is missing in type '(number[] | string[])[]'.
 tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(33,5): error TS2322: Type 'number[]' is not assignable to type '[number, number, number]'.
   Property '0' is missing in type 'number[]'.
-tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(34,5): error TS2322: Type '(string | number)[]' is not assignable to type 'myArray'.
+tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(34,5): error TS2322: Type '(number | string)[]' is not assignable to type 'myArray'.
   Types of property 'push' are incompatible.
-    Type '(...items: (string | number)[]) => number' is not assignable to type '(...items: Number[]) => number'.
+    Type '(...items: (number | string)[]) => number' is not assignable to type '(...items: Number[]) => number'.
       Types of parameters 'items' and 'items' are incompatible.
-        Type 'string | number' is not assignable to type 'Number'.
+        Type 'number | string' is not assignable to type 'Number'.
           Type 'string' is not assignable to type 'Number'.
             Property 'toFixed' is missing in type 'String'.
 
@@ -49,8 +49,8 @@ tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(34,5): error
         ~~~~~~~~
 !!! error TS2322: Type '[number, number, string, boolean]' is not assignable to type '[number, number]'.
 !!! error TS2322:   Types of property 'pop' are incompatible.
-!!! error TS2322:     Type '() => string | number | boolean' is not assignable to type '() => number'.
-!!! error TS2322:       Type 'string | number | boolean' is not assignable to type 'number'.
+!!! error TS2322:     Type '() => number | string | boolean' is not assignable to type '() => number'.
+!!! error TS2322:       Type 'number | string | boolean' is not assignable to type 'number'.
 !!! error TS2322:         Type 'string' is not assignable to type 'number'.
     
     // The resulting type an array literal expression is determined as follows:
@@ -76,11 +76,11 @@ tests/cases/conformance/expressions/arrayLiterals/arrayLiterals3.ts(34,5): error
 !!! error TS2322:   Property '0' is missing in type 'number[]'.
     var c2: myArray = [...temp1, ...temp];            // Error cannot assign (number|string)[] to number[]
         ~~
-!!! error TS2322: Type '(string | number)[]' is not assignable to type 'myArray'.
+!!! error TS2322: Type '(number | string)[]' is not assignable to type 'myArray'.
 !!! error TS2322:   Types of property 'push' are incompatible.
-!!! error TS2322:     Type '(...items: (string | number)[]) => number' is not assignable to type '(...items: Number[]) => number'.
+!!! error TS2322:     Type '(...items: (number | string)[]) => number' is not assignable to type '(...items: Number[]) => number'.
 !!! error TS2322:       Types of parameters 'items' and 'items' are incompatible.
-!!! error TS2322:         Type 'string | number' is not assignable to type 'Number'.
+!!! error TS2322:         Type 'number | string' is not assignable to type 'Number'.
 !!! error TS2322:           Type 'string' is not assignable to type 'Number'.
 !!! error TS2322:             Property 'toFixed' is missing in type 'String'.
     

tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types

@@ -77,8 +77,8 @@ var myDerivedList: DerivedList<number>;
 >DerivedList : DerivedList<U>
 
 var as = [list, myDerivedList]; // List<number>[]
->as : List<number>[]
->[list, myDerivedList] : List<number>[]
+>as : (List<number> | DerivedList<number>)[]
+>[list, myDerivedList] : (List<number> | DerivedList<number>)[]
 >list : List<number>
 >myDerivedList : DerivedList<number>
 

tests/baselines/reference/arrayOfFunctionTypes3.errors.txt

@@ -0,0 +1,35 @@
+tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayOfFunctionTypes3.ts(17,13): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
+tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayOfFunctionTypes3.ts(26,10): error TS2349: Cannot invoke an expression whose type lacks a call signature.
+
+
+==== tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayOfFunctionTypes3.ts (2 errors) ====
+    // valid uses of arrays of function types
+    
+    var x = [() => 1, () => { }];
+    var r2 = x[0]();
+    
+    class C {
+        foo: string;
+    }
+    var y = [C, C];
+    var r3 = new y[0]();
+    
+    var a: { (x: number): number; (x: string): string; };
+    var b: { (x: number): number; (x: string): string; };
+    var c: { (x: number): number; (x: any): any; };
+    var z = [a, b, c];
+    var r4 = z[0];
+    var r5 = r4(''); // any not string
+                ~~
+!!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
+    var r5b = r4(1);
+    
+    var a2: { <T>(x: T): number; (x: string): string;};
+    var b2: { <T>(x: T): number; (x: string): string; };
+    var c2: { (x: number): number; <T>(x: T): any; };
+    
+    var z2 = [a2, b2, c2];
+    var r6 = z2[0];
+    var r7 = r6(''); // any not string
+             ~~~~~~
+!!! error TS2349: Cannot invoke an expression whose type lacks a call signature.

tests/baselines/reference/arrayOfFunctionTypes3.symbols

@@ -1,93 +0,0 @@
-=== tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayOfFunctionTypes3.ts ===
-// valid uses of arrays of function types
-
-var x = [() => 1, () => { }];
->x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 2, 3))
-
-var r2 = x[0]();
->r2 : Symbol(r2, Decl(arrayOfFunctionTypes3.ts, 3, 3))
->x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 2, 3))
-
-class C {
->C : Symbol(C, Decl(arrayOfFunctionTypes3.ts, 3, 16))
-
-    foo: string;
->foo : Symbol(foo, Decl(arrayOfFunctionTypes3.ts, 5, 9))
-}
-var y = [C, C];
->y : Symbol(y, Decl(arrayOfFunctionTypes3.ts, 8, 3))
->C : Symbol(C, Decl(arrayOfFunctionTypes3.ts, 3, 16))
->C : Symbol(C, Decl(arrayOfFunctionTypes3.ts, 3, 16))
-
-var r3 = new y[0]();
->r3 : Symbol(r3, Decl(arrayOfFunctionTypes3.ts, 9, 3))
->y : Symbol(y, Decl(arrayOfFunctionTypes3.ts, 8, 3))
-
-var a: { (x: number): number; (x: string): string; };
->a : Symbol(a, Decl(arrayOfFunctionTypes3.ts, 11, 3))
->x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 11, 10))
->x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 11, 31))
-
-var b: { (x: number): number; (x: string): string; };
->b : Symbol(b, Decl(arrayOfFunctionTypes3.ts, 12, 3))
->x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 12, 10))
->x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 12, 31))
-
-var c: { (x: number): number; (x: any): any; };
->c : Symbol(c, Decl(arrayOfFunctionTypes3.ts, 13, 3))
->x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 13, 10))
->x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 13, 31))
-
-var z = [a, b, c];
->z : Symbol(z, Decl(arrayOfFunctionTypes3.ts, 14, 3))
->a : Symbol(a, Decl(arrayOfFunctionTypes3.ts, 11, 3))
->b : Symbol(b, Decl(arrayOfFunctionTypes3.ts, 12, 3))
->c : Symbol(c, Decl(arrayOfFunctionTypes3.ts, 13, 3))
-
-var r4 = z[0];
->r4 : Symbol(r4, Decl(arrayOfFunctionTypes3.ts, 15, 3))
->z : Symbol(z, Decl(arrayOfFunctionTypes3.ts, 14, 3))
-
-var r5 = r4(''); // any not string
->r5 : Symbol(r5, Decl(arrayOfFunctionTypes3.ts, 16, 3))
->r4 : Symbol(r4, Decl(arrayOfFunctionTypes3.ts, 15, 3))
-
-var r5b = r4(1);
->r5b : Symbol(r5b, Decl(arrayOfFunctionTypes3.ts, 17, 3))
->r4 : Symbol(r4, Decl(arrayOfFunctionTypes3.ts, 15, 3))
-
-var a2: { <T>(x: T): number; (x: string): string;};
->a2 : Symbol(a2, Decl(arrayOfFunctionTypes3.ts, 19, 3))
->T : Symbol(T, Decl(arrayOfFunctionTypes3.ts, 19, 11))
->x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 19, 14))
->T : Symbol(T, Decl(arrayOfFunctionTypes3.ts, 19, 11))
->x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 19, 30))
-
-var b2: { <T>(x: T): number; (x: string): string; };
->b2 : Symbol(b2, Decl(arrayOfFunctionTypes3.ts, 20, 3))
->T : Symbol(T, Decl(arrayOfFunctionTypes3.ts, 20, 11))
->x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 20, 14))
->T : Symbol(T, Decl(arrayOfFunctionTypes3.ts, 20, 11))
->x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 20, 30))
-
-var c2: { (x: number): number; <T>(x: T): any; };
->c2 : Symbol(c2, Decl(arrayOfFunctionTypes3.ts, 21, 3))
->x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 21, 11))
->T : Symbol(T, Decl(arrayOfFunctionTypes3.ts, 21, 32))
->x : Symbol(x, Decl(arrayOfFunctionTypes3.ts, 21, 35))
->T : Symbol(T, Decl(arrayOfFunctionTypes3.ts, 21, 32))
-
-var z2 = [a2, b2, c2];
->z2 : Symbol(z2, Decl(arrayOfFunctionTypes3.ts, 23, 3))
->a2 : Symbol(a2, Decl(arrayOfFunctionTypes3.ts, 19, 3))
->b2 : Symbol(b2, Decl(arrayOfFunctionTypes3.ts, 20, 3))
->c2 : Symbol(c2, Decl(arrayOfFunctionTypes3.ts, 21, 3))
-
-var r6 = z2[0];
->r6 : Symbol(r6, Decl(arrayOfFunctionTypes3.ts, 24, 3))
->z2 : Symbol(z2, Decl(arrayOfFunctionTypes3.ts, 23, 3))
-
-var r7 = r6(''); // any not string
->r7 : Symbol(r7, Decl(arrayOfFunctionTypes3.ts, 25, 3))
->r6 : Symbol(r6, Decl(arrayOfFunctionTypes3.ts, 24, 3))
-

tests/baselines/reference/arrayOfFunctionTypes3.types

@@ -1,116 +0,0 @@
-=== tests/cases/conformance/types/specifyingTypes/typeLiterals/arrayOfFunctionTypes3.ts ===
-// valid uses of arrays of function types
-
-var x = [() => 1, () => { }];
->x : (() => void)[]
->[() => 1, () => { }] : (() => void)[]
->() => 1 : () => number
->1 : number
->() => { } : () => void
-
-var r2 = x[0]();
->r2 : void
->x[0]() : void
->x[0] : () => void
->x : (() => void)[]
->0 : number
-
-class C {
->C : C
-
-    foo: string;
->foo : string
-}
-var y = [C, C];
->y : typeof C[]
->[C, C] : typeof C[]
->C : typeof C
->C : typeof C
-
-var r3 = new y[0]();
->r3 : C
->new y[0]() : C
->y[0] : typeof C
->y : typeof C[]
->0 : number
-
-var a: { (x: number): number; (x: string): string; };
->a : { (x: number): number; (x: string): string; }
->x : number
->x : string
-
-var b: { (x: number): number; (x: string): string; };
->b : { (x: number): number; (x: string): string; }
->x : number
->x : string
-
-var c: { (x: number): number; (x: any): any; };
->c : { (x: number): number; (x: any): any; }
->x : number
->x : any
-
-var z = [a, b, c];
->z : { (x: number): number; (x: any): any; }[]
->[a, b, c] : { (x: number): number; (x: any): any; }[]
->a : { (x: number): number; (x: string): string; }
->b : { (x: number): number; (x: string): string; }
->c : { (x: number): number; (x: any): any; }
-
-var r4 = z[0];
->r4 : { (x: number): number; (x: any): any; }
->z[0] : { (x: number): number; (x: any): any; }
->z : { (x: number): number; (x: any): any; }[]
->0 : number
-
-var r5 = r4(''); // any not string
->r5 : any
->r4('') : any
->r4 : { (x: number): number; (x: any): any; }
->'' : string
-
-var r5b = r4(1);
->r5b : number
->r4(1) : number
->r4 : { (x: number): number; (x: any): any; }
->1 : number
-
-var a2: { <T>(x: T): number; (x: string): string;};
->a2 : { <T>(x: T): number; (x: string): string; }
->T : T
->x : T
->T : T
->x : string
-
-var b2: { <T>(x: T): number; (x: string): string; };
->b2 : { <T>(x: T): number; (x: string): string; }
->T : T
->x : T
->T : T
->x : string
-
-var c2: { (x: number): number; <T>(x: T): any; };
->c2 : { (x: number): number; <T>(x: T): any; }
->x : number
->T : T
->x : T
->T : T
-
-var z2 = [a2, b2, c2];
->z2 : { (x: number): number; <T>(x: T): any; }[]
->[a2, b2, c2] : { (x: number): number; <T>(x: T): any; }[]
->a2 : { <T>(x: T): number; (x: string): string; }
->b2 : { <T>(x: T): number; (x: string): string; }
->c2 : { (x: number): number; <T>(x: T): any; }
-
-var r6 = z2[0];
->r6 : { (x: number): number; <T>(x: T): any; }
->z2[0] : { (x: number): number; <T>(x: T): any; }
->z2 : { (x: number): number; <T>(x: T): any; }[]
->0 : number
-
-var r7 = r6(''); // any not string
->r7 : any
->r6('') : any
->r6 : { (x: number): number; <T>(x: T): any; }
->'' : string
-

tests/baselines/reference/arrowFunctionExpressions.symbols

@@ -70,6 +70,7 @@ var p6 = ({ a }) => { };
 
 var p7 = ({ a: { b } }) => { };
 >p7 : Symbol(p7, Decl(arrowFunctionExpressions.ts, 21, 3))
+>a : Symbol(a)
 >b : Symbol(b, Decl(arrowFunctionExpressions.ts, 21, 16))
 
 var p8 = ({ a = 1 }) => { };
@@ -78,6 +79,7 @@ var p8 = ({ a = 1 }) => { };
 
 var p9 = ({ a: { b = 1 } = { b: 1 } }) => { };
 >p9 : Symbol(p9, Decl(arrowFunctionExpressions.ts, 23, 3))
+>a : Symbol(a)
 >b : Symbol(b, Decl(arrowFunctionExpressions.ts, 23, 16))
 >b : Symbol(b, Decl(arrowFunctionExpressions.ts, 23, 28))
 

tests/baselines/reference/asOperator1.types

@@ -24,12 +24,12 @@ var z = Date as any as string;
 
 // Should parse as a union type, not a bitwise 'or' of (32 as number) and 'string'
 var j = 32 as number|string;
->j : string | number
->32 as number|string : string | number
+>j : number | string
+>32 as number|string : number | string
 >32 : number
 
 j = '';
 >j = '' : string
->j : string | number
+>j : number | string
 >'' : string
 

tests/baselines/reference/assignmentCompatBetweenTupleAndArray.errors.txt

@@ -1,7 +1,7 @@
 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 '() => string | number' is not assignable to type '() => number'.
-      Type 'string | number' is not assignable to type 'number'.
+    Type '() => number | string' is not assignable to type '() => number'.
+      Type 'number | string' 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 '{}[]'.
@@ -28,8 +28,8 @@ 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 '() => string | number' is not assignable to type '() => number'.
-!!! error TS2322:       Type 'string | number' is not assignable to type 'number'.
+!!! error TS2322:     Type '() => number | string' is not assignable to type '() => number'.
+!!! error TS2322:       Type 'number | string' is not assignable to type 'number'.
 !!! error TS2322:         Type 'string' is not assignable to type 'number'.
     emptyObjTuple = emptyObjArray;
     ~~~~~~~~~~~~~

tests/baselines/reference/assignmentCompatBug2.errors.txt

@@ -1,7 +1,9 @@
 tests/cases/compiler/assignmentCompatBug2.ts(1,5): error TS2322: Type '{ a: number; }' is not assignable to type '{ b: number; }'.
-  Property 'b' is missing in type '{ a: number; }'.
+  Object literal may only specify known properties, and 'a' does not exist in type '{ b: number; }'.
 tests/cases/compiler/assignmentCompatBug2.ts(3,1): error TS2322: Type '{ a: number; }' is not assignable to type '{ b: number; }'.
-  Property 'b' is missing in type '{ a: number; }'.
+  Object literal may only specify known properties, and 'a' does not exist in type '{ b: number; }'.
+tests/cases/compiler/assignmentCompatBug2.ts(5,1): error TS2322: Type '{ b: number; a: number; }' is not assignable to type '{ b: number; }'.
+  Object literal may only specify known properties, and 'a' does not exist in type '{ b: number; }'.
 tests/cases/compiler/assignmentCompatBug2.ts(15,1): error TS2322: Type '{ f: (n: number) => number; g: (s: string) => number; }' is not assignable to type '{ f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }'.
   Property 'm' is missing in type '{ f: (n: number) => number; g: (s: string) => number; }'.
 tests/cases/compiler/assignmentCompatBug2.ts(20,1): error TS2322: Type '{ f: (n: number) => number; m: number; }' is not assignable to type '{ f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }'.
@@ -10,18 +12,21 @@ tests/cases/compiler/assignmentCompatBug2.ts(33,1): error TS2322: Type '{ f: (n:
   Property 'm' is missing in type '{ f: (n: number) => number; g: (s: string) => number; n: number; k: (a: any) => any; }'.
 
 
-==== tests/cases/compiler/assignmentCompatBug2.ts (5 errors) ====
+==== tests/cases/compiler/assignmentCompatBug2.ts (6 errors) ====
     var b2: { b: number;} = { a: 0 }; // error
         ~~
 !!! error TS2322: Type '{ a: number; }' is not assignable to type '{ b: number; }'.
-!!! error TS2322:   Property 'b' is missing in type '{ a: number; }'.
+!!! error TS2322:   Object literal may only specify known properties, and 'a' does not exist in type '{ b: number; }'.
     
     b2 = { a: 0 }; // error
     ~~
 !!! error TS2322: Type '{ a: number; }' is not assignable to type '{ b: number; }'.
-!!! error TS2322:   Property 'b' is missing in type '{ a: number; }'.
+!!! error TS2322:   Object literal may only specify known properties, and 'a' does not exist in type '{ b: number; }'.
     
     b2 = {b: 0, a: 0 };
+    ~~
+!!! error TS2322: Type '{ b: number; a: number; }' is not assignable to type '{ b: number; }'.
+!!! error TS2322:   Object literal may only specify known properties, and 'a' does not exist in type '{ b: number; }'.
     
     var b3: { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; };
     

tests/baselines/reference/assignmentCompatBug5.errors.txt

@@ -1,5 +1,5 @@
 tests/cases/compiler/assignmentCompatBug5.ts(2,6): error TS2345: Argument of type '{ b: number; }' is not assignable to parameter of type '{ a: number; }'.
-  Property 'a' is missing in type '{ b: number; }'.
+  Object literal may only specify known properties, and 'b' does not exist in type '{ a: number; }'.
 tests/cases/compiler/assignmentCompatBug5.ts(5,6): error TS2345: Argument of type 'string[]' is not assignable to parameter of type 'number[]'.
   Type 'string' is not assignable to type 'number'.
 tests/cases/compiler/assignmentCompatBug5.ts(8,6): error TS2345: Argument of type '(s: string) => void' is not assignable to parameter of type '(n: number) => number'.
@@ -14,7 +14,7 @@ tests/cases/compiler/assignmentCompatBug5.ts(9,6): error TS2345: Argument of typ
     foo1({ b: 5 });
          ~~~~~~~~
 !!! error TS2345: Argument of type '{ b: number; }' is not assignable to parameter of type '{ a: number; }'.
-!!! error TS2345:   Property 'a' is missing in type '{ b: number; }'.
+!!! error TS2345:   Object literal may only specify known properties, and 'b' does not exist in type '{ a: number; }'.
     
     function foo2(x: number[]) { }
     foo2(["s", "t"]);

tests/baselines/reference/awaitUnion_es6.types

@@ -1,6 +1,6 @@
 === tests/cases/conformance/async/es6/awaitUnion_es6.ts ===
 declare let a: number | string;
->a : string | number
+>a : number | string
 
 declare let b: PromiseLike<number> | PromiseLike<string>;
 >b : PromiseLike<number> | PromiseLike<string>
@@ -8,7 +8,7 @@ declare let b: PromiseLike<number> | PromiseLike<string>;
 >PromiseLike : PromiseLike<T>
 
 declare let c: PromiseLike<number | string>;
->c : PromiseLike<string | number>
+>c : PromiseLike<number | string>
 >PromiseLike : PromiseLike<T>
 
 declare let d: number | PromiseLike<string>;
@@ -16,29 +16,29 @@ declare let d: number | PromiseLike<string>;
 >PromiseLike : PromiseLike<T>
 
 declare let e: number | PromiseLike<number | string>;
->e : number | PromiseLike<string | number>
+>e : number | PromiseLike<number | string>
 >PromiseLike : PromiseLike<T>
 
 async function f() {
 >f : () => Promise<void>
 
 	let await_a = await a;
->await_a : string | number
+>await_a : number | string
 >a : any
 
 	let await_b = await b;
->await_b : string | number
+>await_b : number | string
 >b : any
 
 	let await_c = await c;
->await_c : string | number
+>await_c : number | string
 >c : any
 
 	let await_d = await d;
->await_d : string | number
+>await_d : number | string
 >d : any
 
 	let await_e = await e; 
->await_e : string | number
+>await_e : number | string
 >e : any
 }

tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types

@@ -46,8 +46,8 @@ var r = true ? 1 : 2;
 >2 : number
 
 var r3 = true ? 1 : {};
->r3 : {}
->true ? 1 : {} : {}
+>r3 : number | {}
+>true ? 1 : {} : number | {}
 >true : boolean
 >1 : number
 >{} : {}
@@ -60,15 +60,15 @@ var r4 = true ? a : b; // typeof a
 >b : { x: number; z?: number; }
 
 var r5 = true ? b : a; // typeof b
->r5 : { x: number; y?: number; } | { x: number; z?: number; }
->true ? b : a : { x: number; y?: number; } | { x: number; z?: number; }
+>r5 : { x: number; z?: number; } | { x: number; y?: number; }
+>true ? b : a : { x: number; z?: number; } | { x: number; y?: number; }
 >true : boolean
 >b : { x: number; z?: number; }
 >a : { x: number; y?: number; }
 
 var r6 = true ? (x: number) => { } : (x: Object) => { }; // returns number => void
->r6 : (x: number) => void
->true ? (x: number) => { } : (x: Object) => { } : (x: number) => void
+>r6 : ((x: number) => void) | ((x: Object) => void)
+>true ? (x: number) => { } : (x: Object) => { } : ((x: number) => void) | ((x: Object) => void)
 >true : boolean
 >(x: number) => { } : (x: number) => void
 >x : number
@@ -80,7 +80,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: number) => void
+>true ? (x: number) => { } : (x: Object) => { } : ((x: number) => void) | ((x: Object) => void)
 >true : boolean
 >(x: number) => { } : (x: number) => void
 >x : number
@@ -89,8 +89,8 @@ var r7: (x: Object) => void = true ? (x: number) => { } : (x: Object) => { };
 >Object : Object
 
 var r8 = true ? (x: Object) => { } : (x: number) => { }; // returns Object => void
->r8 : (x: Object) => void
->true ? (x: Object) => { } : (x: number) => { } : (x: Object) => void
+>r8 : ((x: Object) => void) | ((x: number) => void)
+>true ? (x: Object) => { } : (x: number) => { } : ((x: Object) => void) | ((x: number) => void)
 >true : boolean
 >(x: Object) => { } : (x: Object) => void
 >x : Object
@@ -107,8 +107,8 @@ var r10: Base = true ? derived : derived2; // no error since we use the contextu
 >derived2 : Derived2
 
 var r11 = true ? base : derived2;
->r11 : Base
->true ? base : derived2 : Base
+>r11 : Base | Derived2
+>true ? base : derived2 : Base | Derived2
 >true : boolean
 >base : Base
 >derived2 : Derived2

tests/baselines/reference/bestCommonTypeOfTuple.types

@@ -98,8 +98,8 @@ var e3 = t3[2];  // any
 >2 : number
 
 var e4 = t4[3];  // number
->e4 : number
->t4[3] : number
+>e4 : E1 | E2 | number
+>t4[3] : E1 | E2 | number
 >t4 : [E1, E2, number]
 >3 : number
 

tests/baselines/reference/bestCommonTypeOfTuple2.types

@@ -66,8 +66,8 @@ var t5: [C1, F]
 >F : F
 
 var e11 = t1[4]; // base
->e11 : base
->t1[4] : base
+>e11 : C | base
+>t1[4] : C | base
 >t1 : [C, base]
 >4 : number
 
@@ -78,20 +78,20 @@ var e21 = t2[4]; // {}
 >4 : number
 
 var e31 = t3[4]; // C1
->e31 : C1
->t3[4] : C1
+>e31 : C1 | D1
+>t3[4] : C1 | D1
 >t3 : [C1, D1]
 >4 : number
 
 var e41 = t4[2]; // base1
->e41 : base1
->t4[2] : base1
+>e41 : base1 | C1
+>t4[2] : base1 | C1
 >t4 : [base1, C1]
 >2 : number
 
 var e51 = t5[2]; // {}
->e51 : F | C1
->t5[2] : F | C1
+>e51 : C1 | F
+>t5[2] : C1 | F
 >t5 : [C1, F]
 >2 : number
 

tests/baselines/reference/bestCommonTypeWithOptionalProperties.types

@@ -27,43 +27,43 @@ var z: Z;
 
 // All these arrays should be X[]
 var b1 = [x, y, z];
->b1 : X[]
->[x, y, z] : X[]
+>b1 : (X | Y | Z)[]
+>[x, y, z] : (X | Y | Z)[]
 >x : X
 >y : Y
 >z : Z
 
 var b2 = [x, z, y];
->b2 : X[]
->[x, z, y] : X[]
+>b2 : (X | Z | Y)[]
+>[x, z, y] : (X | Z | Y)[]
 >x : X
 >z : Z
 >y : Y
 
 var b3 = [y, x, z];
->b3 : X[]
->[y, x, z] : X[]
+>b3 : (Y | X | Z)[]
+>[y, x, z] : (Y | X | Z)[]
 >y : Y
 >x : X
 >z : Z
 
 var b4 = [y, z, x];
->b4 : X[]
->[y, z, x] : X[]
+>b4 : (Y | Z | X)[]
+>[y, z, x] : (Y | Z | X)[]
 >y : Y
 >z : Z
 >x : X
 
 var b5 = [z, x, y];
->b5 : X[]
->[z, x, y] : X[]
+>b5 : (Z | X | Y)[]
+>[z, x, y] : (Z | X | Y)[]
 >z : Z
 >x : X
 >y : Y
 
 var b6 = [z, y, x];
->b6 : X[]
->[z, y, x] : X[]
+>b6 : (Z | Y | X)[]
+>[z, y, x] : (Z | Y | X)[]
 >z : Z
 >y : Y
 >x : X

tests/baselines/reference/callWithSpread.types

@@ -163,8 +163,8 @@ xa[1].foo(1, 2, ...a, "abc");
 >xa : X[]
 >1 : number
 >foo : (x: number, y: number, ...z: string[]) => any
->...[1, 2, "abc"] : string | number
->[1, 2, "abc"] : (string | number)[]
+>...[1, 2, "abc"] : number | string
+>[1, 2, "abc"] : (number | string)[]
 >1 : number
 >2 : number
 >"abc" : string

tests/baselines/reference/callWithSpreadES6.types

@@ -164,8 +164,8 @@ xa[1].foo(1, 2, ...a, "abc");
 >xa : X[]
 >1 : number
 >foo : (x: number, y: number, ...z: string[]) => any
->...[1, 2, "abc"] : string | number
->[1, 2, "abc"] : (string | number)[]
+>...[1, 2, "abc"] : number | string
+>[1, 2, "abc"] : (number | string)[]
 >1 : number
 >2 : number
 >"abc" : string

tests/baselines/reference/castingTuple.errors.txt

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

tests/baselines/reference/computedPropertyNamesContextualType6_ES5.types

@@ -17,9 +17,9 @@ declare function foo<T>(obj: I<T>): T
 >T : T
 
 foo({
->foo({    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]}) : string | number | boolean | (() => void) | number[]
+>foo({    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]}) : string | (() => void) | boolean | number | number[]
 >foo : <T>(obj: I<T>) => T
->{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: string]: string | number | boolean | (() => void) | number[]; 0: () => void; p: string; }
+>{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: string]: string | (() => void) | boolean | number | number[]; 0: () => void; p: string; }
 
     p: "",
 >p : string

tests/baselines/reference/computedPropertyNamesContextualType6_ES6.types

@@ -17,9 +17,9 @@ declare function foo<T>(obj: I<T>): T
 >T : T
 
 foo({
->foo({    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]}) : string | number | boolean | (() => void) | number[]
+>foo({    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]}) : string | (() => void) | boolean | number | number[]
 >foo : <T>(obj: I<T>) => T
->{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: string]: string | number | boolean | (() => void) | number[]; 0: () => void; p: string; }
+>{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: string]: string | (() => void) | boolean | number | number[]; 0: () => void; p: string; }
 
     p: "",
 >p : string

tests/baselines/reference/computedPropertyNamesContextualType7_ES5.types

@@ -17,9 +17,9 @@ declare function foo<T>(obj: I<T>): T
 >T : T
 
 foo({
->foo({    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]}) : number | (() => void) | number[]
+>foo({    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]}) : (() => void) | number | number[]
 >foo : <T>(obj: I<T>) => T
->{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: number]: number | (() => void) | number[]; 0: () => void; p: string; }
+>{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: number]: (() => void) | number | number[]; 0: () => void; p: string; }
 
     p: "",
 >p : string

tests/baselines/reference/computedPropertyNamesContextualType7_ES6.types

@@ -17,9 +17,9 @@ declare function foo<T>(obj: I<T>): T
 >T : T
 
 foo({
->foo({    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]}) : number | (() => void) | number[]
+>foo({    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]}) : (() => void) | number | number[]
 >foo : <T>(obj: I<T>) => T
->{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: number]: number | (() => void) | number[]; 0: () => void; p: string; }
+>{    p: "",    0: () => { },    ["hi" + "bye"]: true,    [0 + 1]: 0,    [+"hi"]: [0]} : { [x: number]: (() => void) | number | number[]; 0: () => void; p: string; }
 
     p: "",
 >p : string

tests/baselines/reference/conditionalExpression1.errors.txt

@@ -1,9 +1,9 @@
-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(1,5): error TS2322: Type 'number | string' is not assignable to type 'boolean'.
+  Type 'number' is not assignable to type 'boolean'.
 
 
 ==== tests/cases/compiler/conditionalExpression1.ts (1 errors) ====
     var x: boolean = (true ? 1 : ""); // should be an error
         ~
-!!! error TS2322: Type 'string | number' is not assignable to type 'boolean'.
-!!! error TS2322:   Type 'string' is not assignable to type 'boolean'.
+!!! error TS2322: Type 'number | string' is not assignable to type 'boolean'.
+!!! error TS2322:   Type 'number' is not assignable to type 'boolean'.

tests/baselines/reference/conditionalOperatorWithIdenticalBCT.types

@@ -31,27 +31,27 @@ var b: B;
 //Cond ? Expr1 : Expr2,  Expr1 is supertype
 //Be Not contextually typed
 true ? x : a;
->true ? x : a : X
+>true ? x : a : X | A
 >true : boolean
 >x : X
 >a : A
 
 var result1 = true ? x : a;
->result1 : X
->true ? x : a : X
+>result1 : X | A
+>true ? x : a : X | A
 >true : boolean
 >x : X
 >a : A
 
 //Expr1 and Expr2 are literals
 true ? {} : 1;
->true ? {} : 1 : {}
+>true ? {} : 1 : {} | number
 >true : boolean
 >{} : {}
 >1 : number
 
 true ? { a: 1 } : { a: 2, b: 'string' };
->true ? { a: 1 } : { a: 2, b: 'string' } : { a: number; }
+>true ? { a: 1 } : { a: 2, b: 'string' } : { a: number; } | { a: number; b: string; }
 >true : boolean
 >{ a: 1 } : { a: number; }
 >a : number
@@ -63,15 +63,15 @@ true ? { a: 1 } : { a: 2, b: 'string' };
 >'string' : string
 
 var result2 = true ? {} : 1;
->result2 : {}
->true ? {} : 1 : {}
+>result2 : {} | number
+>true ? {} : 1 : {} | number
 >true : boolean
 >{} : {}
 >1 : number
 
 var result3 = true ? { a: 1 } : { a: 2, b: 'string' };
->result3 : { a: number; }
->true ? { a: 1 } : { a: 2, b: 'string' } : { a: number; }
+>result3 : { a: number; } | { a: number; b: string; }
+>true ? { a: 1 } : { a: 2, b: 'string' } : { a: number; } | { a: number; b: string; }
 >true : boolean
 >{ a: 1 } : { a: number; }
 >a : number
@@ -86,7 +86,7 @@ var result3 = true ? { a: 1 } : { a: 2, b: 'string' };
 var resultIsX1: X = true ? x : a;
 >resultIsX1 : X
 >X : X
->true ? x : a : X
+>true ? x : a : X | A
 >true : boolean
 >x : X
 >a : A
@@ -95,7 +95,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 : (m: A) => any
+>true ? (m) => m.propertyX : (n) => n.propertyA : ((m: A) => any) | ((n: A) => number)
 >true : boolean
 >(m) => m.propertyX : (m: A) => any
 >m : A
@@ -111,27 +111,27 @@ var result4: (t: A) => any = true ? (m) => m.propertyX : (n) => n.propertyA;
 //Cond ? Expr1 : Expr2,  Expr2 is supertype
 //Be Not contextually typed
 true ? a : x;
->true ? a : x : X
+>true ? a : x : A | X
 >true : boolean
 >a : A
 >x : X
 
 var result5 = true ? a : x;
->result5 : X
->true ? a : x : X
+>result5 : A | X
+>true ? a : x : A | X
 >true : boolean
 >a : A
 >x : X
 
 //Expr1 and Expr2 are literals
 true ? 1 : {};
->true ? 1 : {} : {}
+>true ? 1 : {} : number | {}
 >true : boolean
 >1 : number
 >{} : {}
 
 true ? { a: 2, b: 'string' } : { a: 1 };
->true ? { a: 2, b: 'string' } : { a: 1 } : { a: number; }
+>true ? { a: 2, b: 'string' } : { a: 1 } : { a: number; b: string; } | { a: number; }
 >true : boolean
 >{ a: 2, b: 'string' } : { a: number; b: string; }
 >a : number
@@ -143,15 +143,15 @@ true ? { a: 2, b: 'string' } : { a: 1 };
 >1 : number
 
 var result6 = true ? 1 : {};
->result6 : {}
->true ? 1 : {} : {}
+>result6 : number | {}
+>true ? 1 : {} : number | {}
 >true : boolean
 >1 : number
 >{} : {}
 
 var result7 = true ? { a: 2, b: 'string' } : { a: 1 };
->result7 : { a: number; }
->true ? { a: 2, b: 'string' } : { a: 1 } : { a: number; }
+>result7 : { a: number; b: string; } | { a: number; }
+>true ? { a: 2, b: 'string' } : { a: 1 } : { a: number; b: string; } | { a: number; }
 >true : boolean
 >{ a: 2, b: 'string' } : { a: number; b: string; }
 >a : number
@@ -166,7 +166,7 @@ var result7 = true ? { a: 2, b: 'string' } : { a: 1 };
 var resultIsX2: X = true ? x : a;
 >resultIsX2 : X
 >X : X
->true ? x : a : X
+>true ? x : a : X | A
 >true : boolean
 >x : X
 >a : A
@@ -175,7 +175,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 : (n: A) => any
+>true ? (m) => m.propertyA : (n) => n.propertyX : ((m: A) => number) | ((n: A) => any)
 >true : boolean
 >(m) => m.propertyA : (m: A) => number
 >m : A
@@ -218,7 +218,7 @@ 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' : string | number
+>true ? 1 : 'string' : number | string
 >true : boolean
 >1 : number
 >'string' : string

tests/baselines/reference/constEnumMergingWithValues1.js

@@ -0,0 +1,14 @@
+//// [constEnumMergingWithValues1.ts]
+
+function foo() {}
+module foo {
+    const enum E { X }
+}
+
+export = foo
+
+//// [constEnumMergingWithValues1.js]
+define(["require", "exports"], function (require, exports) {
+    function foo() { }
+    return foo;
+});

tests/baselines/reference/constEnumMergingWithValues1.symbols

@@ -0,0 +1,16 @@
+=== tests/cases/compiler/constEnumMergingWithValues1.ts ===
+
+function foo() {}
+>foo : Symbol(foo, Decl(constEnumMergingWithValues1.ts, 0, 0), Decl(constEnumMergingWithValues1.ts, 1, 17))
+
+module foo {
+>foo : Symbol(foo, Decl(constEnumMergingWithValues1.ts, 0, 0), Decl(constEnumMergingWithValues1.ts, 1, 17))
+
+    const enum E { X }
+>E : Symbol(E, Decl(constEnumMergingWithValues1.ts, 2, 12))
+>X : Symbol(E.X, Decl(constEnumMergingWithValues1.ts, 3, 18))
+}
+
+export = foo
+>foo : Symbol(foo, Decl(constEnumMergingWithValues1.ts, 0, 0), Decl(constEnumMergingWithValues1.ts, 1, 17))
+

tests/baselines/reference/constEnumMergingWithValues1.types

@@ -0,0 +1,16 @@
+=== tests/cases/compiler/constEnumMergingWithValues1.ts ===
+
+function foo() {}
+>foo : typeof foo
+
+module foo {
+>foo : typeof foo
+
+    const enum E { X }
+>E : E
+>X : E
+}
+
+export = foo
+>foo : typeof foo
+

tests/baselines/reference/constEnumMergingWithValues2.js

@@ -0,0 +1,18 @@
+//// [constEnumMergingWithValues2.ts]
+
+class foo {}
+module foo {
+    const enum E { X }
+}
+
+export = foo
+
+//// [constEnumMergingWithValues2.js]
+define(["require", "exports"], function (require, exports) {
+    var foo = (function () {
+        function foo() {
+        }
+        return foo;
+    })();
+    return foo;
+});

tests/baselines/reference/constEnumMergingWithValues2.symbols

@@ -0,0 +1,16 @@
+=== tests/cases/compiler/constEnumMergingWithValues2.ts ===
+
+class foo {}
+>foo : Symbol(foo, Decl(constEnumMergingWithValues2.ts, 0, 0), Decl(constEnumMergingWithValues2.ts, 1, 12))
+
+module foo {
+>foo : Symbol(foo, Decl(constEnumMergingWithValues2.ts, 0, 0), Decl(constEnumMergingWithValues2.ts, 1, 12))
+
+    const enum E { X }
+>E : Symbol(E, Decl(constEnumMergingWithValues2.ts, 2, 12))
+>X : Symbol(E.X, Decl(constEnumMergingWithValues2.ts, 3, 18))
+}
+
+export = foo
+>foo : Symbol(foo, Decl(constEnumMergingWithValues2.ts, 0, 0), Decl(constEnumMergingWithValues2.ts, 1, 12))
+

tests/baselines/reference/constEnumMergingWithValues2.types

@@ -0,0 +1,16 @@
+=== tests/cases/compiler/constEnumMergingWithValues2.ts ===
+
+class foo {}
+>foo : foo
+
+module foo {
+>foo : typeof foo
+
+    const enum E { X }
+>E : E
+>X : E
+}
+
+export = foo
+>foo : foo
+

tests/baselines/reference/constEnumMergingWithValues3.js

@@ -0,0 +1,17 @@
+//// [constEnumMergingWithValues3.ts]
+
+enum foo { A }
+module foo {
+    const enum E { X }
+}
+
+export = foo
+
+//// [constEnumMergingWithValues3.js]
+define(["require", "exports"], function (require, exports) {
+    var foo;
+    (function (foo) {
+        foo[foo["A"] = 0] = "A";
+    })(foo || (foo = {}));
+    return foo;
+});

tests/baselines/reference/constEnumMergingWithValues3.symbols

@@ -0,0 +1,17 @@
+=== tests/cases/compiler/constEnumMergingWithValues3.ts ===
+
+enum foo { A }
+>foo : Symbol(foo, Decl(constEnumMergingWithValues3.ts, 0, 0), Decl(constEnumMergingWithValues3.ts, 1, 14))
+>A : Symbol(foo.A, Decl(constEnumMergingWithValues3.ts, 1, 10))
+
+module foo {
+>foo : Symbol(foo, Decl(constEnumMergingWithValues3.ts, 0, 0), Decl(constEnumMergingWithValues3.ts, 1, 14))
+
+    const enum E { X }
+>E : Symbol(E, Decl(constEnumMergingWithValues3.ts, 2, 12))
+>X : Symbol(E.X, Decl(constEnumMergingWithValues3.ts, 3, 18))
+}
+
+export = foo
+>foo : Symbol(foo, Decl(constEnumMergingWithValues3.ts, 0, 0), Decl(constEnumMergingWithValues3.ts, 1, 14))
+

tests/baselines/reference/constEnumMergingWithValues3.types

@@ -0,0 +1,17 @@
+=== tests/cases/compiler/constEnumMergingWithValues3.ts ===
+
+enum foo { A }
+>foo : foo
+>A : foo
+
+module foo {
+>foo : typeof foo
+
+    const enum E { X }
+>E : E
+>X : E
+}
+
+export = foo
+>foo : foo
+

tests/baselines/reference/constEnumMergingWithValues4.js

@@ -0,0 +1,21 @@
+//// [constEnumMergingWithValues4.ts]
+
+module foo {
+    const enum E { X }
+}
+
+module foo {
+    var x = 1;
+}
+
+
+export = foo
+
+//// [constEnumMergingWithValues4.js]
+define(["require", "exports"], function (require, exports) {
+    var foo;
+    (function (foo) {
+        var x = 1;
+    })(foo || (foo = {}));
+    return foo;
+});

tests/baselines/reference/constEnumMergingWithValues4.symbols

@@ -0,0 +1,21 @@
+=== tests/cases/compiler/constEnumMergingWithValues4.ts ===
+
+module foo {
+>foo : Symbol(foo, Decl(constEnumMergingWithValues4.ts, 0, 0), Decl(constEnumMergingWithValues4.ts, 3, 1))
+
+    const enum E { X }
+>E : Symbol(E, Decl(constEnumMergingWithValues4.ts, 1, 12))
+>X : Symbol(E.X, Decl(constEnumMergingWithValues4.ts, 2, 18))
+}
+
+module foo {
+>foo : Symbol(foo, Decl(constEnumMergingWithValues4.ts, 0, 0), Decl(constEnumMergingWithValues4.ts, 3, 1))
+
+    var x = 1;
+>x : Symbol(x, Decl(constEnumMergingWithValues4.ts, 6, 7))
+}
+
+
+export = foo
+>foo : Symbol(foo, Decl(constEnumMergingWithValues4.ts, 0, 0), Decl(constEnumMergingWithValues4.ts, 3, 1))
+

tests/baselines/reference/constEnumMergingWithValues4.types

@@ -0,0 +1,22 @@
+=== tests/cases/compiler/constEnumMergingWithValues4.ts ===
+
+module foo {
+>foo : typeof foo
+
+    const enum E { X }
+>E : E
+>X : E
+}
+
+module foo {
+>foo : typeof foo
+
+    var x = 1;
+>x : number
+>1 : number
+}
+
+
+export = foo
+>foo : typeof foo
+

tests/baselines/reference/constEnumMergingWithValues5.js

@@ -0,0 +1,19 @@
+//// [constEnumMergingWithValues5.ts]
+
+module foo {
+    const enum E { X }
+}
+
+export = foo
+
+//// [constEnumMergingWithValues5.js]
+define(["require", "exports"], function (require, exports) {
+    var foo;
+    (function (foo) {
+        var E;
+        (function (E) {
+            E[E["X"] = 0] = "X";
+        })(E || (E = {}));
+    })(foo || (foo = {}));
+    return foo;
+});

tests/baselines/reference/constEnumMergingWithValues5.symbols

@@ -0,0 +1,13 @@
+=== tests/cases/compiler/constEnumMergingWithValues5.ts ===
+
+module foo {
+>foo : Symbol(foo, Decl(constEnumMergingWithValues5.ts, 0, 0))
+
+    const enum E { X }
+>E : Symbol(E, Decl(constEnumMergingWithValues5.ts, 1, 12))
+>X : Symbol(E.X, Decl(constEnumMergingWithValues5.ts, 2, 18))
+}
+
+export = foo
+>foo : Symbol(foo, Decl(constEnumMergingWithValues5.ts, 0, 0))
+

tests/baselines/reference/constEnumMergingWithValues5.types

@@ -0,0 +1,13 @@
+=== tests/cases/compiler/constEnumMergingWithValues5.ts ===
+
+module foo {
+>foo : typeof foo
+
+    const enum E { X }
+>E : E
+>X : E
+}
+
+export = foo
+>foo : typeof foo
+

tests/baselines/reference/contextualSignatureInstantiation.types

@@ -87,24 +87,24 @@ var a = baz(1, 1, g);      // Should be number
 >g : <T>(x: T, y: T) => T
 
 var b: number | string;
->b : string | number
+>b : number | string
 
 var b = foo(g);            // Should be number | string
->b : string | number
->foo(g) : string | number
+>b : number | string
+>foo(g) : number | string
 >foo : <T>(cb: (x: number, y: string) => T) => T
 >g : <T>(x: T, y: T) => T
 
 var b = bar(1, "one", g);  // Should be number | string
->b : string | number
->bar(1, "one", g) : string | number
+>b : number | string
+>bar(1, "one", g) : number | string
 >bar : <T, U, V>(x: T, y: U, cb: (x: T, y: U) => V) => V
 >1 : number
 >"one" : string
 >g : <T>(x: T, y: T) => T
 
 var b = bar("one", 1, g);  // Should be number | string
->b : string | number
+>b : number | string
 >bar("one", 1, g) : string | number
 >bar : <T, U, V>(x: T, y: U, cb: (x: T, y: U) => V) => V
 >"one" : string
@@ -112,11 +112,11 @@ var b = bar("one", 1, g);  // Should be number | string
 >g : <T>(x: T, y: T) => T
 
 var b = baz(b, b, g);      // Should be number | string
->b : string | number
->baz(b, b, g) : string | number
+>b : number | string
+>baz(b, b, g) : number | string
 >baz : <T, U>(x: T, y: T, cb: (x: T, y: T) => U) => U
->b : string | number
->b : string | number
+>b : number | string
+>b : number | string
 >g : <T>(x: T, y: T) => T
 
 var d: number[] | string[];
@@ -138,7 +138,7 @@ var d = bar(1, "one", h);  // Should be number[] | string[]
 
 var d = bar("one", 1, h);  // Should be number[] | string[]
 >d : number[] | string[]
->bar("one", 1, h) : number[] | string[]
+>bar("one", 1, h) : string[] | number[]
 >bar : <T, U, V>(x: T, y: U, cb: (x: T, y: U) => V) => V
 >"one" : string
 >1 : number

tests/baselines/reference/contextualTypeWithTuple.errors.txt

@@ -1,9 +1,9 @@
 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'.
+    Type '() => number | string | boolean' is not assignable to type '() => number | string'.
+      Type 'number | string | boolean' is not assignable to type 'number | string'.
+        Type 'boolean' is not assignable to type 'number | string'.
+          Type 'boolean' is not assignable to type 'string'.
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(15,1): error TS2322: Type '[number, string, boolean]' is not assignable to type '[number, string]'.
 tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(18,1): error TS2322: Type '[{}, number]' is not assignable to type '[{ a: string; }, number]'.
   Types of property '0' are incompatible.
@@ -31,10 +31,10 @@ tests/cases/conformance/types/tuple/contextualTypeWithTuple.ts(25,1): error TS23
         ~~~~~~~~~~~~
 !!! 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'.
+!!! error TS2322:     Type '() => number | string | boolean' is not assignable to type '() => number | string'.
+!!! error TS2322:       Type 'number | string | boolean' is not assignable to type 'number | string'.
+!!! error TS2322:         Type 'boolean' is not assignable to type 'number | string'.
+!!! error TS2322:           Type 'boolean' is not assignable to type 'string'.
     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 }]];

tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols

@@ -82,7 +82,5 @@ var x4: IWithCallSignatures | IWithCallSignatures4 = a => /*here a should be any
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
 >IWithCallSignatures4 : Symbol(IWithCallSignatures4, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 18, 1))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
->a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18))
 

tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.types

@@ -90,10 +90,10 @@ var x4: IWithCallSignatures | IWithCallSignatures4 = a => /*here a should be any
 >x4 : IWithCallSignatures | IWithCallSignatures4
 >IWithCallSignatures : IWithCallSignatures
 >IWithCallSignatures4 : IWithCallSignatures4
->a => /*here a should be any*/ a.toString() : (a: number) => string
->a : number
->a.toString() : string
->a.toString : (radix?: number) => string
->a : number
->toString : (radix?: number) => string
+>a => /*here a should be any*/ a.toString() : (a: any) => any
+>a : any
+>a.toString() : any
+>a.toString : any
+>a : any
+>toString : any
 

tests/baselines/reference/contextualTypeWithUnionTypeMembers.types

@@ -187,7 +187,7 @@ var arrayI1OrI2: Array<I1<number> | I2<number>> = [i1, i2, { // Like i1
 >Array : T[]
 >I1 : I1<T>
 >I2 : I2<T>
->[i1, i2, { // Like i1        commonPropertyType: "hello",        commonMethodType: a=> a,        commonMethodWithTypeParameter: a => a,        methodOnlyInI1: a => a,        propertyOnlyInI1: "Hello",    },    { // Like i2        commonPropertyType: "hello",        commonMethodType: a=> a,        commonMethodWithTypeParameter: a => a,        methodOnlyInI2: a => a,        propertyOnlyInI2: "Hello",    }, { // Like i1 and i2 both        commonPropertyType: "hello",        commonMethodType: a=> a,        commonMethodWithTypeParameter: a => a,        methodOnlyInI1: a => a,        propertyOnlyInI1: "Hello",        methodOnlyInI2: a => a,        propertyOnlyInI2: "Hello",    }] : (I1<number> | I2<number>)[]
+>[i1, i2, { // Like i1        commonPropertyType: "hello",        commonMethodType: a=> a,        commonMethodWithTypeParameter: a => a,        methodOnlyInI1: a => a,        propertyOnlyInI1: "Hello",    },    { // Like i2        commonPropertyType: "hello",        commonMethodType: a=> a,        commonMethodWithTypeParameter: a => a,        methodOnlyInI2: a => a,        propertyOnlyInI2: "Hello",    }, { // Like i1 and i2 both        commonPropertyType: "hello",        commonMethodType: a=> a,        commonMethodWithTypeParameter: a => a,        methodOnlyInI1: a => a,        propertyOnlyInI1: "Hello",        methodOnlyInI2: a => a,        propertyOnlyInI2: "Hello",    }] : (I1<number> | I2<number> | { commonPropertyType: string; commonMethodType: (a: string) => string; commonMethodWithTypeParameter: (a: number) => number; methodOnlyInI1: (a: string) => string; propertyOnlyInI1: string; methodOnlyInI2: (a: string) => string; propertyOnlyInI2: string; })[]
 >i1 : I1<number>
 >i2 : I2<number>
 >{ // Like i1        commonPropertyType: "hello",        commonMethodType: a=> a,        commonMethodWithTypeParameter: a => a,        methodOnlyInI1: a => a,        propertyOnlyInI1: "Hello",    } : { commonPropertyType: string; commonMethodType: (a: string) => string; commonMethodWithTypeParameter: (a: number) => number; methodOnlyInI1: (a: string) => string; propertyOnlyInI1: string; }

tests/baselines/reference/contextualTyping12.errors.txt

@@ -0,0 +1,13 @@
+tests/cases/compiler/contextualTyping12.ts(1,13): error TS2322: Type '({ id: number; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
+  Type '{ id: number; } | { id: number; name: string; }' is not assignable to type '{ id: number; }'.
+    Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
+      Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.
+
+
+==== tests/cases/compiler/contextualTyping12.ts (1 errors) ====
+    class foo { public bar:{id:number;}[] = [{id:1}, {id:2, name:"foo"}]; }
+                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2322: Type '({ id: number; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
+!!! error TS2322:   Type '{ id: number; } | { id: number; name: string; }' is not assignable to type '{ id: number; }'.
+!!! error TS2322:     Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
+!!! error TS2322:       Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.

tests/baselines/reference/contextualTyping12.symbols

@@ -1,9 +0,0 @@
-=== tests/cases/compiler/contextualTyping12.ts ===
-class foo { public bar:{id:number;}[] = [{id:1}, {id:2, name:"foo"}]; }
->foo : Symbol(foo, Decl(contextualTyping12.ts, 0, 0))
->bar : Symbol(bar, Decl(contextualTyping12.ts, 0, 11))
->id : Symbol(id, Decl(contextualTyping12.ts, 0, 24))
->id : Symbol(id, Decl(contextualTyping12.ts, 0, 42))
->id : Symbol(id, Decl(contextualTyping12.ts, 0, 50))
->name : Symbol(name, Decl(contextualTyping12.ts, 0, 55))
-

tests/baselines/reference/contextualTyping12.types

@@ -1,15 +0,0 @@
-=== tests/cases/compiler/contextualTyping12.ts ===
-class foo { public bar:{id:number;}[] = [{id:1}, {id:2, name:"foo"}]; }
->foo : foo
->bar : { id: number; }[]
->id : number
->[{id:1}, {id:2, name:"foo"}] : { id: number; }[]
->{id:1} : { id: number; }
->id : number
->1 : number
->{id:2, name:"foo"} : { id: number; name: string; }
->id : number
->2 : number
->name : string
->"foo" : string
-

tests/baselines/reference/contextualTyping17.errors.txt

@@ -0,0 +1,9 @@
+tests/cases/compiler/contextualTyping17.ts(1,33): error TS2322: Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
+  Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.
+
+
+==== tests/cases/compiler/contextualTyping17.ts (1 errors) ====
+    var foo: {id:number;} = {id:4}; foo = {id: 5, name:"foo"};
+                                    ~~~
+!!! error TS2322: Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
+!!! error TS2322:   Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.

tests/baselines/reference/contextualTyping17.symbols

@@ -1,9 +0,0 @@
-=== tests/cases/compiler/contextualTyping17.ts ===
-var foo: {id:number;} = {id:4}; foo = {id: 5, name:"foo"};
->foo : Symbol(foo, Decl(contextualTyping17.ts, 0, 3))
->id : Symbol(id, Decl(contextualTyping17.ts, 0, 10))
->id : Symbol(id, Decl(contextualTyping17.ts, 0, 25))
->foo : Symbol(foo, Decl(contextualTyping17.ts, 0, 3))
->id : Symbol(id, Decl(contextualTyping17.ts, 0, 39))
->name : Symbol(name, Decl(contextualTyping17.ts, 0, 45))
-

tests/baselines/reference/contextualTyping17.types

@@ -1,15 +0,0 @@
-=== tests/cases/compiler/contextualTyping17.ts ===
-var foo: {id:number;} = {id:4}; foo = {id: 5, name:"foo"};
->foo : { id: number; }
->id : number
->{id:4} : { id: number; }
->id : number
->4 : number
->foo = {id: 5, name:"foo"} : { id: number; name: string; }
->foo : { id: number; }
->{id: 5, name:"foo"} : { id: number; name: string; }
->id : number
->5 : number
->name : string
->"foo" : string
-

tests/baselines/reference/contextualTyping2.errors.txt

@@ -0,0 +1,9 @@
+tests/cases/compiler/contextualTyping2.ts(1,5): error TS2322: Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
+  Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.
+
+
+==== tests/cases/compiler/contextualTyping2.ts (1 errors) ====
+    var foo: {id:number;} = {id:4, name:"foo"};
+        ~~~
+!!! error TS2322: Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
+!!! error TS2322:   Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.

tests/baselines/reference/contextualTyping2.symbols

@@ -1,7 +0,0 @@
-=== tests/cases/compiler/contextualTyping2.ts ===
-var foo: {id:number;} = {id:4, name:"foo"};
->foo : Symbol(foo, Decl(contextualTyping2.ts, 0, 3))
->id : Symbol(id, Decl(contextualTyping2.ts, 0, 10))
->id : Symbol(id, Decl(contextualTyping2.ts, 0, 25))
->name : Symbol(name, Decl(contextualTyping2.ts, 0, 30))
-

tests/baselines/reference/contextualTyping2.types

@@ -1,10 +0,0 @@
-=== tests/cases/compiler/contextualTyping2.ts ===
-var foo: {id:number;} = {id:4, name:"foo"};
->foo : { id: number; }
->id : number
->{id:4, name:"foo"} : { id: number; name: string; }
->id : number
->4 : number
->name : string
->"foo" : string
-

tests/baselines/reference/contextualTyping20.errors.txt

@@ -0,0 +1,13 @@
+tests/cases/compiler/contextualTyping20.ts(1,36): error TS2322: Type '({ id: number; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
+  Type '{ id: number; } | { id: number; name: string; }' is not assignable to type '{ id: number; }'.
+    Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
+      Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.
+
+
+==== tests/cases/compiler/contextualTyping20.ts (1 errors) ====
+    var foo:{id:number;}[] = [{id:1}]; foo = [{id:1}, {id:2, name:"foo"}];
+                                       ~~~
+!!! error TS2322: Type '({ id: number; } | { id: number; name: string; })[]' is not assignable to type '{ id: number; }[]'.
+!!! error TS2322:   Type '{ id: number; } | { id: number; name: string; }' is not assignable to type '{ id: number; }'.
+!!! error TS2322:     Type '{ id: number; name: string; }' is not assignable to type '{ id: number; }'.
+!!! error TS2322:       Object literal may only specify known properties, and 'name' does not exist in type '{ id: number; }'.

tests/baselines/reference/contextualTyping20.symbols

@@ -1,10 +0,0 @@
-=== tests/cases/compiler/contextualTyping20.ts ===
-var foo:{id:number;}[] = [{id:1}]; foo = [{id:1}, {id:2, name:"foo"}];
->foo : Symbol(foo, Decl(contextualTyping20.ts, 0, 3))
->id : Symbol(id, Decl(contextualTyping20.ts, 0, 9))
->id : Symbol(id, Decl(contextualTyping20.ts, 0, 27))
->foo : Symbol(foo, Decl(contextualTyping20.ts, 0, 3))
->id : Symbol(id, Decl(contextualTyping20.ts, 0, 43))
->id : Symbol(id, Decl(contextualTyping20.ts, 0, 51))
->name : Symbol(name, Decl(contextualTyping20.ts, 0, 56))
-

tests/baselines/reference/contextualTyping20.types

@@ -1,20 +0,0 @@
-=== tests/cases/compiler/contextualTyping20.ts ===
-var foo:{id:number;}[] = [{id:1}]; foo = [{id:1}, {id:2, name:"foo"}];
->foo : { id: number; }[]
->id : number
->[{id:1}] : { id: number; }[]
->{id:1} : { id: number; }
->id : number
->1 : number
->foo = [{id:1}, {id:2, name:"foo"}] : { id: number; }[]
->foo : { id: number; }[]
->[{id:1}, {id:2, name:"foo"}] : { id: number; }[]
->{id:1} : { id: number; }
->id : number
->1 : number
->{id:2, name:"foo"} : { id: number; name: string; }
->id : number
->2 : number
->name : string
->"foo" : string
-

tests/baselines/reference/contextualTyping21.errors.txt

@@ -1,5 +1,5 @@
-tests/cases/compiler/contextualTyping21.ts(1,36): error TS2322: Type '(number | { id: number; })[]' is not assignable to type '{ id: number; }[]'.
-  Type 'number | { id: number; }' is not assignable to type '{ id: number; }'.
+tests/cases/compiler/contextualTyping21.ts(1,36): error TS2322: Type '({ id: number; } | number)[]' is not assignable to type '{ id: number; }[]'.
+  Type '{ id: number; } | number' is not assignable to type '{ id: number; }'.
     Type 'number' is not assignable to type '{ id: number; }'.
       Property 'id' is missing in type 'Number'.
 
@@ -7,7 +7,7 @@ tests/cases/compiler/contextualTyping21.ts(1,36): error TS2322: Type '(number |
 ==== tests/cases/compiler/contextualTyping21.ts (1 errors) ====
     var foo:{id:number;}[] = [{id:1}]; foo = [{id:1}, 1];
                                        ~~~
-!!! error TS2322: Type '(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 '({ id: number; } | number)[]' is not assignable to type '{ id: number; }[]'.
+!!! error TS2322:   Type '{ id: number; } | 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'.

tests/baselines/reference/contextualTyping30.errors.txt

@@ -1,11 +1,11 @@
-tests/cases/compiler/contextualTyping30.ts(1,37): error TS2345: Argument of type '(string | number)[]' is not assignable to parameter of type 'number[]'.
-  Type 'string | number' is not assignable to type 'number'.
+tests/cases/compiler/contextualTyping30.ts(1,37): error TS2345: Argument of type '(number | string)[]' is not assignable to parameter of type 'number[]'.
+  Type 'number | string' 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 '(string | number)[]' is not assignable to parameter of type 'number[]'.
-!!! error TS2345:   Type 'string | number' is not assignable to type 'number'.
+!!! error TS2345: Argument of type '(number | string)[]' is not assignable to parameter of type 'number[]'.
+!!! error TS2345:   Type 'number | string' is not assignable to type 'number'.
 !!! error TS2345:     Type 'string' is not assignable to type 'number'.

tests/baselines/reference/contextualTyping37.types

@@ -3,7 +3,7 @@ var foo = <{ id: number; }[]>[{ foo: "s" }, {  }];
 >foo : { id: number; }[]
 ><{ id: number; }[]>[{ foo: "s" }, {  }] : { id: number; }[]
 >id : number
->[{ foo: "s" }, {  }] : {}[]
+>[{ foo: "s" }, {  }] : ({ foo: string; } | {})[]
 >{ foo: "s" } : { foo: string; }
 >foo : string
 >"s" : string