TargetPlatform#getDefaultImports(): cache result in all implementations

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmPlatform.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.resolve.jvm.platform
 
-import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.platform.JvmBuiltIns
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
@@ -25,25 +24,28 @@ import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import java.util.*
 
 object JvmPlatform : TargetPlatform("JVM") {
-    private val builtIns by lazy(LazyThreadSafetyMode.PUBLICATION) { JvmBuiltIns(LockBasedStorageManager()) }
+    private val defaultImports = LockBasedStorageManager().createMemoizedFunction<Boolean, List<ImportPath>> { includeKotlinComparisons ->
+        ArrayList<ImportPath>().apply {
+            addAll(Default.getDefaultImports(includeKotlinComparisons))
 
-    override fun getDefaultImports(languageVersionSettings: LanguageVersionSettings): List<ImportPath> = ArrayList<ImportPath>().apply {
+            add(ImportPath.fromString("java.lang.*"))
-        addAll(Default.getDefaultImports(languageVersionSettings))
+            add(ImportPath.fromString("kotlin.jvm.*"))
 
-        add(ImportPath.fromString("java.lang.*"))
+            fun addAllClassifiersFromScope(scope: MemberScope) {
-        add(ImportPath.fromString("kotlin.jvm.*"))
+                for (descriptor in scope.getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS, MemberScope.ALL_NAME_FILTER)) {
+                    add(ImportPath(DescriptorUtils.getFqNameSafe(descriptor), false))
+                }
+            }
 
-        fun addAllClassifiersFromScope(scope: MemberScope) {
+            for (builtinPackageFragment in JvmBuiltIns(LockBasedStorageManager.NO_LOCKS).builtInsPackageFragmentsImportedByDefault) {
-            for (descriptor in scope.getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS, MemberScope.ALL_NAME_FILTER)) {
+                addAllClassifiersFromScope(builtinPackageFragment.getMemberScope())
-                add(ImportPath(DescriptorUtils.getFqNameSafe(descriptor), false))
             }
         }
 
-        for (builtinPackageFragment in builtIns.builtInsPackageFragmentsImportedByDefault) {
-            addAllClassifiersFromScope(builtinPackageFragment.getMemberScope())
-        }
     }
 
+    override fun getDefaultImports(includeKotlinComparisons: Boolean): List<ImportPath> = defaultImports(includeKotlinComparisons)
+
     override val platformConfigurator: PlatformConfigurator = JvmPlatformConfigurator
 
     override val multiTargetPlatform = MultiTargetPlatform.Specific(platformName)

compiler/frontend/src/org/jetbrains/kotlin/resolve/TargetPlatform.kt

@@ -16,8 +16,6 @@
 
 package org.jetbrains.kotlin.resolve
 
-import org.jetbrains.kotlin.config.LanguageFeature
-import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.composeContainer
 import org.jetbrains.kotlin.container.useInstance
@@ -29,6 +27,7 @@ import org.jetbrains.kotlin.resolve.checkers.*
 import org.jetbrains.kotlin.resolve.lazy.DelegationFilter
 import org.jetbrains.kotlin.resolve.scopes.SyntheticConstructorsProvider
 import org.jetbrains.kotlin.resolve.scopes.SyntheticScopes
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
 import org.jetbrains.kotlin.types.DynamicTypesSettings
 import java.util.*
 
@@ -36,28 +35,33 @@ abstract class TargetPlatform(val platformName: String) {
     override fun toString() = platformName
 
     abstract val platformConfigurator: PlatformConfigurator
-    abstract fun getDefaultImports(languageVersionSettings: LanguageVersionSettings): List<ImportPath>
+    abstract fun getDefaultImports(includeKotlinComparisons: Boolean): List<ImportPath>
     open val excludedImports: List<FqName> get() = emptyList()
 
     abstract val multiTargetPlatform: MultiTargetPlatform
 
     object Default : TargetPlatform("Default") {
-        override fun getDefaultImports(languageVersionSettings: LanguageVersionSettings): List<ImportPath> = ArrayList<ImportPath>().apply {
+        private val defaultImports = LockBasedStorageManager().createMemoizedFunction<Boolean, List<ImportPath>> {
-            listOf(
+            includeKotlinComparisons ->
-                    "kotlin.*",
+            ArrayList<ImportPath>().apply {
-                    "kotlin.annotation.*",
+                listOf(
-                    "kotlin.collections.*",
+                        "kotlin.*",
-                    "kotlin.ranges.*",
+                        "kotlin.annotation.*",
-                    "kotlin.sequences.*",
+                        "kotlin.collections.*",
-                    "kotlin.text.*",
+                        "kotlin.ranges.*",
-                    "kotlin.io.*"
+                        "kotlin.sequences.*",
-            ).forEach { add(ImportPath.fromString(it)) }
+                        "kotlin.text.*",
+                        "kotlin.io.*"
+                ).forEach { add(ImportPath.fromString(it)) }
 
-            if (languageVersionSettings.supportsFeature(LanguageFeature.DefaultImportOfPackageKotlinComparisons)) {
+                if (includeKotlinComparisons) {
-                add(ImportPath.fromString("kotlin.comparisons.*"))
+                    add(ImportPath.fromString("kotlin.comparisons.*"))
+                }
             }
         }
 
+        override fun getDefaultImports(includeKotlinComparisons: Boolean): List<ImportPath> = defaultImports(includeKotlinComparisons)
+
         override val platformConfigurator =
                 object : PlatformConfigurator(
                         DynamicTypesSettings(), listOf(), listOf(), listOf(), listOf(), listOf(),

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/DefaultImportProvider.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.resolve.lazy
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
+import org.jetbrains.kotlin.config.LanguageFeature.DefaultImportOfPackageKotlinComparisons
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor
@@ -37,8 +38,9 @@ class DefaultImportProvider(
         private val targetPlatform: TargetPlatform,
         private val languageVersionSettings: LanguageVersionSettings
 ) {
-    val defaultImports: List<ImportPath>
+    val defaultImports: List<ImportPath> by storageManager.createLazyValue {
-            by storageManager.createLazyValue { targetPlatform.getDefaultImports(languageVersionSettings) }
+        targetPlatform.getDefaultImports(languageVersionSettings.supportsFeature(DefaultImportOfPackageKotlinComparisons))
+    }
 
     val excludedImports: List<FqName> by storageManager.createLazyValue {
         val packagesWithAliases = listOf(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME, KotlinBuiltIns.TEXT_PACKAGE_FQ_NAME)

j2k/src/org/jetbrains/kotlin/j2k/importConversion.kt

@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.asJava.classes.KtLightClass
 import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade
 import org.jetbrains.kotlin.asJava.elements.KtLightDeclaration
 import org.jetbrains.kotlin.asJava.elements.KtLightMethod
+import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.j2k.ast.Import
@@ -160,10 +161,9 @@ private fun convertNonStaticImport(fqName: FqName, isOnDemand: Boolean, target:
 private fun renderImportName(fqName: FqName, isOnDemand: Boolean)
         = if (isOnDemand) fqName.render() + ".*" else fqName.render()
 
-// TODO: use the correct LanguageVersionSettings instance here
+private val DEFAULT_IMPORTS_SET: Set<FqName> = JvmPlatform.getDefaultImports(
-private val DEFAULT_IMPORTS_SET: Set<FqName> = JvmPlatform.getDefaultImports(LanguageVersionSettingsImpl.DEFAULT)
+        // TODO: use the correct LanguageVersionSettings instance here
-        .filter { it.isAllUnder }
+        LanguageVersionSettingsImpl.DEFAULT.supportsFeature(LanguageFeature.DefaultImportOfPackageKotlinComparisons)
-        .map { it.fqName }
+).filter { it.isAllUnder }.map { it.fqName }.toSet()
-        .toSet()
 
 private fun isImportedByDefault(c: KtLightClass) = c.qualifiedName?.let { FqName(it).parent() } in DEFAULT_IMPORTS_SET

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/JsPlatform.kt

@@ -18,16 +18,19 @@ package org.jetbrains.kotlin.js.resolve
 
 import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.ImportPath
 import org.jetbrains.kotlin.resolve.MultiTargetPlatform
 import org.jetbrains.kotlin.resolve.PlatformConfigurator
 import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.storage.LockBasedStorageManager
 
 object JsPlatform : TargetPlatform("JS") {
-    override fun getDefaultImports(languageVersionSettings: LanguageVersionSettings): List<ImportPath> =
+    private val defaultImports = LockBasedStorageManager().createMemoizedFunction<Boolean, List<ImportPath>> { includeKotlinComparisons ->
-            Default.getDefaultImports(languageVersionSettings) + ImportPath.fromString("kotlin.js.*")
+            Default.getDefaultImports(includeKotlinComparisons) + ImportPath.fromString("kotlin.js.*")
+    }
+
+    override fun getDefaultImports(includeKotlinComparisons: Boolean): List<ImportPath> = defaultImports(includeKotlinComparisons)
 
     override val platformConfigurator: PlatformConfigurator = JsPlatformConfigurator