Merge pull request #919 from Microsoft/optionalPropertySubtyping

Require optional properties to be present in subtypes

Author: ahejlsberg

src/compiler/checker.ts

@@ -3372,7 +3372,7 @@ module ts {
                     var sourceProp = getPropertyOfApparentType(<ApparentType>source, targetProp.name);
                     if (sourceProp !== targetProp) {
                         if (!sourceProp) {
-                            if (!isOptionalProperty(targetProp)) {
+                            if (relation === subtypeRelation || !isOptionalProperty(targetProp)) {
                                 if (reportErrors) {
                                     reportError(Diagnostics.Property_0_is_missing_in_type_1, symbolToString(targetProp), typeToString(source));
                                 }
@@ -3661,10 +3661,6 @@ module ts {
             return forEach(types, t => isSupertypeOfEach(t, types) ? t : undefined);
         }
 
-        function getBestCommonType(types: Type[], contextualType: Type): Type {
-            return contextualType && isSupertypeOfEach(contextualType, types) ? contextualType : getUnionType(types);
-        }
-
         function isTypeOfObjectLiteral(type: Type): boolean {
             return (type.flags & TypeFlags.Anonymous) && type.symbol && (type.symbol.flags & SymbolFlags.ObjectLiteral) ? true : false;
         }
@@ -5751,7 +5747,7 @@ module ts {
                 case SyntaxKind.GreaterThanToken:
                 case SyntaxKind.LessThanEqualsToken:
                 case SyntaxKind.GreaterThanEqualsToken:
-                    if (!isTypeSubtypeOf(leftType, rightType) && !isTypeSubtypeOf(rightType, leftType)) {
+                    if (!isTypeAssignableTo(leftType, rightType) && !isTypeAssignableTo(rightType, leftType)) {
                         reportOperatorError();
                     }
                     return booleanType;

src/compiler/emitter.ts

@@ -2868,7 +2868,7 @@ module ts {
                         }
                         return {
                             diagnosticMessage: diagnosticMessage,
-                            errorNode: node.parameters[0],
+                            errorNode: <Node>node.parameters[0],
                             typeName: node.name
                         };
                     }
@@ -2889,7 +2889,7 @@ module ts {
                         }
                         return {
                             diagnosticMessage: diagnosticMessage,
-                            errorNode: node.name,
+                            errorNode: <Node>node.name,
                             typeName: undefined
                         };
                     }

tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.types

@@ -17,20 +17,20 @@ var c: { x: number; a?: number };
 >a : number
 
 var as = [a, b]; // { x: number; y?: number };[]
->as : { x: number; y?: number; }[]
->[a, b] : { x: number; y?: number; }[]
+>as : ({ x: number; y?: number; } | { x: number; z?: number; })[]
+>[a, b] : ({ x: number; y?: number; } | { x: number; z?: number; })[]
 >a : { x: number; y?: number; }
 >b : { x: number; z?: number; }
 
 var bs = [b, a]; // { x: number; z?: number };[]
->bs : { x: number; y?: number; }[]
->[b, a] : { x: number; y?: number; }[]
+>bs : ({ x: number; y?: number; } | { x: number; z?: number; })[]
+>[b, a] : ({ x: number; y?: number; } | { x: number; z?: number; })[]
 >b : { x: number; z?: number; }
 >a : { x: number; y?: number; }
 
 var cs = [a, b, c]; // { x: number; y?: number };[]
->cs : { x: number; y?: number; }[]
->[a, b, c] : { x: number; y?: number; }[]
+>cs : ({ x: number; y?: number; } | { x: number; z?: number; } | { x: number; a?: number; })[]
+>[a, b, c] : ({ x: number; y?: number; } | { x: number; z?: number; } | { x: number; a?: number; })[]
 >a : { x: number; y?: number; }
 >b : { x: number; z?: number; }
 >c : { x: number; a?: number; }
@@ -54,8 +54,8 @@ var es = [(x: string) => 2, (x: Object) => 1]; // { (x:string) => number }[]
 >Object : Object
 
 var fs = [(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2]; // (a: { x: number; y?: number }) => number[]
->fs : ((a: { x: number; y?: number; }) => number)[]
->[(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2] : ((a: { x: number; y?: number; }) => number)[]
+>fs : (((a: { x: number; y?: number; }) => number) | ((b: { x: number; z?: number; }) => number))[]
+>[(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2] : (((a: { x: number; y?: number; }) => number) | ((b: { x: number; z?: number; }) => number))[]
 >(a: { x: number; y?: number }) => 1 : (a: { x: number; y?: number; }) => number
 >a : { x: number; y?: number; }
 >x : number
@@ -66,8 +66,8 @@ var fs = [(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) =>
 >z : number
 
 var gs = [(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1]; // (b: { x: number; z?: number }) => number[]
->gs : ((b: { x: number; z?: number; }) => number)[]
->[(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1] : ((b: { x: number; z?: number; }) => number)[]
+>gs : (((b: { x: number; z?: number; }) => number) | ((a: { x: number; y?: number; }) => number))[]
+>[(b: { x: number; z?: number }) => 2, (a: { x: number; y?: number }) => 1] : (((b: { x: number; z?: number; }) => number) | ((a: { x: number; y?: number; }) => number))[]
 >(b: { x: number; z?: number }) => 2 : (b: { x: number; z?: number; }) => number
 >b : { x: number; z?: number; }
 >x : number

tests/baselines/reference/bestCommonTypeOfConditionalExpressions.types

@@ -48,14 +48,14 @@ var r3 = true ? 1 : {};
 >{} : {}
 
 var r4 = true ? a : b; // typeof a
->r4 : { x: number; y?: number; }
->true ? a : b : { x: number; y?: number; }
+>r4 : { x: number; y?: number; } | { x: number; z?: number; }
+>true ? a : b : { x: number; y?: number; } | { x: number; z?: number; }
 >a : { x: number; y?: number; }
 >b : { x: number; z?: number; }
 
 var r5 = true ? b : a; // typeof b
->r5 : { x: number; y?: number; }
->true ? b : a : { x: number; y?: number; }
+>r5 : { x: number; y?: number; } | { x: number; z?: number; }
+>true ? b : a : { x: number; y?: number; } | { x: number; z?: number; }
 >b : { x: number; z?: number; }
 >a : { x: number; y?: number; }