Explicitly state that PluginDeclarationProviderFactory is source-only

Before this change `filesScope` was effectively empty in cases when
module info is a library, thus looking
into PackageIndexUtil.packageExists(name, indexedFilesScope, project)
was kind of redundant since it always returns false for empty scopes

The initial motivation was run by 1716720604
that made PackageIndexUtil::packageExists calls much more frequent

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

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.resolve.jvm
 
-import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.config.JvmTarget
 import org.jetbrains.kotlin.container.get
@@ -58,7 +57,7 @@ object JvmAnalyzerFacade : AnalyzerFacade() {
         val project = moduleContext.project
         val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
             project, moduleContext.storageManager, syntheticFiles,
-            if (moduleInfo.isLibrary) GlobalSearchScope.EMPTY_SCOPE else moduleContentScope,
+            moduleContentScope,
             moduleInfo
         )
 

compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt

@@ -233,8 +233,6 @@ data class ModuleContent(
 interface PlatformAnalysisParameters
 
 interface ModuleInfo {
-    val isLibrary: Boolean
-        get() = false
     val name: Name
     val displayedName: String get() = name.asString()
     fun dependencies(): List<ModuleInfo>

compiler/frontend/src/org/jetbrains/kotlin/analyzer/common/CommonAnalyzerFacade.kt

@@ -112,7 +112,7 @@ object CommonAnalyzerFacade : AnalyzerFacade() {
         val project = moduleContext.project
         val declarationProviderFactory = DeclarationProviderFactoryService.createDeclarationProviderFactory(
             project, moduleContext.storageManager, syntheticFiles,
-            if (moduleInfo.isLibrary) GlobalSearchScope.EMPTY_SCOPE else moduleContentScope,
+            moduleContentScope,
             moduleInfo
         )
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/DeclarationProviderFactoryService.kt

@@ -42,11 +42,11 @@ abstract class DeclarationProviderFactoryService {
             project: Project,
             storageManager: StorageManager,
             syntheticFiles: Collection<KtFile>,
-            filesScope: GlobalSearchScope,
+            moduleContentScope: GlobalSearchScope,
             moduleInfo: ModuleInfo
         ): DeclarationProviderFactory {
             return ServiceManager.getService(project, DeclarationProviderFactoryService::class.java)!!
-                .create(project, storageManager, syntheticFiles, filteringScope(syntheticFiles, filesScope), moduleInfo)
+                .create(project, storageManager, syntheticFiles, filteringScope(syntheticFiles, moduleContentScope), moduleInfo)
         }
 
         private fun filteringScope(syntheticFiles: Collection<KtFile>, baseScope: GlobalSearchScope): GlobalSearchScope {

idea/ide-common/src/org/jetbrains/kotlin/caches/resolve/JsAnalyzerFacade.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.idea.caches.resolve
 
-import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.*
 import org.jetbrains.kotlin.caches.resolve.LibraryModuleInfo
 import org.jetbrains.kotlin.config.TargetPlatformVersion
@@ -56,7 +55,7 @@ object JsAnalyzerFacade : AnalyzerFacade() {
             project,
             moduleContext.storageManager,
             syntheticFiles,
-            if (moduleInfo.isLibrary) GlobalSearchScope.EMPTY_SCOPE else moduleContentScope,
+            moduleContentScope,
             moduleInfo
         )
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaModuleInfos.kt

@@ -221,9 +221,6 @@ class LibraryInfo(val project: Project, val library: Library) : IdeaModuleInfo,
 
     override fun contentScope(): GlobalSearchScope = LibraryWithoutSourceScope(project, library)
 
-    override val isLibrary: Boolean
-        get() = true
-
     override fun dependencies(): List<IdeaModuleInfo> {
         val result = LinkedHashSet<IdeaModuleInfo>()
         result.add(this)
@@ -261,9 +258,6 @@ data class LibrarySourceInfo(val project: Project, val library: Library) : IdeaM
 
     override fun sourceScope(): GlobalSearchScope = KotlinSourceFilterScope.librarySources(LibrarySourceScope(project, library), project)
 
-    override val isLibrary: Boolean
-        get() = true
-
     override fun modulesWhoseInternalsAreVisible(): Collection<ModuleInfo> {
         return listOf(LibraryInfo(project, library))
     }
@@ -366,4 +360,4 @@ interface SourceForBinaryModuleInfo : IdeaModuleInfo {
 
     override val moduleOrigin: ModuleOrigin
         get() = ModuleOrigin.OTHER
-}
+}

idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/KotlinSourceFilterScope.kt

@@ -18,7 +18,6 @@ package org.jetbrains.kotlin.idea.stubindex
 
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.ProjectRootManager
-import com.intellij.openapi.util.Ref
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.search.DelegatingGlobalSearchScope
 import com.intellij.psi.search.GlobalSearchScope
@@ -86,9 +85,6 @@ class KotlinSourceFilterScope private constructor(
         @JvmStatic
         fun projectSourceAndClassFiles(delegate: GlobalSearchScope, project: Project) = create(delegate, true, false, true, false, project)
 
-        @JvmStatic
-        fun sources(delegate: GlobalSearchScope, project: Project) = create(delegate, true, false, false, true, project)
-
         @JvmStatic
         fun projectSources(delegate: GlobalSearchScope, project: Project) = create(delegate, true, false, false, false, project)
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/PluginDeclarationProviderFactory.kt

@@ -61,10 +61,9 @@ class PluginDeclarationProviderFactory(
         fileBasedDeclarationProviderFactory.packageExists(fqName) || stubBasedPackageExists(fqName)
 
     private fun stubBasedPackageExists(name: FqName): Boolean {
-        return if (moduleInfo is ModuleSourceInfo)
+        // We're only looking for source-based declarations
-            project.service<PerModulePackageCacheService>().packageExists(name, moduleInfo)
+        val moduleSourceInfo = moduleInfo as? ModuleSourceInfo ?: return false
-        else
+        return project.service<PerModulePackageCacheService>().packageExists(name, moduleSourceInfo)
-            PackageIndexUtil.packageExists(name, indexedFilesScope, project)
     }
 
     private fun getStubBasedPackageMemberDeclarationProvider(name: FqName): PackageMemberDeclarationProvider? {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/resolve/PluginDeclarationProviderFactoryService.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.idea.stubindex.resolve
 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.idea.caches.resolve.ModuleSourceInfo
 import org.jetbrains.kotlin.idea.stubindex.KotlinSourceFilterScope
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.lazy.declarations.DeclarationProviderFactory
@@ -28,11 +29,25 @@ import org.jetbrains.kotlin.storage.StorageManager
 class PluginDeclarationProviderFactoryService : DeclarationProviderFactoryService() {
 
     override fun create(
-            project: Project,
+        project: Project,
-            storageManager: StorageManager,
+        storageManager: StorageManager,
-            syntheticFiles: Collection<KtFile>,
+        syntheticFiles: Collection<KtFile>,
-            filesScope: GlobalSearchScope,
+        filesScope: GlobalSearchScope,
-            moduleInfo: ModuleInfo
+        moduleInfo: ModuleInfo
-    ): DeclarationProviderFactory =
+    ): DeclarationProviderFactory {
-        PluginDeclarationProviderFactory(project, KotlinSourceFilterScope.sources(filesScope, project), storageManager, syntheticFiles, moduleInfo)
+        if (syntheticFiles.isEmpty() && moduleInfo !is ModuleSourceInfo) {
+            // No actual source declarations for libraries
+            // Even in case of libraries sources they should be obtained through the classpath with subsequent decompiling
+            // Anyway, we'll filter them out with `KotlinSourceFilterScope.sources` call below
+            return DeclarationProviderFactory.EMPTY
+        }
+
+        return PluginDeclarationProviderFactory(
+            project,
+            KotlinSourceFilterScope.projectSources(filesScope, project),
+            storageManager,
+            syntheticFiles,
+            moduleInfo
+        )
+    }
 }