[SLC] migrate from ImmutableHashMap to PersistentHashMap

^KTIJ-23783

analysis/symbol-light-classes/build.gradle.kts

@@ -15,6 +15,7 @@ dependencies {
     implementation(project(":analysis:project-structure"))
     implementation(project(":analysis:decompiled:light-classes-for-decompiled"))
     implementation(intellijCore())
+    implementation(kotlinxCollectionsImmutable())
 
     testImplementation(project(":analysis:decompiled:decompiler-to-file-stubs"))
     testImplementation(projectTests(":analysis:decompiled:decompiler-to-file-stubs"))

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/classes/SymbolLightClassForNamedClassLike.kt

@@ -25,8 +25,6 @@ import org.jetbrains.kotlin.light.classes.symbol.modifierLists.LazyModifiersBox
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.with
 import org.jetbrains.kotlin.light.classes.symbol.toPsiVisibilityForClass
 import org.jetbrains.kotlin.psi.KtClassOrObject
-import org.jetbrains.kotlin.util.javaslang.ImmutableHashMap
-import org.jetbrains.kotlin.util.javaslang.ImmutableMap
 import org.jetbrains.kotlin.utils.addToStdlib.applyIf
 
 abstract class SymbolLightClassForNamedClassLike : SymbolLightClassForClassLike<KtNamedClassOrObjectSymbol> {
@@ -128,7 +126,7 @@ abstract class SymbolLightClassForNamedClassLike : SymbolLightClassForClassLike<
         }
     }
 
