Ensure common supertype retains nullability

Author: jakebailey

src/compiler/checker.ts

@@ -21228,7 +21228,17 @@ namespace ts {
             const primaryTypes = filter(types, t => !(t.flags & TypeFlags.Nullable));
             if (primaryTypes.length) {
                 const supertypeOrUnion = getSupertypeOrUnion(primaryTypes);
-                return primaryTypes === types ? supertypeOrUnion : getUnionType([supertypeOrUnion, ...filter(types, t => !!(t.flags & TypeFlags.Nullable))]);
+                const supertypeOrUnionFacts = getTypeFacts(supertypeOrUnion);
+                const allFacts = getAllTypeFacts(types);
+
+                let missingNullableFlags: TypeFlags = 0;
+                if (allFacts & TypeFacts.IsNull && !(supertypeOrUnionFacts & TypeFacts.IsNull)) {
+                    missingNullableFlags |= TypeFlags.Null;
+                }
+                if (allFacts & TypeFacts.IsUndefined && !(supertypeOrUnionFacts & TypeFacts.IsUndefined)) {
+                    missingNullableFlags |= TypeFlags.Undefined;
+                }
+                return getNullableType(supertypeOrUnion, missingNullableFlags);
             }
             return getUnionType(types, UnionReduction.Subtype);
         }
@@ -23717,14 +23727,18 @@ namespace ts {
                 return TypeFacts.None;
             }
             if (flags & TypeFlags.Union) {
-                return reduceLeft((type as UnionType).types, (facts, t) => facts | getTypeFacts(t), TypeFacts.None);
+                return getAllTypeFacts((type as UnionType).types);
             }
             if (flags & TypeFlags.Intersection) {
                 return getIntersectionTypeFacts(type as IntersectionType);
             }
             return TypeFacts.UnknownFacts;
         }
 
+        function getAllTypeFacts(types: Type[]): TypeFacts {
+            return reduceLeft(types, (facts, t) => facts | getTypeFacts(t), TypeFacts.None);
+        }
+
         function getIntersectionTypeFacts(type: IntersectionType): TypeFacts {
             // When an intersection contains a primitive type we ignore object type constituents as they are
             // presumably type tags. For example, in string & { __kind__: "name" } we ignore the object type.

tests/baselines/reference/inferenceOfNullableObjectTypesWithCommonBase.errors.txt

@@ -1,10 +1,8 @@
-tests/cases/compiler/inferenceOfNullableObjectTypesWithCommonBase.ts(10,15): error TS2345: Argument of type 'D | undefined' is not assignable to parameter of type 'B'.
-  Type 'undefined' is not assignable to type 'B'.
 tests/cases/compiler/inferenceOfNullableObjectTypesWithCommonBase.ts(11,27): error TS2345: Argument of type 'B' is not assignable to parameter of type 'D'.
   Property 'bar' is missing in type 'B' but required in type 'D'.
 
 
-==== tests/cases/compiler/inferenceOfNullableObjectTypesWithCommonBase.ts (2 errors) ====
+==== tests/cases/compiler/inferenceOfNullableObjectTypesWithCommonBase.ts (1 errors) ====
     function equal<T>(a: T, b: T) { }
 
     let v = null!;
@@ -15,9 +13,6 @@ tests/cases/compiler/inferenceOfNullableObjectTypesWithCommonBase.ts(11,27): err
     type D = { foo: string; bar: number }
 
     equal(v as B, v as undefined | D)
-                  ~~~~~~~~~~~~~~~~~~
-!!! error TS2345: Argument of type 'D | undefined' is not assignable to parameter of type 'B'.
-!!! error TS2345:   Type 'undefined' is not assignable to type 'B'.
     equal(v as undefined | D, v as B)
                               ~~~~~~
 !!! error TS2345: Argument of type 'B' is not assignable to parameter of type 'D'.