From 955db84f2c556fddc459bab28440c681fa3d7d81 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <293473+sandersn@users.noreply.github.com>
Date: Thu, 14 Dec 2017 15:03:12 -0800
Subject: [PATCH] Simplify printing of deferred mapped types

Just print {} for the type of deferred symbols. This is simple although
it loses fidelity pretty badly. It will not be sufficient for projects
that want to export the result of an inference. I don't think any such
projects exist right now, though.
---
 src/compiler/checker.ts | 25 ++-----------------------
 1 file changed, 2 insertions(+), 23 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index dbc12b1461a..6fc9ae48ae2 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -335,7 +335,6 @@ namespace ts {
 
         const globals = createSymbolTable();
         const deferredInferenceCache = createMap<Type | undefined>();
-        const deferredMappedTypeInstantiationStack: string[] = [];
         let ambientModulesCache: Symbol[] | undefined;
         /**
          * List of every ambient module with a "*" wildcard.
@@ -2868,23 +2867,7 @@ namespace ts {
                     }
 
                     for (const propertySymbol of properties) {
-                        let propertyType: Type;
-                        if (getCheckFlags(propertySymbol) & CheckFlags.DeferredInferred) {
-                            const deferred = propertySymbol as DeferredTransientSymbol;
-                            const key = deferred.propertyType.id + "," + (deferred.mappedType.symbol ? deferred.mappedType.symbol.id : "");
-                            // Temporary solution to recursive printing: zero out repeated types.
-                            if (contains(deferredMappedTypeInstantiationStack, key)) {
-                                // TODO: Could probably be an actual cache that returns {} when it contains undefined.
-                                propertyType = emptyObjectType;
-                            }
-                            else {
-                                deferredMappedTypeInstantiationStack.push(key)
-                                propertyType = getTypeOfSymbol(propertySymbol);
-                            }
-                        }
-                        else {
-                            propertyType = getTypeOfSymbol(propertySymbol);
-                        }
+                        const propertyType = getCheckFlags(propertySymbol) & CheckFlags.DeferredInferred ? emptyObjectType : getTypeOfSymbol(propertySymbol);
                         const saveEnclosingDeclaration = context.enclosingDeclaration;
                         context.enclosingDeclaration = undefined;
                         const propertyName = symbolToName(propertySymbol, context, SymbolFlags.Value, /*expectsIdentifier*/ true);
@@ -2911,9 +2894,6 @@ namespace ts {
                                /*initializer*/ undefined);
                             typeElements.push(propertySignature);
                         }
-                        if (getCheckFlags(propertySymbol) & CheckFlags.DeferredInferred) {
-                            deferredMappedTypeInstantiationStack.pop();
-                        }
                     }
                     return typeElements.length ? typeElements : undefined;
                 }
@@ -11278,7 +11258,7 @@ namespace ts {
                     const checkFlags = CheckFlags.DeferredInferred | (readonlyMask && isReadonlySymbol(prop) ? CheckFlags.Readonly : 0);
                     const inferredProp = createSymbol(SymbolFlags.Property | prop.flags & optionalMask, prop.escapedName, checkFlags) as DeferredTransientSymbol;
                     inferredProp.declarations = prop.declarations;
-                    inferredProp.propertyType = propType; // not sure I need this.
+                    inferredProp.propertyType = propType;
                     inferredProp.mappedType = target;
                     members.set(prop.escapedName, inferredProp);
                 }
@@ -11295,7 +11275,6 @@ namespace ts {
             const typeParameter = <TypeParameter>getIndexedAccessType((<IndexType>getConstraintTypeFromMappedType(target)).type, getTypeParameterFromMappedType(target));
             const templateType = getTemplateTypeFromMappedType(target);
             const inference = createInferenceInfo(typeParameter);
-            inference.candidates = undefined;
             inferTypes([inference], sourceType, templateType);
             return inference.candidates ? getUnionType(inference.candidates, UnionReduction.Subtype) : emptyObjectType;
         }