-    internal fun computeModifiers(modifier: String): ImmutableMap<String, Boolean>? = when (modifier) {
+    internal fun computeModifiers(modifier: String): Map<String, Boolean>? = when (modifier) {
         in LazyModifiersBox.VISIBILITY_MODIFIERS -> {
             val visibility = withClassOrObjectSymbol { it.toPsiVisibilityForClass(isNested = !isTopLevel) }
             LazyModifiersBox.VISIBILITY_MODIFIERS_MAP.with(visibility)
@@ -137,7 +135,7 @@ abstract class SymbolLightClassForNamedClassLike : SymbolLightClassForClassLike<
         in LazyModifiersBox.MODALITY_MODIFIERS -> LazyModifiersBox.computeSimpleModality(ktModule, classOrObjectSymbolPointer)
         PsiModifier.STATIC -> {
             val isStatic = !isTopLevel && !isInner
-            ImmutableHashMap.of(modifier, isStatic)
+            mapOf(modifier to isStatic)
         }
 
         else -> null

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/SymbolLightFieldForObject.kt

@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.light.classes.symbol.modifierLists.with
 import org.jetbrains.kotlin.light.classes.symbol.nonExistentType
 import org.jetbrains.kotlin.light.classes.symbol.withSymbol
 import org.jetbrains.kotlin.psi.KtObjectDeclaration
-import org.jetbrains.kotlin.util.javaslang.ImmutableMap
 
 internal class SymbolLightFieldForObject private constructor(
     containingClass: SymbolLightClassForClassLike<*>,
@@ -65,7 +64,7 @@ internal class SymbolLightFieldForObject private constructor(
         }
     }
 
-    private fun computeModifiers(modifier: String): ImmutableMap<String, Boolean>? {
+    private fun computeModifiers(modifier: String): Map<String, Boolean>? {
         if (modifier !in LazyModifiersBox.VISIBILITY_MODIFIERS) return null
         return LazyModifiersBox.computeVisibilityForMember(ktModule, objectSymbolPointer)
     }

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/SymbolLightFieldForProperty.kt

@@ -32,8 +32,6 @@ import org.jetbrains.kotlin.name.JvmNames.TRANSIENT_ANNOTATION_CLASS_ID
 import org.jetbrains.kotlin.name.JvmNames.VOLATILE_ANNOTATION_CLASS_ID
 import org.jetbrains.kotlin.psi.KtCallableDeclaration
 import org.jetbrains.kotlin.psi.KtProperty
-import org.jetbrains.kotlin.util.javaslang.ImmutableHashMap
-import org.jetbrains.kotlin.util.javaslang.ImmutableMap
 
 internal class SymbolLightFieldForProperty private constructor(
     private val propertySymbolPointer: KtSymbolPointer<KtPropertySymbol>,
@@ -95,7 +93,7 @@ internal class SymbolLightFieldForProperty private constructor(
 
     override fun getName(): String = fieldName
 
-    private fun computeModifiers(modifier: String): ImmutableMap<String, Boolean>? = when (modifier) {
+    private fun computeModifiers(modifier: String): Map<String, Boolean>? = when (modifier) {
         in LazyModifiersBox.VISIBILITY_MODIFIERS -> LazyModifiersBox.computeVisibilityForMember(ktModule, propertySymbolPointer)
         in LazyModifiersBox.MODALITY_MODIFIERS -> {
             val modality = withPropertySymbol { propertySymbol ->
@@ -113,17 +111,17 @@ internal class SymbolLightFieldForProperty private constructor(
 
         PsiModifier.STATIC -> {
             val isStatic = forceStatic || isTopLevel
-            ImmutableHashMap.of(modifier, isStatic)
+            mapOf(modifier to isStatic)
         }
 
         PsiModifier.VOLATILE -> withPropertySymbol { propertySymbol ->
             val hasAnnotation = propertySymbol.hasAnnotation(VOLATILE_ANNOTATION_CLASS_ID, null)
-            ImmutableHashMap.of(modifier, hasAnnotation)
+            mapOf(modifier to hasAnnotation)
         }
 
         PsiModifier.TRANSIENT -> withPropertySymbol { propertySymbol ->
             val hasAnnotation = propertySymbol.hasAnnotation(TRANSIENT_ANNOTATION_CLASS_ID, null)
-            ImmutableHashMap.of(modifier, hasAnnotation)
+            mapOf(modifier to hasAnnotation)
         }
 
         else -> null
@@ -131,7 +129,7 @@ internal class SymbolLightFieldForProperty private constructor(
 
     private val _modifierList: PsiModifierList by lazyPub {
         val initializerValue = if (takePropertyVisibility) {
-            ImmutableHashMap.empty()
+            emptyMap()
         } else {
             LazyModifiersBox.VISIBILITY_MODIFIERS_MAP.with(PsiModifier.PRIVATE)
         }

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/SymbolLightAccessorMethod.kt

@@ -39,8 +39,6 @@ import org.jetbrains.kotlin.psi.KtCallableDeclaration
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.psi.KtParameter
 import org.jetbrains.kotlin.psi.KtPropertyAccessor
-import org.jetbrains.kotlin.util.javaslang.ImmutableHashMap
-import org.jetbrains.kotlin.util.javaslang.ImmutableMap
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 
 internal class SymbolLightAccessorMethod private constructor(
@@ -157,7 +155,7 @@ internal class SymbolLightAccessorMethod private constructor(
         annotationsFromProperty + annotationsFromAccessor
     }
 
-    private fun computeModifiers(modifier: String): ImmutableMap<String, Boolean>? {
+    private fun computeModifiers(modifier: String): Map<String, Boolean>? {
         return when (modifier) {
             in LazyModifiersBox.VISIBILITY_MODIFIERS -> LazyModifiersBox.computeVisibilityForMember(ktModule, propertyAccessorSymbolPointer)
 
@@ -176,7 +174,7 @@ internal class SymbolLightAccessorMethod private constructor(
                     isTopLevel || hasJvmStaticAnnotation()
                 }
 
-                ImmutableHashMap.of(modifier, isStatic)
+                mapOf(modifier to isStatic)
             }
 
             else -> null

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/SymbolLightConstructor.kt

@@ -16,8 +16,6 @@ import org.jetbrains.kotlin.light.classes.symbol.classes.SymbolLightClassForEnum
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.LazyModifiersBox
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.SymbolLightMemberModifierList
 import org.jetbrains.kotlin.light.classes.symbol.modifierLists.with
-import org.jetbrains.kotlin.util.javaslang.ImmutableHashMap
-import org.jetbrains.kotlin.util.javaslang.ImmutableMap
 import java.util.*
 
 internal class SymbolLightConstructor(
@@ -48,7 +46,7 @@ internal class SymbolLightConstructor(
         val initialValue = if (containingClass is SymbolLightClassForEnumEntry) {
             LazyModifiersBox.VISIBILITY_MODIFIERS_MAP.with(PsiModifier.PACKAGE_LOCAL)
         } else {
-            ImmutableHashMap.empty()
+            emptyMap()
         }
 
         SymbolLightMemberModifierList(
@@ -66,7 +64,7 @@ internal class SymbolLightConstructor(
         }
     }
 
-    private fun computeModifiers(modifier: String): ImmutableMap<String, Boolean>? {
+    private fun computeModifiers(modifier: String): Map<String, Boolean>? {
         if (modifier !in LazyModifiersBox.VISIBILITY_MODIFIERS) return null
         return LazyModifiersBox.computeVisibilityForMember(ktModule, functionSymbolPointer)
     }

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/methods/SymbolLightSimpleMethod.kt

@@ -25,8 +25,6 @@ import org.jetbrains.kotlin.light.classes.symbol.modifierLists.with
 import org.jetbrains.kotlin.light.classes.symbol.parameters.SymbolLightTypeParameterList
 import org.jetbrains.kotlin.name.JvmNames.STRICTFP_ANNOTATION_CLASS_ID
 import org.jetbrains.kotlin.name.JvmNames.SYNCHRONIZED_ANNOTATION_CLASS_ID
-import org.jetbrains.kotlin.util.javaslang.ImmutableHashMap
-import org.jetbrains.kotlin.util.javaslang.ImmutableMap
 import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
 import java.util.*
 
@@ -90,7 +88,7 @@ internal class SymbolLightSimpleMethod(
         )
     }
 
-    private fun computeModifiers(modifier: String): ImmutableMap<String, Boolean>? = when (modifier) {
+    private fun computeModifiers(modifier: String): Map<String, Boolean>? = when (modifier) {
         in LazyModifiersBox.MODALITY_MODIFIERS -> {
             ifInlineOnly { return modifiersForInlineOnlyCase() }
             val modality = if (isTopLevel) PsiModifier.FINAL else withFunctionSymbol { it.computeSimpleModality() }
@@ -110,25 +108,25 @@ internal class SymbolLightSimpleMethod(
                 isTopLevel || withFunctionSymbol { it.hasJvmStaticAnnotation() }
             }
 
-            ImmutableHashMap.of(modifier, isStatic)
+            mapOf(modifier to isStatic)
         }
 
         PsiModifier.NATIVE -> {
             ifInlineOnly { return null }
             val isExternal = functionDeclaration?.hasModifier(KtTokens.EXTERNAL_KEYWORD) ?: withFunctionSymbol { it.isExternal }
-            ImmutableHashMap.of(modifier, isExternal)
+            mapOf(modifier to isExternal)
         }
 
         PsiModifier.STRICTFP -> {
             ifInlineOnly { return null }
             val hasAnnotation = withFunctionSymbol { it.hasAnnotation(STRICTFP_ANNOTATION_CLASS_ID, null) }
-            ImmutableHashMap.of(modifier, hasAnnotation)
+            mapOf(modifier to hasAnnotation)
         }
 
         PsiModifier.SYNCHRONIZED -> {
             ifInlineOnly { return null }
             val hasAnnotation = withFunctionSymbol { it.hasAnnotation(SYNCHRONIZED_ANNOTATION_CLASS_ID, null) }
-            ImmutableHashMap.of(modifier, hasAnnotation)
+            mapOf(modifier to hasAnnotation)
         }
 
         else -> null
@@ -140,8 +138,8 @@ internal class SymbolLightSimpleMethod(
         }
     }
 
-    private fun modifiersForInlineOnlyCase(): ImmutableMap<String, Boolean> =
+    private fun modifiersForInlineOnlyCase(): Map<String, Boolean> =
-        LazyModifiersBox.MODALITY_MODIFIERS_MAP.merge(LazyModifiersBox.VISIBILITY_MODIFIERS_MAP)
+        LazyModifiersBox.MODALITY_MODIFIERS_MAP.putAll(LazyModifiersBox.VISIBILITY_MODIFIERS_MAP)
             .with(PsiModifier.FINAL)
             .with(PsiModifier.PRIVATE)
 

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/modifierLists/SymbolLightClassModifierList.kt

@@ -10,12 +10,11 @@ import com.intellij.psi.PsiModifierList
 import com.intellij.psi.PsiModifierListOwner
 import org.jetbrains.kotlin.asJava.elements.KtLightElement
 import org.jetbrains.kotlin.psi.KtModifierListOwner
-import org.jetbrains.kotlin.util.javaslang.ImmutableHashMap
 
 internal class SymbolLightClassModifierList<T : KtLightElement<KtModifierListOwner, PsiModifierListOwner>> : SymbolLightModifierList<T> {
     constructor(
         containingDeclaration: T,
-        initialValue: ImmutableHashMap<String, Boolean> = ImmutableHashMap.empty(),
+        initialValue: Map<String, Boolean> = emptyMap(),
         lazyModifiersComputer: LazyModifiersComputer,
         annotationsComputer: ((PsiModifierList) -> List<PsiAnnotation>)?,
     ) : super(containingDeclaration, initialValue, lazyModifiersComputer, annotationsComputer)

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/modifierLists/SymbolLightMemberModifierList.kt

@@ -14,12 +14,11 @@ import org.jetbrains.kotlin.light.classes.symbol.methods.SymbolLightMethodBase
 import org.jetbrains.kotlin.psi.KtModifierList
 import org.jetbrains.kotlin.psi.KtPropertyAccessor
 import org.jetbrains.kotlin.psi.psiUtil.hasBody
-import org.jetbrains.kotlin.util.javaslang.ImmutableHashMap
 
 internal class SymbolLightMemberModifierList<T : KtLightMember<*>> : SymbolLightModifierList<T> {
     constructor(
         containingDeclaration: T,
-        initialValue: ImmutableHashMap<String, Boolean> = ImmutableHashMap.empty(),
+        initialValue: Map<String, Boolean> = emptyMap(),
         lazyModifiersComputer: LazyModifiersComputer,
         annotationsComputer: ((PsiModifierList) -> List<PsiAnnotation>)?,
     ) : super(containingDeclaration, initialValue, lazyModifiersComputer, annotationsComputer)

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/modifierLists/SymbolLightModifierList.kt

@@ -7,6 +7,8 @@ package org.jetbrains.kotlin.light.classes.symbol.modifierLists
 
 import com.intellij.psi.*
 import com.intellij.util.IncorrectOperationException
+import kotlinx.collections.immutable.PersistentMap
+import kotlinx.collections.immutable.toPersistentHashMap
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithModality
 import org.jetbrains.kotlin.analysis.api.symbols.markers.KtSymbolWithVisibility
 import org.jetbrains.kotlin.analysis.api.symbols.pointers.KtSymbolPointer
@@ -19,9 +21,6 @@ import org.jetbrains.kotlin.asJava.elements.KtLightElementBase
 import org.jetbrains.kotlin.light.classes.symbol.*
 import org.jetbrains.kotlin.psi.KtModifierList
 import org.jetbrains.kotlin.psi.KtModifierListOwner
-import org.jetbrains.kotlin.util.javaslang.ImmutableHashMap
-import org.jetbrains.kotlin.util.javaslang.ImmutableMap
-import org.jetbrains.kotlin.util.javaslang.getOrNull
 import org.jetbrains.kotlin.utils.keysToMap
 import java.util.concurrent.atomic.AtomicReference
 
@@ -34,7 +33,7 @@ internal open class SymbolLightModifierList<out T : KtLightElement<KtModifierLis
 
     constructor(
         owner: T,
-        initialValue: ImmutableHashMap<String, Boolean>,
+        initialValue: Map<String, Boolean>,
         lazyModifiersComputer: LazyModifiersComputer,
         annotationsComputer: ((PsiModifierList) -> List<PsiAnnotation>)?,
     ) : super(owner) {
@@ -81,41 +80,47 @@ internal open class SymbolLightModifierList<out T : KtLightElement<KtModifierLis
         staticModifiers?.contains(name) == true || lazyModifiersBox?.hasModifier(name) == true
 }
 
-internal typealias LazyModifiersComputer = (modifier: String) -> ImmutableMap<String, Boolean>?
+internal typealias LazyModifiersComputer = (modifier: String) -> Map<String, Boolean>?
 
 @Suppress("NOTHING_TO_INLINE")
-internal inline fun ImmutableHashMap<String, Boolean>.with(modifier: String?): ImmutableHashMap<String, Boolean> {
+internal inline fun PersistentMap<String, Boolean>.with(modifier: String?): PersistentMap<String, Boolean> {
     return modifier?.let { put(modifier, true) } ?: this
 }
 
 internal class LazyModifiersBox(
-    initialValue: ImmutableHashMap<String, Boolean>,
+    initialValue: Map<String, Boolean>,
     private val computer: LazyModifiersComputer,
 ) {
-    private val modifiersMapReference: AtomicReference<ImmutableHashMap<String, Boolean>> = AtomicReference(initialValue)
+    private val modifiersMapReference: AtomicReference<PersistentMap<String, Boolean>> = AtomicReference(initialValue.toPersistentHashMap())
 
     fun hasModifier(modifier: String): Boolean {
-        modifiersMapReference.get().getOrNull(modifier)?.let { return it }
+        modifiersMapReference.get()[modifier]?.let { return it }
-        val newValues = computer(modifier) ?: ImmutableHashMap.of(modifier, false)
+        val newValues = computer(modifier) ?: mapOf(modifier to false)
         do {
             val currentMap = modifiersMapReference.get()
-            val newMap = currentMap.merge(newValues)
+            val newMap = currentMap.putAll(newValues)
         } while (!modifiersMapReference.compareAndSet(currentMap, newMap))
 
-        return newValues.getOrNull(modifier) ?: error("Inconsistent state: $modifier")
+        return newValues[modifier] ?: error("Inconsistent state: $modifier")
     }
 
     companion object {
         internal val VISIBILITY_MODIFIERS = setOf(PsiModifier.PUBLIC, PsiModifier.PACKAGE_LOCAL, PsiModifier.PROTECTED, PsiModifier.PRIVATE)
-        internal val VISIBILITY_MODIFIERS_MAP = ImmutableHashMap.ofAll(VISIBILITY_MODIFIERS.keysToMap { false })
+        internal val VISIBILITY_MODIFIERS_MAP: PersistentMap<String, Boolean> =
+            VISIBILITY_MODIFIERS.keysToMap {
+                false
+            }.toPersistentHashMap()
 
         internal val MODALITY_MODIFIERS = setOf(PsiModifier.FINAL, PsiModifier.ABSTRACT)
-        internal val MODALITY_MODIFIERS_MAP = ImmutableHashMap.ofAll(MODALITY_MODIFIERS.keysToMap { false })
+        internal val MODALITY_MODIFIERS_MAP: PersistentMap<String, Boolean> =
+            MODALITY_MODIFIERS.keysToMap {
+                false
+            }.toPersistentHashMap()
 
         internal fun computeVisibilityForMember(
             ktModule: KtModule,
             declarationPointer: KtSymbolPointer<KtSymbolWithVisibility>,
-        ): ImmutableMap<String, Boolean> {
+        ): PersistentMap<String, Boolean> {
             val visibility = analyzeForLightClasses(ktModule) {
                 declarationPointer.restoreSymbolOrThrowIfDisposed().toPsiVisibilityForMember()
             }
@@ -126,7 +131,7 @@ internal class LazyModifiersBox(
         internal fun computeSimpleModality(
             ktModule: KtModule,
             declarationPointer: KtSymbolPointer<KtSymbolWithModality>,
-        ): ImmutableMap<String, Boolean> {
+        ): PersistentMap<String, Boolean> {
             val visibility = analyzeForLightClasses(ktModule) {
                 declarationPointer.restoreSymbolOrThrowIfDisposed().computeSimpleModality()
             }