@@ -8830,8 +8830,7 @@ namespace ts {
8830
8830
let sourceStack: Type[];
8831
8831
let targetStack: Type[];
8832
8832
let maybeCount = 0;
8833
- let maybeReferenceKeys: string[];
8834
- let maybeReferenceCount = 0;
8833
+ let maybeReferences: Map<true>;
8835
8834
let depth = 0;
8836
8835
let expandingFlags = 0;
8837
8836
let overflow = false;
@@ -9190,37 +9189,34 @@ namespace ts {
9190
9189
return result;
9191
9190
}
9192
9191
9193
- function checkTypeReferenceMaybeStack(source: Type, target: Type): Ternary {
9192
+ function getTypePairKey(source: Type, target: Type) {
9193
+ return relation !== identityRelation || source.id < target.id ? source.id + "," + target.id : target.id + "," + source.id;
9194
+ }
9195
+
9196
+ function alreadyComparingTypeReferences(source: Type, target: Type) {
9194
9197
if (!(getObjectFlags(source) & ObjectFlags.Reference) || !(getObjectFlags(target) & ObjectFlags.Reference)) {
9195
- return Ternary.False ;
9198
+ return false ;
9196
9199
}
9197
9200
const sourceArguments = (source as TypeReference).typeArguments;
9198
9201
const targetArguments = (source as TypeReference).typeArguments;
9199
- const sourceGeneric = (source as TypeReference).target;
9200
- const targetGeneric = (source as TypeReference).target;
9201
9202
9202
9203
const onlyTypeParametersAsArguments =
9203
9204
arrayIsEqualTo(sourceArguments, targetArguments) &&
9204
9205
sourceArguments && sourceArguments.length > 0 &&
9205
9206
every(sourceArguments, t => !!(t.flags & TypeFlags.TypeParameter));
9206
9207
if (!onlyTypeParametersAsArguments) {
9207
- return Ternary.False ;
9208
+ return false ;
9208
9209
}
9209
- const id = (relation !== identityRelation || sourceGeneric.id < targetGeneric.id ? sourceGeneric.id + "," + targetGeneric.id : targetGeneric.id + "," + sourceGeneric.id ) +
9210
- "<" + map(sourceArguments, t => { let c = getConstraintFromTypeParameter(t as TypeParameter); return c ? c.id : "" }).join(',') + ">" ;
9211
- if (!maybeReferenceKeys ) {
9212
- maybeReferenceKeys = [] ;
9210
+ const id = getTypePairKey(source, target ) +
9211
+ "<" + map(sourceArguments, t => { let c = getConstraintFromTypeParameter(t as TypeParameter); return c ? c.id : "" }).join(',');
9212
+ if (!maybeReferences ) {
9213
+ maybeReferences = createMap<true>() ;
9213
9214
}
9214
- else {
9215
- for (let i = 0; i < maybeReferenceCount; i++) {
9216
- if (id === maybeReferenceKeys[i]) {
9217
- return Ternary.Maybe;
9218
- }
9219
- }
9215
+ else if (maybeReferences.has(id)) {
9216
+ return true;
9220
9217
}
9221
- maybeReferenceKeys[maybeReferenceCount] = id;
9222
- maybeReferenceCount++;
9223
- return Ternary.False;
9218
+ maybeReferences.set(id, true);
9219
+ return false;
9224
9220
}
9225
9221
9226
9222
// Determine if possibly recursive types are related. First, check if the result is already available in the global cache.
@@ -9233,7 +9229,7 @@ namespace ts {
9233
9229
return Ternary.False;
9234
9230
}
9235
9231
9236
- const id = relation !== identityRelation || source.id < target.id ? source.id + "," + target.id : target.id + "," + source.id ;
9232
+ const id = getTypePairKey( source, target) ;
9237
9233
const related = relation.get(id);
9238
9234
if (related !== undefined) {
9239
9235
if (reportErrors && related === RelationComparisonResult.Failed) {
@@ -9263,7 +9259,7 @@ namespace ts {
9263
9259
return Ternary.False;
9264
9260
}
9265
9261
}
9266
- if (checkTypeReferenceMaybeStack (source, target) === Ternary.Maybe ) {
9262
+ if (alreadyComparingTypeReferences (source, target)) {
9267
9263
return Ternary.Maybe;
9268
9264
}
9269
9265
0 commit comments