Readd simple preservation fix

Author: weswigham

src/compiler/checker.ts

@@ -7777,7 +7777,7 @@ namespace ts {
         // expression constructs such as array literals and the || and ?: operators). Named types can
         // circularly reference themselves and therefore cannot be subtype reduced during their declaration.
         // For example, "type Item = string | (() => Item" is a named type that circularly references itself.
-        function getUnionType(types: Type[], subtypeReduction?: boolean, aliasSymbol?: Symbol, aliasTypeArguments?: Type[]): Type {
+        function getUnionType(types: Type[], subtypeReduction?: boolean, aliasSymbol?: Symbol, aliasTypeArguments?: Type[], noReductions?: boolean): Type {
             if (types.length === 0) {
                 return neverType;
             }
@@ -7789,11 +7789,13 @@ namespace ts {
             if (typeSet.containsAny) {
                 return anyType;
             }
-            if (subtypeReduction) {
-                removeSubtypes(typeSet);
-            }
-            else if (typeSet.containsLiteralOrUniqueESSymbol) {
-                removeRedundantLiteralTypes(typeSet);
+            if (!noReductions) {
+                if (subtypeReduction) {
+                    removeSubtypes(typeSet);
+                }
+                else if (typeSet.containsLiteralOrUniqueESSymbol) {
+                    removeRedundantLiteralTypes(typeSet);
+                }
             }
             if (typeSet.length === 0) {
                 return typeSet.containsNull ? typeSet.containsNonWideningType ? nullType : nullWideningType :
@@ -12104,7 +12106,7 @@ namespace ts {
         // Apply a mapping function to a type and return the resulting type. If the source type
         // is a union type, the mapping function is applied to each constituent type and a union
         // of the resulting types is returned.
-        function mapType(type: Type, mapper: (t: Type) => Type): Type {
+        function mapType(type: Type, mapper: (t: Type) => Type, noReductions?: boolean): Type {
             if (!(type.flags & TypeFlags.Union)) {
                 return mapper(type);
             }
@@ -12125,7 +12127,7 @@ namespace ts {
                     }
                 }
             }
-            return mappedTypes ? getUnionType(mappedTypes) : mappedType;
+            return mappedTypes ? getUnionType(mappedTypes, /*subtypeReduction*/ undefined, /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, noReductions) : mappedType;
         }
 
         function extractTypesOfKind(type: Type, kind: TypeFlags) {
@@ -13911,11 +13913,11 @@ namespace ts {
             return mapType(type, t => {
                 const prop = t.flags & TypeFlags.StructuredType ? getPropertyOfType(t, name) : undefined;
                 return prop ? getTypeOfSymbol(prop) : undefined;
-            });
+            }, /*noReductions*/ true);
         }
 
         function getIndexTypeOfContextualType(type: Type, kind: IndexKind) {
-            return mapType(type, t => getIndexTypeOfStructuredType(t, kind));
+            return mapType(type, t => getIndexTypeOfStructuredType(t, kind), /*noReductions*/ true);
         }
 
         // Return true if the given contextual type is a tuple-like type

tests/baselines/reference/contextualTypeShouldBeLiteral.errors.txt

@@ -104,6 +104,8 @@ foo2({
 
         this;
         this.value;
+>this.value : Symbol(value, Decl(contextualTypeShouldBeLiteral.ts, 25, 15), Decl(contextualTypeShouldBeLiteral.ts, 31, 15))
+>value : Symbol(value, Decl(contextualTypeShouldBeLiteral.ts, 25, 15), Decl(contextualTypeShouldBeLiteral.ts, 31, 15))
     }
 });
 

tests/baselines/reference/contextualTypeShouldBeLiteral.symbols

@@ -97,7 +97,7 @@ function foo2(bar: X2 | Y2) { }
 foo2({
 >foo2({    type2: 'y',    value: 'done',    method() {        this;        this.value;    }}) : void
 >foo2 : (bar: X2 | Y2) => void
->{    type2: 'y',    value: 'done',    method() {        this;        this.value;    }} : { type2: string; value: string; method(): void; }
+>{    type2: 'y',    value: 'done',    method() {        this;        this.value;    }} : { type2: "y"; value: "done"; method(): void; }
 
     type2: 'y',
 >type2 : string
@@ -111,12 +111,12 @@ foo2({
 >method : () => void
 
         this;
->this : any
+>this : X2 | Y2
 
         this.value;
->this.value : any
->this : any
->value : any
+>this.value : string
+>this : X2 | Y2
+>value : string
     }
 });
 

tests/baselines/reference/contextualTypeShouldBeLiteral.types

@@ -16,7 +16,8 @@ hasZField(directUnionSingle) // ok
 hasZField(directUnionArray) // ok
 hasZField(nestedSingle) // ok
 hasZField(nestedUnionSingle) // ok
-hasZField(nestedUnionArray) // ok
+hasZField(nestedUnionArray) // ok
+
 
 //// [nestedTypeVariableInfersLiteral.js]
 var directUnionSingle = direct("z");

tests/baselines/reference/nestedTypeVariableInfersLiteral.errors.txt

@@ -35,10 +35,10 @@ const directUnionSingle = direct("z")
 >"z" : "z"
 
 const directUnionArray = direct(["z", "y"])
->directUnionArray : any
->direct(["z", "y"]) : any
+>directUnionArray : Record<"z" | "y", string>
+>direct(["z", "y"]) : Record<"z" | "y", string>
 >direct : <A extends string>(a: A | A[]) => Record<A, string>
->["z", "y"] : string[]
+>["z", "y"] : ("z" | "y")[]
 >"z" : "z"
 >"y" : "y"
 
@@ -59,12 +59,12 @@ const nestedUnionSingle = nestedUnion({fields: "z"})
 >"z" : "z"
 
 const nestedUnionArray = nestedUnion({fields: ["z", "y"]})
->nestedUnionArray : any
->nestedUnion({fields: ["z", "y"]}) : any
+>nestedUnionArray : Record<"z" | "y", string>
+>nestedUnion({fields: ["z", "y"]}) : Record<"z" | "y", string>
 >nestedUnion : <A extends string>(a: { fields: A | A[]; }) => Record<A, string>
->{fields: ["z", "y"]} : { fields: string[]; }
->fields : string[]
->["z", "y"] : string[]
+>{fields: ["z", "y"]} : { fields: ("z" | "y")[]; }
+>fields : ("z" | "y")[]
+>["z", "y"] : ("z" | "y")[]
 >"z" : "z"
 >"y" : "y"
 
@@ -81,7 +81,7 @@ hasZField(directUnionSingle) // ok
 hasZField(directUnionArray) // ok
 >hasZField(directUnionArray) : void
 >hasZField : (arg: { z: string; }) => void
->directUnionArray : any
+>directUnionArray : Record<"z" | "y", string>
 
 hasZField(nestedSingle) // ok
 >hasZField(nestedSingle) : void
@@ -96,5 +96,5 @@ hasZField(nestedUnionSingle) // ok
 hasZField(nestedUnionArray) // ok
 >hasZField(nestedUnionArray) : void
 >hasZField : (arg: { z: string; }) => void
->nestedUnionArray : any
+>nestedUnionArray : Record<"z" | "y", string>
 

tests/baselines/reference/nestedTypeVariableInfersLiteral.js

@@ -15,4 +15,4 @@ hasZField(directUnionSingle) // ok
 hasZField(directUnionArray) // ok
 hasZField(nestedSingle) // ok
 hasZField(nestedUnionSingle) // ok
-hasZField(nestedUnionArray) // ok
+hasZField(nestedUnionArray) // ok