Revert "cache relationships, needs work on preserving diagnostic output"

This reverts commit e7f5c96.

Author: sandersn

src/compiler/checker.ts

@@ -469,25 +469,10 @@ namespace ts {
         };
 
         const subtypeRelation = createMap<RelationComparisonResult>();
-        const subtypeRelationErrors = createMap<DiagnosticMessageChain>();
         const assignableRelation = createMap<RelationComparisonResult>();
-        const assignableRelationErrors = createMap<DiagnosticMessageChain>();
         const comparableRelation = createMap<RelationComparisonResult>();
-        const comparableRelationErrors = createMap<DiagnosticMessageChain>();
         const identityRelation = createMap<RelationComparisonResult>();
-        const identityRelationErrors = createMap<DiagnosticMessageChain>();
         const enumRelation = createMap<boolean>();
-        const enumRelationErrors = createMap<DiagnosticMessageChain>();
-
-        function getErrorCache(relation: Map<RelationComparisonResult> | Map<boolean>) {
-            switch (true) {
-                case relation === subtypeRelation: return subtypeRelationErrors;
-                case relation === assignableRelation: return assignableRelationErrors;
-                case relation === comparableRelation: return comparableRelationErrors;
-                case relation === identityRelation: return identityRelationErrors;
-                case relation === enumRelation: return enumRelationErrors;
-            }
-        }
 
         // This is for caching the result of getSymbolDisplayBuilder. Do not access directly.
         let _displayBuilder: SymbolDisplayBuilder;
@@ -8933,17 +8918,6 @@ namespace ts {
              * * Ternary.False if they are not related.
              */
             function isRelatedTo(source: Type, target: Type, reportErrors?: boolean, headMessage?: DiagnosticMessage): Ternary {
-                const comparisonId = comparisonTypeId(source, target);
-                const cachedResult = fetchRelationResult(comparisonId);
-                if (cachedResult !== undefined) {
-                    if (reportErrors && cachedResult === Ternary.False) {
-                        const cachedChain = getErrorCache(relation).get(comparisonId);
-                        if (cachedChain) {
-                            errorInfo = concatenateDiagnosticMessageChains(errorInfo, cachedChain);
-                        }
-                    }
-                    return cachedResult;
-                }
                 if (source.flags & TypeFlags.StringOrNumberLiteral && source.flags & TypeFlags.FreshLiteral) {
                     source = (<LiteralType>source).regularType;
                 }
@@ -9054,14 +9028,6 @@ namespace ts {
                     }
                     reportRelationError(headMessage, source, target);
                 }
-
-                if (fetchRelationResult(comparisonId) === undefined) {
-                    relation.set(comparisonId, result ? RelationComparisonResult.Succeeded : reportErrors ? RelationComparisonResult.FailedAndReported : RelationComparisonResult.Failed);
-                    if (reportErrors && errorInfo) {
-                        getErrorCache(relation).set(comparisonId, errorInfo);
-                    }
-                }
-
                 return result;
             }
 
@@ -9224,24 +9190,6 @@ namespace ts {
                 return result;
             }
 
-            function comparisonTypeId(source: Type, target: Type) {
-                return relation !== identityRelation || source.id < target.id ? source.id + "," + target.id : target.id + "," + source.id;
-            }
-
-            function fetchRelationResult(id: string, reportErrors?: boolean): Ternary | undefined {
-                const related = relation.get(id);
-                if (related !== undefined) {
-                    if (reportErrors && related === RelationComparisonResult.Failed) {
-                        // We are elaborating errors and the cached result is an unreported failure. Record the result as a reported
-                        // failure and continue computing the relation such that errors get reported.
-                        relation.set(id, RelationComparisonResult.FailedAndReported);
-                    }
-                    else {
-                        return related === RelationComparisonResult.Succeeded ? Ternary.True : Ternary.False;
-                    }
-                }
-            }
-
             // Determine if possibly recursive types are related. First, check if the result is already available in the global cache.
             // Second, check if we have already started a comparison of the given two types in which case we assume the result to be true.
             // Third, check if both types are part of deeply nested chains of generic type instantiations and if so assume the types are
@@ -9260,7 +9208,7 @@ namespace ts {
                     // this is a copy of the normal code! It can probably be merged somehow.
                     const src = (source as TypeReference).target;
                     const trg = (target as TypeReference).target;
-                    const id = comparisonTypeId(src, trg);
+                    const id = relation !== identityRelation || src.id < trg.id ? src.id + "," + trg.id : trg.id + "," + src.id;
                     if (!maybeReferenceKeys) {
                         maybeReferenceKeys = [];
                     }
@@ -9275,11 +9223,19 @@ namespace ts {
                     maybeReferenceCount++;
                 }
 
-                const id = comparisonTypeId(source, target);
-                const cachedResult = fetchRelationResult(id);
-                if (cachedResult !== undefined) {
-                    return cachedResult;
+                const id = relation !== identityRelation || source.id < target.id ? source.id + "," + target.id : target.id + "," + source.id;
+                const related = relation.get(id);
+                if (related !== undefined) {
+                    if (reportErrors && related === RelationComparisonResult.Failed) {
+                        // We are elaborating errors and the cached result is an unreported failure. Record the result as a reported
+                        // failure and continue computing the relation such that errors get reported.
+                        relation.set(id, RelationComparisonResult.FailedAndReported);
+                    }
+                    else {
+                        return related === RelationComparisonResult.Succeeded ? Ternary.True : Ternary.False;
+                    }
                 }
+
                 if (!maybeKeys) {
                     maybeKeys = [];
                     sourceStack = [];