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,7 +13913,7 @@ 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) {

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
     }
 });