Delete DefaultImportProvider, refactor TargetPlatform.defaultImports

Previously, packages `java.lang` and `kotlin.jvm` were imported on JVM
by default on the same rights, causing problems when the same classifier
existed both in `java.lang` and `kotlin.jvm`. Since the only known case
of such conflict were type aliases to JVM classes, the corresponding
classes (expansions of those type aliases) were manually excluded from
default imports. This made the code in DefaultImportProvider complicated
and resulted in multiple problems, regarding both correctness and
performance (see 82364ad3e5, a9f2f5c7d0, dd3dbda719).

This change adds a new concept, a "low priority import", and treats
`java.lang` as such. Since these imports are now separated from the rest
of default imports in LazyImportScope via secondaryClassImportResolver,
conflicts between classifiers are handled naturally: the one from
`kotlin.jvm` always wins (unless the one from `java.lang` is imported
explicitly, of course). This approach is simpler, safer and does not
require any memory to cache anything.

Skip ResolveToJava.kt test for javac-based resolve; it now fails because
of a weird issue which I didn't have time to investigate (this is OK
because it's a corner case of an experimental functionality)

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

@@ -20,33 +20,24 @@ import org.jetbrains.kotlin.platform.JvmBuiltIns
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
-import org.jetbrains.kotlin.storage.LockBasedStorageManager
-import java.util.*
+import org.jetbrains.kotlin.storage.StorageManager
 
 object JvmPlatform : TargetPlatform("JVM") {
-    private val defaultImports = LockBasedStorageManager().let { storageManager ->
-        storageManager.createMemoizedFunction<Boolean, List<ImportPath>> { includeKotlinComparisons ->
-            ArrayList<ImportPath>().apply {
-                addAll(Common.getDefaultImports(includeKotlinComparisons))
+    override fun computePlatformSpecificDefaultImports(storageManager: StorageManager, result: MutableList<ImportPath>) {
+        result.add(ImportPath.fromString("kotlin.jvm.*"))
 
-                add(ImportPath.fromString("java.lang.*"))
-                add(ImportPath.fromString("kotlin.jvm.*"))
-
-                fun addAllClassifiersFromScope(scope: MemberScope) {
-                    for (descriptor in scope.getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS, MemberScope.ALL_NAME_FILTER)) {
-                        add(ImportPath(DescriptorUtils.getFqNameSafe(descriptor), false))
-                    }
-                }
-
-                for (builtinPackageFragment in JvmBuiltIns(storageManager).builtInsPackageFragmentsImportedByDefault) {
-                    addAllClassifiersFromScope(builtinPackageFragment.getMemberScope())
-                }
+        fun addAllClassifiersFromScope(scope: MemberScope) {
+            for (descriptor in scope.getContributedDescriptors(DescriptorKindFilter.CLASSIFIERS, MemberScope.ALL_NAME_FILTER)) {
+                result.add(ImportPath(DescriptorUtils.getFqNameSafe(descriptor), false))
             }
         }
 
+        for (builtinPackageFragment in JvmBuiltIns(storageManager).builtInsPackageFragmentsImportedByDefault) {
+            addAllClassifiersFromScope(builtinPackageFragment.getMemberScope())
+        }
     }
 
-    override fun getDefaultImports(includeKotlinComparisons: Boolean): List<ImportPath> = defaultImports(includeKotlinComparisons)
+    override val defaultLowPriorityImports: List<ImportPath> = listOf(ImportPath.fromString("java.lang.*"))
 
     override val platformConfigurator: PlatformConfigurator = JvmPlatformConfigurator
 

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

@@ -5,14 +5,11 @@
 
 package org.jetbrains.kotlin.resolve
 
-import com.intellij.openapi.util.Key
 import org.jetbrains.kotlin.container.StorageComponentContainer
 import org.jetbrains.kotlin.container.composeContainer
 import org.jetbrains.kotlin.container.useInstance
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
-import org.jetbrains.kotlin.psi.KtFile
-import org.jetbrains.kotlin.psi.UserDataProperty
 import org.jetbrains.kotlin.resolve.calls.checkers.*
 import org.jetbrains.kotlin.resolve.calls.components.SamConversionTransformer
 import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator
@@ -20,39 +17,56 @@ import org.jetbrains.kotlin.resolve.checkers.*
 import org.jetbrains.kotlin.resolve.lazy.DelegationFilter
 import org.jetbrains.kotlin.resolve.scopes.SyntheticScopes
 import org.jetbrains.kotlin.storage.LockBasedStorageManager
+import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.DynamicTypesSettings
 import java.util.*
 
 abstract class TargetPlatform(val platformName: String) {
+    private data class DefaultImportsKey(val includeKotlinComparisons: Boolean, val includeLowPriorityImports: Boolean)
+
+    private val defaultImports = LockBasedStorageManager().let { storageManager ->
+        storageManager.createMemoizedFunction<DefaultImportsKey, List<ImportPath>> { (includeKotlinComparisons, includeLowPriorityImports) ->
+            ArrayList<ImportPath>().apply {
+                listOf(
+                    "kotlin.*",
+                    "kotlin.annotation.*",
+                    "kotlin.collections.*",
+                    "kotlin.ranges.*",
+                    "kotlin.sequences.*",
+                    "kotlin.text.*",
+                    "kotlin.io.*"
+                ).forEach { add(ImportPath.fromString(it)) }
+
+                if (includeKotlinComparisons) {
+                    add(ImportPath.fromString("kotlin.comparisons.*"))
+                }
+
+                computePlatformSpecificDefaultImports(storageManager, this)
+
+                if (includeLowPriorityImports) {
+                    addAll(defaultLowPriorityImports)
+                }
+            }
+        }
+    }
+
     override fun toString() = platformName
 
     abstract val platformConfigurator: PlatformConfigurator
-    abstract fun getDefaultImports(includeKotlinComparisons: Boolean): List<ImportPath>
+
+    open val defaultLowPriorityImports: List<ImportPath> get() = emptyList()
+
+    fun getDefaultImports(includeKotlinComparisons: Boolean, includeLowPriorityImports: Boolean): List<ImportPath> =
+        defaultImports(DefaultImportsKey(includeKotlinComparisons, includeLowPriorityImports))
+
+    protected abstract fun computePlatformSpecificDefaultImports(storageManager: StorageManager, result: MutableList<ImportPath>)
+
     open val excludedImports: List<FqName> get() = emptyList()
 
     abstract val multiTargetPlatform: MultiTargetPlatform
 
     object Common : TargetPlatform("Default") {
-        private val defaultImports =
-            LockBasedStorageManager().createMemoizedFunction<Boolean, List<ImportPath>> { includeKotlinComparisons ->
-                ArrayList<ImportPath>().apply {
-                    listOf(
-                        "kotlin.*",
-                        "kotlin.annotation.*",
-                        "kotlin.collections.*",
-                        "kotlin.ranges.*",
-                        "kotlin.sequences.*",
-                        "kotlin.text.*",
-                        "kotlin.io.*"
-                    ).forEach { add(ImportPath.fromString(it)) }
-
-                    if (includeKotlinComparisons) {
-                        add(ImportPath.fromString("kotlin.comparisons.*"))
-                    }
-                }
-            }
-
-        override fun getDefaultImports(includeKotlinComparisons: Boolean): List<ImportPath> = defaultImports(includeKotlinComparisons)
+        override fun computePlatformSpecificDefaultImports(storageManager: StorageManager, result: MutableList<ImportPath>) {}
 
         override val platformConfigurator =
             object : PlatformConfigurator(

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

@@ -1,88 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-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
-import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.name.isChildOf
-import org.jetbrains.kotlin.name.isSubpackageOf
-import org.jetbrains.kotlin.resolve.ImportPath
-import org.jetbrains.kotlin.resolve.SinceKotlinAccessibility
-import org.jetbrains.kotlin.resolve.TargetPlatform
-import org.jetbrains.kotlin.resolve.checkSinceKotlinVersionAccessibility
-import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.storage.StorageManager
-import org.jetbrains.kotlin.storage.getValue
-
-class DefaultImportProvider(
-    storageManager: StorageManager,
-    moduleDescriptor: ModuleDescriptor,
-    private val targetPlatform: TargetPlatform,
-    private val languageVersionSettings: LanguageVersionSettings
-) {
-    companion object {
-        private val PACKAGES_WITH_ALIASES = listOf(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME, KotlinBuiltIns.TEXT_PACKAGE_FQ_NAME)
-
-        private fun ModuleDescriptor.findTypeAliasesInPackages(packages: Collection<FqName>): Collection<TypeAliasDescriptor> {
-            val result = mutableListOf<TypeAliasDescriptor>()
-
-            for (dependencyModuleDescriptor in allDependencyModules) {
-                if (dependencyModuleDescriptor !is ModuleDescriptorImpl) continue
-
-                for (packageFqName in packages) {
-                    dependencyModuleDescriptor.packageFragmentProviderForContent.getPackageFragments(packageFqName)
-                        .flatMapTo(result) { packageFragmentDescriptor ->
-                            packageFragmentDescriptor.getMemberScope()
-                                .getContributedDescriptors(DescriptorKindFilter.TYPE_ALIASES)
-                                .filterIsInstance<TypeAliasDescriptor>()
-                        }
-                }
-            }
-
-            return result
-        }
-    }
-
-    val defaultImports: List<ImportPath> by storageManager.createLazyValue {
-        targetPlatform.getDefaultImports(languageVersionSettings.supportsFeature(DefaultImportOfPackageKotlinComparisons))
-    }
-
-    val excludedImports: List<FqName> by storageManager.createLazyValue {
-        val builtinTypeAliases =
-            moduleDescriptor.findTypeAliasesInPackages(PACKAGES_WITH_ALIASES)
-                .filter { it.checkSinceKotlinVersionAccessibility(languageVersionSettings) == SinceKotlinAccessibility.Accessible }
-
-        val nonKotlinDefaultImportedPackages =
-            defaultImports
-                .filter { it.isAllUnder }
-                .mapNotNull {
-                    it.fqName.takeUnless { it.isSubpackageOf(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) }
-                }
-        val nonKotlinAliasedTypeFqNames =
-            builtinTypeAliases
-                .mapNotNull { it.expandedType.constructor.declarationDescriptor?.fqNameSafe }
-                .filter { nonKotlinDefaultImportedPackages.any(it::isChildOf) }
-
-        nonKotlinAliasedTypeFqNames + targetPlatform.excludedImports
-    }
-}

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.resolve.lazy
 
+import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
@@ -44,13 +45,22 @@ class FileScopeFactory(
     private val bindingTrace: BindingTrace,
     private val ktImportsFactory: KtImportsFactory,
     private val platformToKotlinClassMap: PlatformToKotlinClassMap,
-    private val defaultImportProvider: DefaultImportProvider,
+    private val targetPlatform: TargetPlatform,
     private val languageVersionSettings: LanguageVersionSettings,
     private val deprecationResolver: DeprecationResolver
 ) {
     /* avoid constructing psi for default imports prematurely (time consuming in some scenarios) */
     private val defaultImports by storageManager.createLazyValue {
-        ktImportsFactory.createImportDirectivesNotCached(defaultImportProvider.defaultImports)
+        ktImportsFactory.createImportDirectivesNotCached(
+            targetPlatform.getDefaultImports(
+                languageVersionSettings.supportsFeature(LanguageFeature.DefaultImportOfPackageKotlinComparisons),
+                includeLowPriorityImports = false
+            )
+        )
+    }
+
+    private val defaultLowPriorityImports by storageManager.createLazyValue {
+        ktImportsFactory.createImportDirectivesNotCached(targetPlatform.defaultLowPriorityImports)
     }
 
     fun createScopesForFile(file: KtFile, existingImports: ImportingScope? = null): FileScopes {
@@ -60,10 +70,16 @@ class FileScopeFactory(
         return FilesScopesBuilder(file, existingImports, packageFragment, packageView).result
     }
 
+    private data class DefaultImportResolvers(
+        val explicit: LazyImportResolver,
+        val allUnder: LazyImportResolver,
+        val lowPriority: LazyImportResolver
+    )
+
     private fun createDefaultImportResolvers(
         extraImports: Collection<KtImportDirective>,
         aliasImportNames: Collection<FqName>
-    ): Pair<LazyImportResolver, LazyImportResolver> {
+    ): DefaultImportResolvers {
         val tempTrace = TemporaryBindingTrace.create(bindingTrace, "Transient trace for default imports lazy resolve", false)
         val allImplicitImports = defaultImports concat extraImports
 
@@ -73,22 +89,29 @@ class FileScopeFactory(
             allImplicitImports.filter { it.isAllUnder || it.importedFqName !in aliasImportNames }
         }
 
-        val defaultExplicitImportResolver = createImportResolver(
+        val explicit = createImportResolver(
             ExplicitImportsIndexed(defaultImportsFiltered),
             tempTrace,
             packageFragment = null,
             aliasImportNames = aliasImportNames
         )
-        val defaultAllUnderImportResolver =
-            createImportResolver(
-                AllUnderImportsIndexed(defaultImportsFiltered),
-                tempTrace,
-                packageFragment = null,
-                aliasImportNames = aliasImportNames,
-                excludedImports = defaultImportProvider.excludedImports
-            )
+        val allUnder = createImportResolver(
+            AllUnderImportsIndexed(defaultImportsFiltered),
+            tempTrace,
+            packageFragment = null,
+            aliasImportNames = aliasImportNames,
+            excludedImports = targetPlatform.excludedImports
+        )
+        val lowPriority = createImportResolver(
+            AllUnderImportsIndexed(defaultLowPriorityImports.also { imports ->
+                assert(imports.all { it.isAllUnder }) { "All low priority imports must be all-under: $imports" }
+            }),
+            tempTrace,
+            packageFragment = null,
+            aliasImportNames = aliasImportNames
+        )
 
-        return defaultExplicitImportResolver to defaultAllUnderImportResolver
+        return DefaultImportResolvers(explicit, allUnder, lowPriority)
     }
 
     private val defaultImportResolvers by storageManager.createLazyValue {
@@ -152,7 +175,7 @@ class FileScopeFactory(
 
         val result = FileScopes(lexicalScope, lazyImportingScope, importResolver)
 
-        private fun createDefaultImportResolversForFile(): Pair<LazyImportResolver, LazyImportResolver> {
+        private fun createDefaultImportResolversForFile(): DefaultImportResolvers {
             val extraImports = file.takeIf { it.isScript() }?.originalFile?.virtualFile?.let { vFile ->
                 val scriptExternalDependencies = getScriptExternalDependencies(vFile, file.project)
                 ktImportsFactory.createImportDirectives(scriptExternalDependencies?.imports?.map { ImportPath.fromString(it) }.orEmpty())
@@ -166,37 +189,40 @@ class FileScopeFactory(
         }
 
         fun createImportingScope(): LazyImportScope {
-            val (defaultExplicitImportResolver, defaultAllUnderImportResolver) = createDefaultImportResolversForFile()
+            val (defaultExplicitImportResolver, defaultAllUnderImportResolver, defaultLowPriorityImportResolver) =
+                    createDefaultImportResolversForFile()
 
             val dummyContainerDescriptor = DummyContainerDescriptor(file, packageFragment)
 
             var scope: ImportingScope
 
             val debugName = "LazyFileScope for file " + file.name
+
             scope = LazyImportScope(
-                existingImports, defaultAllUnderImportResolver, LazyImportScope.FilteringKind.INVISIBLE_CLASSES,
+                existingImports, defaultAllUnderImportResolver, defaultLowPriorityImportResolver,
+                LazyImportScope.FilteringKind.INVISIBLE_CLASSES,
                 "Default all under imports in $debugName (invisible classes only)"
             )
 
             scope = LazyImportScope(
-                scope, allUnderImportResolver, LazyImportScope.FilteringKind.INVISIBLE_CLASSES,
+                scope, allUnderImportResolver, null, LazyImportScope.FilteringKind.INVISIBLE_CLASSES,
                 "All under imports in $debugName (invisible classes only)"
             )
 
             scope = currentPackageScope(packageView, aliasImportNames, dummyContainerDescriptor, FilteringKind.INVISIBLE_CLASSES, scope)
 
             scope = LazyImportScope(
-                scope, defaultAllUnderImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES,
+                scope, defaultAllUnderImportResolver, defaultLowPriorityImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES,
                 "Default all under imports in $debugName (visible classes)"
             )
 
             scope = LazyImportScope(
-                scope, allUnderImportResolver, LazyImportScope.FilteringKind.VISIBLE_CLASSES,
+                scope, allUnderImportResolver, null, LazyImportScope.FilteringKind.VISIBLE_CLASSES,
                 "All under imports in $debugName (visible classes)"
             )
 
             scope = LazyImportScope(
-                scope, defaultExplicitImportResolver, LazyImportScope.FilteringKind.ALL,
+                scope, defaultExplicitImportResolver, null, LazyImportScope.FilteringKind.ALL,
                 "Default explicit imports in $debugName"
             )
 
@@ -204,7 +230,7 @@ class FileScopeFactory(
 
             scope = currentPackageScope(packageView, aliasImportNames, dummyContainerDescriptor, FilteringKind.VISIBLE_CLASSES, scope)
 
-            return LazyImportScope(scope, explicitImportResolver, LazyImportScope.FilteringKind.ALL, "Explicit imports in $debugName")
+            return LazyImportScope(scope, explicitImportResolver, null, LazyImportScope.FilteringKind.ALL, "Explicit imports in $debugName")
         }
 
     }
@@ -228,7 +254,7 @@ class FileScopeFactory(
         return object : ImportingScope {
             override val parent: ImportingScope? = parentScope
 
-            override fun getContributedPackage(name: Name) = null
+            override fun getContributedPackage(name: Name): Nothing? = null
 
             override fun getContributedClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? {
                 if (name in excludedNames) return null

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

@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.util.collectionUtils.concat
 import org.jetbrains.kotlin.utils.Printer
 import org.jetbrains.kotlin.utils.addToStdlib.flatMapToNullable
-import java.util.*
+import org.jetbrains.kotlin.utils.ifEmpty
 
 interface IndexedImports {
     val imports: List<KtImportDirective>
@@ -208,6 +208,7 @@ class LazyImportResolver(
 class LazyImportScope(
     override val parent: ImportingScope?,
     private val importResolver: LazyImportResolver,
+    private val secondaryClassImportResolver: LazyImportResolver?,
     private val filteringKind: LazyImportScope.FilteringKind,
     private val debugName: String
 ) : ImportingScope {
@@ -218,19 +219,23 @@ class LazyImportScope(
         INVISIBLE_CLASSES
     }
 
-    private fun isClassifierVisible(descriptor: ClassifierDescriptor): Boolean {
+    private fun LazyImportResolver.isClassifierVisible(descriptor: ClassifierDescriptor): Boolean {
         if (filteringKind == FilteringKind.ALL) return true
 
-        if (importResolver.deprecationResolver.isHiddenInResolution(descriptor)) return false
+        if (deprecationResolver.isHiddenInResolution(descriptor)) return false
 
         val visibility = (descriptor as DeclarationDescriptorWithVisibility).visibility
         val includeVisible = filteringKind == FilteringKind.VISIBLE_CLASSES
         if (!visibility.mustCheckInImports()) return includeVisible
-        return Visibilities.isVisibleIgnoringReceiver(descriptor, importResolver.moduleDescriptor) == includeVisible
+        return Visibilities.isVisibleIgnoringReceiver(descriptor, moduleDescriptor) == includeVisible
     }
 
     override fun getContributedClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? {
-        return importResolver.selectSingleFromImports(name) { scope, name ->
+        return importResolver.getClassifier(name, location) ?: secondaryClassImportResolver?.getClassifier(name, location)
+    }
+
+    private fun LazyImportResolver.getClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? {
+        return selectSingleFromImports(name) { scope, _ ->
             val descriptor = scope.getContributedClassifier(name, location)
             if ((descriptor is ClassDescriptor || descriptor is TypeAliasDescriptor) && isClassifierVisible(descriptor))
                 descriptor
@@ -239,16 +244,20 @@ class LazyImportScope(
         }
     }
 
-    override fun getContributedPackage(name: Name) = null
+    override fun getContributedPackage(name: Name): PackageViewDescriptor? = null
 
     override fun getContributedVariables(name: Name, location: LookupLocation): Collection<VariableDescriptor> {
         if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return listOf()
-        return importResolver.collectFromImports(name) { scope, name -> scope.getContributedVariables(name, location) }
+        return importResolver.collectFromImports(name) { scope, _ -> scope.getContributedVariables(name, location) }.ifEmpty {
+            secondaryClassImportResolver?.collectFromImports(name) { scope, _ -> scope.getContributedVariables(name, location) }.orEmpty()
+        }
     }
 
     override fun getContributedFunctions(name: Name, location: LookupLocation): Collection<FunctionDescriptor> {
         if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return listOf()
-        return importResolver.collectFromImports(name) { scope, name -> scope.getContributedFunctions(name, location) }
+        return importResolver.collectFromImports(name) { scope, _ -> scope.getContributedFunctions(name, location) }.ifEmpty {
+            secondaryClassImportResolver?.collectFromImports(name) { scope, _ -> scope.getContributedFunctions(name, location) }.orEmpty()
+        }
     }
 
     override fun getContributedDescriptors(
@@ -259,26 +268,49 @@ class LazyImportScope(
         // we do not perform any filtering by visibility here because all descriptors from both visible/invisible filter scopes are to be added anyway
         if (filteringKind == FilteringKind.INVISIBLE_CLASSES) return listOf()
 
-        return importResolver.storageManager.compute {
-            val descriptors = LinkedHashSet<DeclarationDescriptor>()
+        val storageManager = importResolver.storageManager
+        if (secondaryClassImportResolver != null) {
+            assert(storageManager === secondaryClassImportResolver.storageManager) { "Multiple storage managers are not supported" }
+        }
+
+        return storageManager.compute {
+            val result = linkedSetOf<DeclarationDescriptor>()
+            val importedNames = if (secondaryClassImportResolver == null) null else hashSetOf<Name>()
+
             for (directive in importResolver.indexedImports.imports) {
                 val importPath = directive.importPath ?: continue
                 val importedName = importPath.importedName
                 if (importedName == null || nameFilter(importedName)) {
-                    descriptors.addAll(
-                        importResolver.getImportScope(directive).getContributedDescriptors(
-                            kindFilter,
-                            nameFilter,
-                            changeNamesForAliased
-                        )
-                    )
+                    val newDescriptors =
+                        importResolver.getImportScope(directive).getContributedDescriptors(kindFilter, nameFilter, changeNamesForAliased)
+                    result.addAll(newDescriptors)
+
+                    if (importedNames != null) {
+                        for (descriptor in newDescriptors) {
+                            importedNames.add(descriptor.name)
+                        }
+                    }
                 }
             }
-            descriptors
+
+            secondaryClassImportResolver?.let { resolver ->
+                for (directive in resolver.indexedImports.imports) {
+                    val newDescriptors =
+                        resolver.getImportScope(directive).getContributedDescriptors(kindFilter, nameFilter, changeNamesForAliased)
+
+                    for (descriptor in newDescriptors) {
+                        if (descriptor.name !in importedNames!!) {
+                            result.add(descriptor)
+                        }
+                    }
+                }
+            }
+
+            result
         }
     }
 
-    override fun toString() = "LazyImportScope: " + debugName
+    override fun toString() = "LazyImportScope: $debugName"
 
     override fun printStructure(p: Printer) {
         p.println(this::class.java.simpleName, ": ", debugName, " {")
@@ -288,11 +320,12 @@ class LazyImportScope(
         p.println("}")
     }
 
-    override fun definitelyDoesNotContainName(name: Name) = importResolver.definitelyDoesNotContainName(name)
+    override fun definitelyDoesNotContainName(name: Name): Boolean =
+        importResolver.definitelyDoesNotContainName(name) && secondaryClassImportResolver?.definitelyDoesNotContainName(name) != false
 
     override fun recordLookup(name: Name, location: LookupLocation) {
         importResolver.recordLookup(name, location)
     }
 
-    override fun computeImportedNames() = importResolver.allNames
+    override fun computeImportedNames(): Set<Name>? = importResolver.allNames?.union(secondaryClassImportResolver?.allNames.orEmpty())
 }

compiler/testData/diagnostics/tests/ResolveToJava.kt

@@ -1,5 +1,6 @@
 // !WITH_NEW_INFERENCE
 // !CHECK_TYPE
+// JAVAC_SKIP
 
 // FILE: f.kt
 

core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ModuleDescriptorImpl.kt

@@ -135,14 +135,6 @@ class ModuleDescriptorImpl @JvmOverloads constructor(
             return packageFragmentProviderForWholeModuleWithDependencies
         }
 
-    val packageFragmentProviderForContent: PackageFragmentProvider
-        get() {
-            assertValid()
-            return packageFragmentProviderForModuleContent.sure {
-                "Module $id was not initialized by the time packageFragmentProviderForContent was requested"
-            }
-        }
-
     @Suppress("UNCHECKED_CAST")
     override fun <T> getCapability(capability: ModuleDescriptor.Capability<T>) = capabilities[capability] as? T
 }

idea/ide-common/src/org/jetbrains/kotlin/idea/util/ImportInsertHelper.kt

@@ -27,6 +27,8 @@ abstract class ImportInsertHelper {
     /*TODO: implementation is not quite correct*/
     abstract fun isImportedWithDefault(importPath: ImportPath, contextFile: KtFile): Boolean
 
+    abstract fun isImportedWithLowPriorityDefaultImport(importPath: ImportPath, contextFile: KtFile): Boolean
+
     abstract fun mayImportOnShortenReferences(descriptor: DeclarationDescriptor): Boolean
 
     abstract val importSortComparator: Comparator<ImportPath>

idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/PsiBasedClassResolver.kt

@@ -260,7 +260,9 @@ class PsiBasedClassResolver @TestOnly constructor(private val targetClassFqName:
 private fun KtFile.getDefaultImports(): List<ImportPath> {
     val moduleInfo = getNullableModuleInfo() ?: return emptyList()
     val versionSettings = IDELanguageSettingsProvider.getLanguageVersionSettings(moduleInfo, project)
-    return TargetPlatformDetector.getPlatform(this).getDefaultImports(
-            versionSettings.supportsFeature(LanguageFeature.DefaultImportOfPackageKotlinComparisons)
+    val platform = TargetPlatformDetector.getPlatform(this)
+    return platform.getDefaultImports(
+        versionSettings.supportsFeature(LanguageFeature.DefaultImportOfPackageKotlinComparisons),
+        includeLowPriorityImports = true
     )
 }

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/Weighers.kt

@@ -84,6 +84,7 @@ class ImportedWeigher(private val classifier: ImportableFqNameClassifier) : Look
         currentPackage,
         preciseImport,
         defaultImport,
+        lowPriorityDefaultImport,
         allUnderImport
     }
 
@@ -93,6 +94,7 @@ class ImportedWeigher(private val classifier: ImportableFqNameClassifier) : Look
         return when (classifier.classify(fqName, o is PackageLookupObject)) {
             ImportableFqNameClassifier.Classification.fromCurrentPackage -> Weight.currentPackage
             ImportableFqNameClassifier.Classification.defaultImport -> Weight.defaultImport
+            ImportableFqNameClassifier.Classification.lowPriorityDefaultImport -> Weight.lowPriorityDefaultImport
             ImportableFqNameClassifier.Classification.preciseImport -> Weight.preciseImport
             ImportableFqNameClassifier.Classification.allUnderImport -> Weight.allUnderImport
             else -> null

idea/idea-core/src/org/jetbrains/kotlin/idea/core/ImportableFqNameClassifier.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.idea.core
 
-import org.jetbrains.kotlin.builtins.DefaultBuiltIns
 import org.jetbrains.kotlin.idea.util.ImportInsertHelper
 import org.jetbrains.kotlin.load.java.components.JavaAnnotationMapper
 import org.jetbrains.kotlin.name.FqName
@@ -52,6 +51,7 @@ class ImportableFqNameClassifier(private val file: KtFile) {
         topLevelPackage,
         preciseImport,
         defaultImport,
+        lowPriorityDefaultImport,
         allUnderImport,
         siblingImported,
         notImported,
@@ -69,15 +69,19 @@ class ImportableFqNameClassifier(private val file: KtFile) {
             }
         }
 
+        val importInsertHelper = ImportInsertHelper.getInstance(file.project)
+
         return when {
             isJavaClassNotToBeUsedInKotlin(fqName) -> Classification.notToBeUsedInKotlin
 
             fqName.parent() == file.packageFqName -> Classification.fromCurrentPackage
 
-            ImportInsertHelper.getInstance(file.project).isImportedWithDefault(importPath, file) -> Classification.defaultImport
-
             isImportedWithPreciseImport(fqName) -> Classification.preciseImport
 
+            importInsertHelper.isImportedWithLowPriorityDefaultImport(importPath, file) -> Classification.lowPriorityDefaultImport
+
+            importInsertHelper.isImportedWithDefault(importPath, file) -> Classification.defaultImport
+
             isImportedWithAllUnderImport(fqName) -> Classification.allUnderImport
 
             hasPreciseImportFromPackage(fqName.parent()) -> Classification.siblingImported

idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.idea.quickfix.replaceWith
 
+import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.analysis.analyzeInContext
@@ -34,7 +35,6 @@ import org.jetbrains.kotlin.psi.KtUserType
 import org.jetbrains.kotlin.psi.psiUtil.forEachDescendantOfType
 import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
-import org.jetbrains.kotlin.resolve.lazy.DefaultImportProvider
 import org.jetbrains.kotlin.resolve.lazy.descriptors.ClassResolutionScopesSupport
 import org.jetbrains.kotlin.resolve.scopes.*
 import org.jetbrains.kotlin.resolve.scopes.utils.chainImportingScopes
@@ -74,9 +74,9 @@ object ReplaceWithAnnotationAnalyzer {
 
         val module = resolutionFacade.moduleDescriptor
         val explicitImportsScope = buildExplicitImportsScope(annotation, resolutionFacade, module)
-        val defaultImportsScopes = buildDefaultImportsScopes(resolutionFacade, module)
+        val languageVersionSettings = resolutionFacade.frontendService<LanguageVersionSettings>()
+        val defaultImportsScopes = buildDefaultImportsScopes(resolutionFacade, module, languageVersionSettings)
 
-        val languageVersionSettings = resolutionFacade.getFrontendService(LanguageVersionSettings::class.java)
         val scope = getResolutionScope(
             symbolDescriptor, symbolDescriptor,
             listOf(explicitImportsScope), defaultImportsScopes, languageVersionSettings
@@ -106,12 +106,10 @@ object ReplaceWithAnnotationAnalyzer {
         val module = resolutionFacade.moduleDescriptor
 
         val explicitImportsScope = buildExplicitImportsScope(annotation, resolutionFacade, module)
-        val defaultImportScopes = buildDefaultImportsScopes(resolutionFacade, module)
+        val languageVersionSettings = resolutionFacade.frontendService<LanguageVersionSettings>()
+        val defaultImportScopes = buildDefaultImportsScopes(resolutionFacade, module, languageVersionSettings)
         val scope = getResolutionScope(
-            symbolDescriptor,
-            symbolDescriptor,
-            listOf(explicitImportsScope), defaultImportScopes,
-            resolutionFacade.getFrontendService(LanguageVersionSettings::class.java)
+            symbolDescriptor, symbolDescriptor, listOf(explicitImportsScope), defaultImportScopes, languageVersionSettings
         ) ?: return null
 
         val typeResolver = resolutionFacade.getFrontendService(TypeResolver::class.java)
@@ -138,8 +136,16 @@ object ReplaceWithAnnotationAnalyzer {
         return typeReference.typeElement as KtUserType
     }
 
-    private fun buildDefaultImportsScopes(resolutionFacade: ResolutionFacade, module: ModuleDescriptor): List<ImportingScope> {
-        val (allUnderImports, aliasImports) = resolutionFacade.frontendService<DefaultImportProvider>().defaultImports.partition { it.isAllUnder }
+    private fun buildDefaultImportsScopes(
+        resolutionFacade: ResolutionFacade,
+        module: ModuleDescriptor,
+        languageVersionSettings: LanguageVersionSettings
+    ): List<ImportingScope> {
+        val allDefaultImports = resolutionFacade.frontendService<TargetPlatform>().getDefaultImports(
+            languageVersionSettings.supportsFeature(LanguageFeature.DefaultImportOfPackageKotlinComparisons),
+            includeLowPriorityImports = true
+        )
+        val (allUnderImports, aliasImports) = allDefaultImports.partition { it.isAllUnder }
         // this solution doesn't support aliased default imports with a different alias
         // TODO: Create import directives from ImportPath, create ImportResolver, create LazyResolverScope, see FileScopeProviderImpl
 

idea/src/org/jetbrains/kotlin/idea/util/ImportInsertHelperImpl.kt

@@ -18,6 +18,8 @@ package org.jetbrains.kotlin.util
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.core.formatter.KotlinCodeStyleSettings
@@ -25,6 +27,7 @@ import org.jetbrains.kotlin.idea.core.targetDescriptors
 import org.jetbrains.kotlin.idea.imports.ImportPathComparator
 import org.jetbrains.kotlin.idea.imports.getImportableTargets
 import org.jetbrains.kotlin.idea.imports.importableFqName
+import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
 import org.jetbrains.kotlin.idea.refactoring.fqName.isImported
 import org.jetbrains.kotlin.idea.resolve.frontendService
 import org.jetbrains.kotlin.idea.util.ImportDescriptorResult
@@ -37,7 +40,6 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.ImportPath
 import org.jetbrains.kotlin.resolve.descriptorUtil.getImportableDescriptor
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
-import org.jetbrains.kotlin.resolve.lazy.DefaultImportProvider
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.scopes.LexicalScope
 import org.jetbrains.kotlin.resolve.scopes.MemberScope
@@ -58,8 +60,18 @@ class ImportInsertHelperImpl(private val project: Project) : ImportInsertHelper(
         get() = ImportPathComparator
 
     override fun isImportedWithDefault(importPath: ImportPath, contextFile: KtFile): Boolean {
-        val defaultImportProvider = contextFile.getResolutionFacade().frontendService<DefaultImportProvider>()
-        return importPath.isImported(defaultImportProvider.defaultImports, defaultImportProvider.excludedImports)
+        val languageVersionSettings = contextFile.getResolutionFacade().frontendService<LanguageVersionSettings>()
+        val platform = TargetPlatformDetector.getPlatform(contextFile)
+        val allDefaultImports = platform.getDefaultImports(
+            languageVersionSettings.supportsFeature(LanguageFeature.DefaultImportOfPackageKotlinComparisons),
+            includeLowPriorityImports = true
+        )
+        return importPath.isImported(allDefaultImports, platform.excludedImports)
+    }
+
+    override fun isImportedWithLowPriorityDefaultImport(importPath: ImportPath, contextFile: KtFile): Boolean {
+        val platform = TargetPlatformDetector.getPlatform(contextFile)
+        return importPath.isImported(platform.defaultLowPriorityImports, platform.excludedImports)
     }
 
     override fun mayImportOnShortenReferences(descriptor: DeclarationDescriptor): Boolean {

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

@@ -162,8 +162,9 @@ private fun renderImportName(fqName: FqName, isOnDemand: Boolean)
         = if (isOnDemand) fqName.render() + ".*" else fqName.render()
 
 private val DEFAULT_IMPORTS_SET: Set<FqName> = JvmPlatform.getDefaultImports(
-        // TODO: use the correct LanguageVersionSettings instance here
-        LanguageVersionSettingsImpl.DEFAULT.supportsFeature(LanguageFeature.DefaultImportOfPackageKotlinComparisons)
+    // TODO: use the correct LanguageVersionSettings instance here
+    LanguageVersionSettingsImpl.DEFAULT.supportsFeature(LanguageFeature.DefaultImportOfPackageKotlinComparisons),
+    includeLowPriorityImports = true
 ).filter { it.isAllUnder }.map { it.fqName }.toSet()
 
 private fun isImportedByDefault(c: KtLightClass) = c.qualifiedName?.let { FqName(it).parent() } in DEFAULT_IMPORTS_SET

jps-plugin/testData/incremental/lookupTracker/jvm/SAM/usages.kt

@@ -3,12 +3,12 @@ package foo
 /*p:bar(SAMInterface)*/import bar.SAMInterface
 
 /*p:foo*/fun foo(c: /*p:bar*/C) /*p:bar(SAMInterface)*/{
-    /*p:bar(C)*/c./*c:bar.C c:bar.SAMInterface(<SAM-CONSTRUCTOR>) c:bar.C(getFoo) c:bar.C(getFOO) p:foo p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/foo()
+    /*p:bar(C)*/c./*c:bar.C c:bar.SAMInterface(<SAM-CONSTRUCTOR>) c:bar.C(getFoo) c:bar.C(getFOO) p:foo p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/foo()
     /*p:bar(C)*/c./*c:bar.C c:bar.SAMInterface(<SAM-CONSTRUCTOR>)*/foo /*p:kotlin(Function1) p:kotlin(String)*/{  }
 
-    /*p:bar p:foo p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/C./*c:bar.C c:bar.SAMInterface(<SAM-CONSTRUCTOR>)*/bar()
-    /*p:bar p:foo p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/C./*c:bar.C c:bar.SAMInterface(<SAM-CONSTRUCTOR>)*/bar /*p:kotlin(Function1) p:kotlin(String)*/{}
+    /*p:bar p:foo p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/C./*c:bar.C c:bar.SAMInterface(<SAM-CONSTRUCTOR>)*/bar()
+    /*p:bar p:foo p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/C./*c:bar.C c:bar.SAMInterface(<SAM-CONSTRUCTOR>)*/bar /*p:kotlin(Function1) p:kotlin(String)*/{}
 
-    /*p:bar c:bar.SAMInterface(<SAM-CONSTRUCTOR>) p:foo p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/SAMInterface()
+    /*p:bar c:bar.SAMInterface(<SAM-CONSTRUCTOR>) p:foo p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/SAMInterface()
     /*p:bar c:bar.SAMInterface(<SAM-CONSTRUCTOR>)*/SAMInterface /*p:kotlin(Function1) p:kotlin(String)*/{}
 }

jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/foo.kt

@@ -18,9 +18,9 @@ import bar.*
         /*c:foo.A*/foo()
         /*p:foo(A) p:kotlin(Int)*/this./*c:foo.A*/a
         /*p:foo(A)*/this./*c:foo.A*/foo()
-        /*c:foo.A c:foo.A(getBaz) c:foo.A(getBAZ) c:foo.A.Companion p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/baz()
-        /*c:foo.A c:foo.A.Companion p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:kotlin(Int)*/Companion./*c:foo.A.Companion*/a
-        /*c:foo.A c:foo.A.Companion p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:kotlin(String)*/O./*c:foo.A.O*/v = /*p:kotlin(String)*/"OK"
+        /*c:foo.A c:foo.A(getBaz) c:foo.A(getBAZ) c:foo.A.Companion p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/baz()
+        /*c:foo.A c:foo.A.Companion p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:kotlin(Int)*/Companion./*c:foo.A.Companion*/a
+        /*c:foo.A c:foo.A.Companion p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:kotlin(String)*/O./*c:foo.A.O*/v = /*p:kotlin(String)*/"OK"
     }
 
     class B {
@@ -64,8 +64,8 @@ import bar.*
     val a = /*p:kotlin(Int)*/1
     fun foo() {
         /*c:foo.E p:kotlin(Int)*/a
-        /*c:foo.E p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:kotlin(Int)*/Y./*c:foo.E*/a
+        /*c:foo.E p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:kotlin(Int)*/Y./*c:foo.E*/a
         /*c:foo.E*/foo()
-        /*c:foo.E p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/X./*c:foo.E*/foo()
+        /*c:foo.E p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/X./*c:foo.E*/foo()
     }
 }

jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/usages.kt

@@ -29,11 +29,11 @@ import bar.*
     val iii = /*p:foo p:foo(I)*/Obj./*c:foo.Obj*/bar()
     /*p:foo(I)*/iii./*c:foo.I*/foo()
 
-    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/E./*c:foo.E*/X
-    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:kotlin(Int)*/E./*c:foo.E*/X./*c:foo.E*/a
-    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/E./*c:foo.E*/Y./*c:foo.E*/foo()
-    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:kotlin(Array)*/E./*c:foo.E*/values()
-    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/E./*c:foo.E*/valueOf(/*p:kotlin(String)*/"")
+    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/E./*c:foo.E*/X
+    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:kotlin(Int)*/E./*c:foo.E*/X./*c:foo.E*/a
+    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/E./*c:foo.E*/Y./*c:foo.E*/foo()
+    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:kotlin(Array)*/E./*c:foo.E*/values()
+    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/E./*c:foo.E*/valueOf(/*p:kotlin(String)*/"")
 }
 
 /*p:foo*/fun classifiers(

jps-plugin/testData/incremental/lookupTracker/jvm/classifierMembers/usages.kt.new.2

@@ -18,8 +18,8 @@ import bar.*
     /*p:foo*/A./*c:foo.A*/Companion./*c:foo.A.Companion*/baz()
     /*p:foo c:foo.A(O)*/A./*c:foo.A.Companion c:foo.A*/O
     /*p:foo p:kotlin(String)*/A./*c:foo.A*/O./*c:foo.A.O*/v = /*p:kotlin(String)*/"OK"
-    /*p:foo*/A./*c:foo.A.Companion c:foo.A c:foo.A.Companion(getVala) c:foo.A.Companion(getVALA) p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/vala
-    /*p:foo*/A./*c:foo.A c:foo.A.Companion c:foo.A.Companion(getVara) c:foo.A.Companion(getVARA) p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/vara()
+    /*p:foo*/A./*c:foo.A.Companion c:foo.A c:foo.A.Companion(getVala) c:foo.A.Companion(getVALA) p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/vala
+    /*p:foo*/A./*c:foo.A c:foo.A.Companion c:foo.A.Companion(getVara) c:foo.A.Companion(getVARA) p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/vara()
 
     /*p:foo(I) p:kotlin(Int)*/i./*c:foo.I*/a = /*p:kotlin(Int)*/2
     /*p:foo p:kotlin(Int)*/Obj./*c:foo.Obj*/a
@@ -31,13 +31,13 @@ import bar.*
     val iii = /*p:foo p:foo(I)*/Obj./*c:foo.Obj*/bar()
     /*p:foo(I)*/iii./*c:foo.I*/foo()
 
-    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/E./*c:foo.E*/X
-    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:kotlin(Int)*/E./*c:foo.E*/X./*c:foo.E*/a
-    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/E./*c:foo.E*/Y./*c:foo.E*/foo()
-    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:kotlin(Array)*/E./*c:foo.E*/values()
-    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/E./*c:foo.E*/valueOf(/*p:kotlin(String)*/"")
-    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/E./*c:foo.E*/foo
-    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/E./*c:foo.E*/bar()
+    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/E./*c:foo.E*/X
+    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:kotlin(Int)*/E./*c:foo.E*/X./*c:foo.E*/a
+    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/E./*c:foo.E*/Y./*c:foo.E*/foo()
+    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:kotlin(Array)*/E./*c:foo.E*/values()
+    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/E./*c:foo.E*/valueOf(/*p:kotlin(String)*/"")
+    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/E./*c:foo.E*/foo
+    /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/E./*c:foo.E*/bar()
 }
 
 /*p:foo*/fun classifiers(

jps-plugin/testData/incremental/lookupTracker/jvm/conventions/delegateProperty.kt

@@ -20,8 +20,8 @@ package foo.bar
 }
 
 
-/*p:foo.bar*/val x1 by /*p:foo.bar c:foo.bar.D1(provideDelegate) c:foo.bar.D1(getProvideDelegate) c:foo.bar.D1(getPROVIDEDelegate) p:foo.bar(provideDelegate) p:kotlin(provideDelegate) p:kotlin.annotation(provideDelegate) p:kotlin.collections(provideDelegate) p:kotlin.ranges(provideDelegate) p:kotlin.sequences(provideDelegate) p:kotlin.text(provideDelegate) p:kotlin.io(provideDelegate) p:kotlin.comparisons(provideDelegate) p:java.lang(provideDelegate) p:kotlin.jvm(provideDelegate) c:foo.bar.D1(getValue)*/D1()
-/*p:foo.bar*/var y1 by /*p:foo.bar c:foo.bar.D1(provideDelegate) c:foo.bar.D1(getProvideDelegate) c:foo.bar.D1(getPROVIDEDelegate) p:foo.bar(provideDelegate) p:kotlin(provideDelegate) p:kotlin.annotation(provideDelegate) p:kotlin.collections(provideDelegate) p:kotlin.ranges(provideDelegate) p:kotlin.sequences(provideDelegate) p:kotlin.text(provideDelegate) p:kotlin.io(provideDelegate) p:kotlin.comparisons(provideDelegate) p:java.lang(provideDelegate) p:kotlin.jvm(provideDelegate) c:foo.bar.D1(getValue) c:foo.bar.D1(setValue) c:foo.bar.D1(getSetValue) c:foo.bar.D1(getSETValue) p:foo.bar(setValue)*/D1()
+/*p:foo.bar*/val x1 by /*p:foo.bar c:foo.bar.D1(provideDelegate) c:foo.bar.D1(getProvideDelegate) c:foo.bar.D1(getPROVIDEDelegate) p:foo.bar(provideDelegate) p:kotlin(provideDelegate) p:kotlin.annotation(provideDelegate) p:kotlin.collections(provideDelegate) p:kotlin.ranges(provideDelegate) p:kotlin.sequences(provideDelegate) p:kotlin.text(provideDelegate) p:kotlin.io(provideDelegate) p:kotlin.comparisons(provideDelegate) p:kotlin.jvm(provideDelegate) c:foo.bar.D1(getValue)*/D1()
+/*p:foo.bar*/var y1 by /*p:foo.bar c:foo.bar.D1(provideDelegate) c:foo.bar.D1(getProvideDelegate) c:foo.bar.D1(getPROVIDEDelegate) p:foo.bar(provideDelegate) p:kotlin(provideDelegate) p:kotlin.annotation(provideDelegate) p:kotlin.collections(provideDelegate) p:kotlin.ranges(provideDelegate) p:kotlin.sequences(provideDelegate) p:kotlin.text(provideDelegate) p:kotlin.io(provideDelegate) p:kotlin.comparisons(provideDelegate) p:kotlin.jvm(provideDelegate) c:foo.bar.D1(getValue) c:foo.bar.D1(setValue) c:foo.bar.D1(getSetValue) c:foo.bar.D1(getSETValue) p:foo.bar(setValue)*/D1()
 
 /*p:foo.bar*/val x2 by /*p:foo.bar c:foo.bar.D2(provideDelegate) c:foo.bar.D2(getProvideDelegate) c:foo.bar.D2(getPROVIDEDelegate) p:foo.bar(provideDelegate) c:foo.bar.D2(getValue) c:foo.bar.D2(getGetValue) c:foo.bar.D2(getGETValue) p:foo.bar(getValue)*/D2()
 /*p:foo.bar*/var y2 by /*p:foo.bar c:foo.bar.D2(provideDelegate) c:foo.bar.D2(getProvideDelegate) c:foo.bar.D2(getPROVIDEDelegate) p:foo.bar(provideDelegate) c:foo.bar.D2(getValue) c:foo.bar.D2(getGetValue) c:foo.bar.D2(getGETValue) p:foo.bar(getValue) c:foo.bar.D2(setValue)*/D2()

jps-plugin/testData/incremental/lookupTracker/jvm/conventions/mathematicalLike.kt

@@ -17,8 +17,8 @@ package foo.bar
     /*p:foo.bar(A)*/a /*c:foo.bar.A(divAssign) c:foo.bar.A(getDivAssign) c:foo.bar.A(getDIVAssign) p:foo.bar(divAssign)*//= /*p:kotlin(Int)*/b
 
     // for var
-    /*p:foo.bar(A)*/d /*c:foo.bar.A(plusAssign) c:foo.bar.A(getPlusAssign) c:foo.bar.A(getPLUSAssign) p:foo.bar(plusAssign) p:kotlin(plusAssign) p:kotlin.annotation(plusAssign) p:kotlin.collections(plusAssign) p:kotlin.ranges(plusAssign) p:kotlin.sequences(plusAssign) p:kotlin.text(plusAssign) p:kotlin.io(plusAssign) p:kotlin.comparisons(plusAssign) p:java.lang(plusAssign) p:kotlin.jvm(plusAssign) c:foo.bar.A(plus)*/+= /*p:kotlin(Int)*/b
-    /*p:foo.bar(A)*/d /*c:foo.bar.A(minusAssign) c:foo.bar.A(getMinusAssign) c:foo.bar.A(getMINUSAssign) p:foo.bar(minusAssign) p:kotlin(minusAssign) p:kotlin.annotation(minusAssign) p:kotlin.collections(minusAssign) p:kotlin.ranges(minusAssign) p:kotlin.sequences(minusAssign) p:kotlin.text(minusAssign) p:kotlin.io(minusAssign) p:kotlin.comparisons(minusAssign) p:java.lang(minusAssign) p:kotlin.jvm(minusAssign) c:foo.bar.A(minus) c:foo.bar.A(getMinus) c:foo.bar.A(getMINUS) p:foo.bar(minus)*/-= /*p:kotlin(Int)*/b
-    /*p:foo.bar(A)*/d /*c:foo.bar.A(timesAssign) c:foo.bar.A(times) c:foo.bar.A(getTimes) c:foo.bar.A(getTIMES) p:foo.bar(times) p:kotlin(times) p:kotlin.annotation(times) p:kotlin.collections(times) p:kotlin.ranges(times) p:kotlin.sequences(times) p:kotlin.text(times) p:kotlin.io(times) p:kotlin.comparisons(times) p:java.lang(times) p:kotlin.jvm(times)*/*= /*p:kotlin(Int)*/b
-    /*p:foo.bar(A)*/d /*c:foo.bar.A(divAssign) c:foo.bar.A(getDivAssign) c:foo.bar.A(getDIVAssign) p:foo.bar(divAssign) c:foo.bar.A(div) c:foo.bar.A(getDiv) c:foo.bar.A(getDIV) p:foo.bar(div) p:kotlin(div) p:kotlin.annotation(div) p:kotlin.collections(div) p:kotlin.ranges(div) p:kotlin.sequences(div) p:kotlin.text(div) p:kotlin.io(div) p:kotlin.comparisons(div) p:java.lang(div) p:kotlin.jvm(div)*//= /*p:kotlin(Int)*/b
+    /*p:foo.bar(A)*/d /*c:foo.bar.A(plusAssign) c:foo.bar.A(getPlusAssign) c:foo.bar.A(getPLUSAssign) p:foo.bar(plusAssign) p:kotlin(plusAssign) p:kotlin.annotation(plusAssign) p:kotlin.collections(plusAssign) p:kotlin.ranges(plusAssign) p:kotlin.sequences(plusAssign) p:kotlin.text(plusAssign) p:kotlin.io(plusAssign) p:kotlin.comparisons(plusAssign) p:kotlin.jvm(plusAssign) p:java.lang(plusAssign) c:foo.bar.A(plus)*/+= /*p:kotlin(Int)*/b
+    /*p:foo.bar(A)*/d /*c:foo.bar.A(minusAssign) c:foo.bar.A(getMinusAssign) c:foo.bar.A(getMINUSAssign) p:foo.bar(minusAssign) p:kotlin(minusAssign) p:kotlin.annotation(minusAssign) p:kotlin.collections(minusAssign) p:kotlin.ranges(minusAssign) p:kotlin.sequences(minusAssign) p:kotlin.text(minusAssign) p:kotlin.io(minusAssign) p:kotlin.comparisons(minusAssign) p:kotlin.jvm(minusAssign) p:java.lang(minusAssign) c:foo.bar.A(minus) c:foo.bar.A(getMinus) c:foo.bar.A(getMINUS) p:foo.bar(minus)*/-= /*p:kotlin(Int)*/b
+    /*p:foo.bar(A)*/d /*c:foo.bar.A(timesAssign) c:foo.bar.A(times) c:foo.bar.A(getTimes) c:foo.bar.A(getTIMES) p:foo.bar(times) p:kotlin(times) p:kotlin.annotation(times) p:kotlin.collections(times) p:kotlin.ranges(times) p:kotlin.sequences(times) p:kotlin.text(times) p:kotlin.io(times) p:kotlin.comparisons(times) p:kotlin.jvm(times) p:java.lang(times)*/*= /*p:kotlin(Int)*/b
+    /*p:foo.bar(A)*/d /*c:foo.bar.A(divAssign) c:foo.bar.A(getDivAssign) c:foo.bar.A(getDIVAssign) p:foo.bar(divAssign) c:foo.bar.A(div) c:foo.bar.A(getDiv) c:foo.bar.A(getDIV) p:foo.bar(div) p:kotlin(div) p:kotlin.annotation(div) p:kotlin.collections(div) p:kotlin.ranges(div) p:kotlin.sequences(div) p:kotlin.text(div) p:kotlin.io(div) p:kotlin.comparisons(div) p:kotlin.jvm(div) p:java.lang(div)*//= /*p:kotlin(Int)*/b
 }

jps-plugin/testData/incremental/lookupTracker/jvm/expressionType/inferredType.kt

@@ -6,8 +6,8 @@ package foo
 /*p:foo*/fun getA() = /*p:foo*/A()
 /*p:foo*/fun getB() = /*p:foo*/B()
 
-/*p:foo*/fun getListOfA() = /*p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:foo p:kotlin.collections(List) p:foo(A)*/listOf(/*p:foo*/A())
-/*p:foo*/fun getListOfB() = /*p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:foo p:kotlin.collections(List) p:foo(B)*/listOf(/*p:foo*/B())
+/*p:foo*/fun getListOfA() = /*p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:java.lang p:foo p:kotlin.collections(List) p:foo(A)*/listOf(/*p:foo*/A())
+/*p:foo*/fun getListOfB() = /*p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:java.lang p:foo p:kotlin.collections(List) p:foo(B)*/listOf(/*p:foo*/B())
 
 /*p:foo*/fun useListOfA(a: /*p:foo p:kotlin.collections*/List</*p:foo*/A>) {}
 /*p:foo*/fun useListOfB(b: /*p:foo p:kotlin.collections*/List</*p:foo*/B>) {}

jps-plugin/testData/incremental/lookupTracker/jvm/java/usages.kt

@@ -11,27 +11,27 @@ import baz.*
     /*p:bar(C)*/c./*c:bar.C*/func()
     /*p:bar(C) c:bar.C(B)*/c./*c:bar.C*/B()
 
-    /*p:bar p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:kotlin(String)*/C./*c:bar.C*/sfield
-    /*p:bar p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:kotlin(String)*/C./*c:bar.C*/sfield = /*p:kotlin(String)*/"new"
-    /*p:bar p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/C./*c:bar.C*/sfunc()
-    /*p:bar p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm c:bar.C(S)*/C./*c:bar.C*/S()
+    /*p:bar p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:kotlin(String)*/C./*c:bar.C*/sfield
+    /*p:bar p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:kotlin(String)*/C./*c:bar.C*/sfield = /*p:kotlin(String)*/"new"
+    /*p:bar p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/C./*c:bar.C*/sfunc()
+    /*p:bar p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm c:bar.C(S)*/C./*c:bar.C*/S()
 
     // inherited from I
     /*p:bar(C)*/c./*c:bar.C*/ifunc()
-    /*p:bar p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:kotlin(String)*/C./*c:bar.C*/isfield
+    /*p:bar p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:kotlin(String)*/C./*c:bar.C*/isfield
     // expected error: Unresolved reference: IS
-    /*p:bar p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/C./*c:bar.C*/IS()
+    /*p:bar p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/C./*c:bar.C*/IS()
 
 
     val i: /*p:foo*/I = /*p:bar(C)*/c
     /*p:foo(I)*/i./*c:foo.I*/ifunc()
 
-    /*p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:kotlin(String)*/I./*c:foo.I*/isfield
-    /*p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm c:foo.I(IS)*/I./*c:foo.I*/IS()
+    /*p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:kotlin(String)*/I./*c:foo.I*/isfield
+    /*p:foo p:baz p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm c:foo.I(IS)*/I./*c:foo.I*/IS()
 
-    /*p:baz p:foo p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/E./*c:baz.E*/F
-    /*p:baz p:foo p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:kotlin(Int)*/E./*c:baz.E*/F./*c:baz.E*/field
-    /*p:baz p:foo p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/E./*c:baz.E*/S./*c:baz.E*/func()
+    /*p:baz p:foo p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/E./*c:baz.E*/F
+    /*p:baz p:foo p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:kotlin(Int)*/E./*c:baz.E*/F./*c:baz.E*/field
+    /*p:baz p:foo p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/E./*c:baz.E*/S./*c:baz.E*/func()
 }
 
 /*p:foo*/fun classifiers(

jps-plugin/testData/incremental/lookupTracker/jvm/packageDeclarations/foo1.kt

@@ -4,7 +4,7 @@ import bar.*
 /*p:baz(C)*/import baz.C
 
 /*p:foo*/val a = /*p:bar p:foo*/A()
-/*p:foo*/var b: /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/baz./*p:baz*/B = /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:baz(B)*/baz./*p:baz*/B()
+/*p:foo*/var b: /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:java.lang*/baz./*p:baz*/B = /*p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:java.lang p:baz(B)*/baz./*p:baz*/B()
 
 /*p:foo*/fun function(p: /*p:foo p:bar*/B): /*p:foo p:bar*/B /*p:kotlin(Nothing)*/{
     /*p:foo p:bar(A)*/a
@@ -12,6 +12,6 @@ import bar.*
 }
 
 /*p:foo*/fun /*p:foo*/MyClass.extFunc(p: /**p:foo p:bar*//*p:foo p:kotlin*/Array</*p:foo p:bar*/B>, e: /*p:foo*/MyEnum, c: /**???*//*p:baz*/C): /*p:foo*/MyInterface /*p:kotlin(Nothing)*/{
-    /*c:foo.MyClass c:foo.MyClass(getB) p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm p:baz(B)*/b
-    /*p:kotlin(Nothing)*/return /*c:foo.MyClass p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/MyClass()
+    /*c:foo.MyClass c:foo.MyClass(getB) p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm p:baz(B)*/b
+    /*p:kotlin(Nothing)*/return /*c:foo.MyClass p:foo p:bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/MyClass()
 }

jps-plugin/testData/incremental/lookupTracker/jvm/syntheticProperties/usages.kt

@@ -8,23 +8,23 @@ package foo.bar
     val k = /*p:foo*/KotlinClass()
 
     /*p:<root>(JavaClass) p:kotlin(Int)*/j./*c:JavaClass*/getFoo()
-    /*p:<root>(JavaClass)*/j./*c:JavaClass c:JavaClass(getSetFoo) c:JavaClass(getSETFoo) p:foo.bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/setFoo(2)
+    /*p:<root>(JavaClass)*/j./*c:JavaClass c:JavaClass(getSetFoo) c:JavaClass(getSETFoo) p:foo.bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/setFoo(2)
     /*p:<root>(JavaClass) p:kotlin(Int)*/j./*c:JavaClass c:JavaClass(getFoo) c:JavaClass(getFOO) c:JavaClass(setFoo)*/foo = /*p:kotlin(Int)*/2
     /*p:<root>(JavaClass) p:kotlin(Int)*/j./*c:JavaClass c:JavaClass(getFoo) c:JavaClass(getFOO) c:JavaClass(setFoo)*/foo
     /*p:<root>(JavaClass) p:kotlin(String)*/j./*c:JavaClass c:JavaClass(getBar) c:JavaClass(getBAR) c:JavaClass(setBar)*/bar
     /*p:<root>(JavaClass) p:kotlin(String)*/j./*c:JavaClass c:JavaClass(getBar) c:JavaClass(getBAR) c:JavaClass(setBar)*/bar = /*p:kotlin(String)*/""
-    /*p:<root>(JavaClass)*/j./*c:JavaClass c:JavaClass(getBazBaz) c:JavaClass(getBAZBaz) p:foo.bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/bazBaz
-    /*p:<root>(JavaClass)*/j./*c:JavaClass c:JavaClass(getBazBaz) c:JavaClass(getBAZBaz) p:foo.bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/bazBaz = /*p:kotlin(String)*/""
+    /*p:<root>(JavaClass)*/j./*c:JavaClass c:JavaClass(getBazBaz) c:JavaClass(getBAZBaz) p:foo.bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/bazBaz
+    /*p:<root>(JavaClass)*/j./*c:JavaClass c:JavaClass(getBazBaz) c:JavaClass(getBAZBaz) p:foo.bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/bazBaz = /*p:kotlin(String)*/""
     /*p:<root>(JavaClass)*/j./*c:JavaClass*/setBoo(2)
-    /*p:<root>(JavaClass)*/j./*c:JavaClass c:JavaClass(getBoo) c:JavaClass(getBOO) p:foo.bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm*/boo = /*p:kotlin(Int)*/2
+    /*p:<root>(JavaClass)*/j./*c:JavaClass c:JavaClass(getBoo) c:JavaClass(getBOO) p:foo.bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm*/boo = /*p:kotlin(Int)*/2
     /*p:foo(KotlinClass) p:kotlin(Int)*/k./*c:foo.KotlinClass c:JavaClass*/getFoo() // getFoo may be an inner class in JavaClass
     /*p:foo(KotlinClass)*/k./*c:foo.KotlinClass c:JavaClass*/setFoo(2)
     /*p:foo(KotlinClass) p:kotlin(Int)*/k./*c:foo.KotlinClass c:foo.KotlinClass(getFoo) c:foo.KotlinClass(getFOO) c:foo.KotlinClass(setFoo)*/foo = /*p:kotlin(Int)*/2
     /*p:foo(KotlinClass) p:kotlin(Int)*/k./*c:foo.KotlinClass c:foo.KotlinClass(getFoo) c:foo.KotlinClass(getFOO) c:foo.KotlinClass(setFoo)*/foo
     /*p:foo(KotlinClass) p:kotlin(String)*/k./*c:foo.KotlinClass c:foo.KotlinClass(getBar) c:foo.KotlinClass(getBAR) c:foo.KotlinClass(setBar)*/bar
     /*p:foo(KotlinClass) p:kotlin(String)*/k./*c:foo.KotlinClass c:foo.KotlinClass(getBar) c:foo.KotlinClass(getBAR) c:foo.KotlinClass(setBar)*/bar = /*p:kotlin(String)*/""
-    /*p:foo(KotlinClass)*/k./*c:foo.KotlinClass c:foo.KotlinClass(getBazBaz) c:foo.KotlinClass(getBAZBaz) p:foo.bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm c:JavaClass*/bazBaz
-    /*p:foo(KotlinClass)*/k./*c:foo.KotlinClass c:foo.KotlinClass(getBazBaz) c:foo.KotlinClass(getBAZBaz) p:foo.bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm c:JavaClass*/bazBaz = /*p:kotlin(String)*/""
+    /*p:foo(KotlinClass)*/k./*c:foo.KotlinClass c:foo.KotlinClass(getBazBaz) c:foo.KotlinClass(getBAZBaz) p:foo.bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm c:JavaClass*/bazBaz
+    /*p:foo(KotlinClass)*/k./*c:foo.KotlinClass c:foo.KotlinClass(getBazBaz) c:foo.KotlinClass(getBAZBaz) p:foo.bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm c:JavaClass*/bazBaz = /*p:kotlin(String)*/""
     /*p:foo(KotlinClass)*/k./*c:foo.KotlinClass c:JavaClass*/setBoo(2)
-    /*p:foo(KotlinClass)*/k./*c:foo.KotlinClass c:foo.KotlinClass(getBoo) c:foo.KotlinClass(getBOO) p:foo.bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:java.lang p:kotlin.jvm c:JavaClass*/boo = /*p:kotlin(Int)*/2
+    /*p:foo(KotlinClass)*/k./*c:foo.KotlinClass c:foo.KotlinClass(getBoo) c:foo.KotlinClass(getBOO) p:foo.bar p:kotlin p:kotlin.annotation p:kotlin.collections p:kotlin.ranges p:kotlin.sequences p:kotlin.text p:kotlin.io p:kotlin.comparisons p:kotlin.jvm c:JavaClass*/boo = /*p:kotlin(Int)*/2
 }

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

@@ -23,15 +23,13 @@ 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
+import org.jetbrains.kotlin.storage.StorageManager
 
 object JsPlatform : TargetPlatform("JS") {
-    private val defaultImports = LockBasedStorageManager().createMemoizedFunction<Boolean, List<ImportPath>> { includeKotlinComparisons ->
-        Common.getDefaultImports(includeKotlinComparisons) + ImportPath.fromString("kotlin.js.*")
+    override fun computePlatformSpecificDefaultImports(storageManager: StorageManager, result: MutableList<ImportPath>) {
+        result.add(ImportPath.fromString("kotlin.js.*"))
     }
 
-    override fun getDefaultImports(includeKotlinComparisons: Boolean): List<ImportPath> = defaultImports(includeKotlinComparisons)
-
     override val platformConfigurator: PlatformConfigurator = JsPlatformConfigurator
 
     val builtIns: KotlinBuiltIns
@@ -39,5 +37,6 @@ object JsPlatform : TargetPlatform("JS") {
 
     override val multiTargetPlatform = MultiTargetPlatform.Specific(platformName)
 
-    override val excludedImports: List<FqName> = listOf("Promise", "Date", "Console", "Math", "RegExp", "RegExpMatch", "Json", "json").map { FqName("kotlin.js.$it") }
+    override val excludedImports: List<FqName> =
+        listOf("Promise", "Date", "Console", "Math", "RegExp", "RegExpMatch", "Json", "json").map { FqName("kotlin.js.$it") }
 }