From 4f7b45dfccd16fb15d1ac3a351e55de780e4dccf Mon Sep 17 00:00:00 2001
From: Mikhail Glukhikh <mikhail.glukhikh@jetbrains.com>
Date: Mon, 16 Nov 2020 13:20:04 +0300
Subject: [PATCH] Fir2IrTypeConverter: simplify captured type cache

---
 .../kotlin/fir/backend/Fir2IrTypeConverter.kt    | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt
index fad22e07e47..15a5d50738a 100644
--- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt
+++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrTypeConverter.kt
@@ -59,10 +59,10 @@ class Fir2IrTypeConverter(
     )
 
     private val capturedTypeCache = mutableMapOf<ConeCapturedType, IrType>()
-    private val capturedTypeStack = mutableSetOf<ConeCapturedType>()
+    private val errorTypeForCapturedTypeStub by lazy { createErrorType() }
 
     fun FirTypeRef.toIrType(typeContext: ConversionTypeContext = ConversionTypeContext.DEFAULT): IrType {
-        capturedTypeStack.clear()
+        capturedTypeCache.clear()
         return when (this) {
             !is FirResolvedTypeRef -> createErrorType()
             !is FirImplicitBuiltinTypeRef -> type.toIrType(typeContext, annotations)
@@ -110,15 +110,19 @@ class Fir2IrTypeConverter(
                 upperBound.toIrType(typeContext)
             }
             is ConeCapturedType -> {
-                if (capturedTypeStack.add(this)) {
-                    val irType = lowerType?.toIrType(typeContext) ?: constructor.supertypes!!.first().toIrType(typeContext)
+                val cached = capturedTypeCache[this]
+                if (cached == null) {
+                    val irType = lowerType?.toIrType(typeContext) ?: run {
+                        capturedTypeCache[this] = errorTypeForCapturedTypeStub
+                        constructor.supertypes!!.first().toIrType(typeContext)
+                    }
                     capturedTypeCache[this] = irType
                     irType
                 } else {
                     // Potentially recursive captured type, e.g., Recursive<R> where R : Recursive<R>, ...
                     // That should have been handled during type argument conversion, though.
                     // Or, simply repeated captured type, e.g., FunctionN<..., *, ..., *>, literally same captured types.
-                    capturedTypeCache[this] ?: createErrorType()
+                    cached
                 }
             }
             is ConeDefinitelyNotNullType -> {
@@ -145,7 +149,7 @@ class Fir2IrTypeConverter(
                 makeTypeProjection(irType, Variance.OUT_VARIANCE)
             }
             is ConeKotlinType -> {
-                if (this is ConeCapturedType && capturedTypeStack.contains(this) && this.isRecursive(mutableSetOf())) {
+                if (this is ConeCapturedType && this in capturedTypeCache && this.isRecursive(mutableSetOf())) {
                     // Recursive captured type, e.g., Recursive<R> where R : Recursive<R>, ...
                     // We can return * early here to avoid recursive type conversions.
                     IrStarProjectionImpl