elaborate check before converting fresh literal type to regular

src/compiler/checker.ts

@@ -7156,6 +7156,25 @@ namespace ts {
                 }
             }
 
+            function isUnionOrIntersectionTypeWithoutNullableConstituents(type: Type): boolean {
+                if (!(type.flags & TypeFlags.UnionOrIntersection)) {
+                    return false;
+                }
+                // at this point we know that this is union or intersection type possibly with nullable constituents.
+                // check if we still will have compound type if we ignore nullable components.
+                let seenNonNullable = false;
+                for (const t of (<UnionOrIntersectionType>type).types) {
+                    if (t.flags & TypeFlags.Nullable) {
+                        continue;
+                    }
+                    if (seenNonNullable) {
+                        return true;
+                    }
+                    seenNonNullable = true;
+                }
+                return false;
+            }
+
             // 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
@@ -7188,7 +7207,7 @@ namespace ts {
                     // 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.
-                    if (target.flags & TypeFlags.UnionOrIntersection) {
+                    if (isUnionOrIntersectionTypeWithoutNullableConstituents(target)) {
                         source = getRegularTypeOfObjectLiteral(source);
                     }
                 }

tests/baselines/reference/nestedFreshLiteral.errors.txt

@@ -0,0 +1,31 @@
+tests/cases/compiler/nestedFreshLiteral.ts(12,21): error TS2322: Type '{ nested: { prop: { colour: string; }; }; }' is not assignable to type 'NestedCSSProps'.
+  Types of property 'nested' are incompatible.
+    Type '{ prop: { colour: string; }; }' is not assignable to type 'NestedSelector | undefined'.
+      Type '{ prop: { colour: string; }; }' is not assignable to type 'NestedSelector'.
+        Types of property 'prop' are incompatible.
+          Type '{ colour: string; }' is not assignable to type 'CSSProps'.
+            Object literal may only specify known properties, and 'colour' does not exist in type 'CSSProps'.
+
+
+==== tests/cases/compiler/nestedFreshLiteral.ts (1 errors) ====
+    interface CSSProps  {
+      color?: string
+    }
+    interface NestedCSSProps {
+      nested?: NestedSelector
+    }
+    interface NestedSelector  {
+      prop: CSSProps;
+    }
+
+    let stylen: NestedCSSProps = {
+      nested: { prop: { colour: 'red' } }
+                        ~~~~~~~~~~~~~
+!!! error TS2322: Type '{ nested: { prop: { colour: string; }; }; }' is not assignable to type 'NestedCSSProps'.
+!!! error TS2322:   Types of property 'nested' are incompatible.
+!!! error TS2322:     Type '{ prop: { colour: string; }; }' is not assignable to type 'NestedSelector | undefined'.
+!!! error TS2322:       Type '{ prop: { colour: string; }; }' is not assignable to type 'NestedSelector'.
+!!! error TS2322:         Types of property 'prop' are incompatible.
+!!! error TS2322:           Type '{ colour: string; }' is not assignable to type 'CSSProps'.
+!!! error TS2322:             Object literal may only specify known properties, and 'colour' does not exist in type 'CSSProps'.
+    }

tests/baselines/reference/nestedFreshLiteral.js

@@ -0,0 +1,19 @@
+//// [nestedFreshLiteral.ts]
+interface CSSProps  {
+  color?: string
+}
+interface NestedCSSProps {
+  nested?: NestedSelector
+}
+interface NestedSelector  {
+  prop: CSSProps;
+}
+
+let stylen: NestedCSSProps = {
+  nested: { prop: { colour: 'red' } }
+}
+
+//// [nestedFreshLiteral.js]
+var stylen = {
+    nested: { prop: { colour: 'red' } }
+};

tests/cases/compiler/nestedFreshLiteral.ts

@@ -0,0 +1,14 @@
+// @strictNullChecks: true
+interface CSSProps  {
+  color?: string
+}
+interface NestedCSSProps {
+  nested?: NestedSelector
+}
+interface NestedSelector  {
+  prop: CSSProps;
+}
+
+let stylen: NestedCSSProps = {
+  nested: { prop: { colour: 'red' } }
+}