Implement LazyPackageMemberScope::getFunctions/VariableNames

It's necessary for future optimizations
Although current implementation is rather conservative,
it should be enough for current needs

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/DelegatePackageMemberDeclarationProvider.kt

@@ -41,4 +41,6 @@ open class DelegatePackageMemberDeclarationProvider(var delegate: PackageMemberD
     override fun getClassOrObjectDeclarations(name: Name) = delegate.getClassOrObjectDeclarations(name)
 
     override fun getTypeAliasDeclarations(name: Name) = delegate.getTypeAliasDeclarations(name)
+
+    override fun getDeclarationNames() = delegate.getDeclarationNames()
 }

compiler/frontend/src/org/jetbrains/kotlin/psi/synthetics/SyntheticClassOrObjectDescriptor.kt

@@ -131,6 +131,7 @@ class SyntheticClassOrObjectDescriptor(
         override fun getDestructuringDeclarationsEntries(name: Name): Collection<KtDestructuringDeclarationEntry> = emptyList()
         override fun getClassOrObjectDeclarations(name: Name): Collection<KtClassLikeInfo> = emptyList()
         override fun getTypeAliasDeclarations(name: Name): Collection<KtTypeAlias> = emptyList()
+        override fun getDeclarationNames() = emptySet<Name>()
     }
 
     internal inner class SyntheticDeclaration(

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

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.resolve.lazy.declarations
 
 import com.google.common.collect.ArrayListMultimap
+import com.google.common.collect.Sets
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.lazy.ResolveSessionUtils.safeNameForLazyResolve
@@ -37,6 +38,7 @@ abstract class AbstractPsiBasedDeclarationProvider(storageManager: StorageManage
         val classesAndObjects = ArrayListMultimap.create<Name, KtClassLikeInfo>() // order matters here
         val typeAliases = ArrayListMultimap.create<Name, KtTypeAlias>()
         val destructuringDeclarationsEntries = ArrayListMultimap.create<Name, KtDestructuringDeclarationEntry>()
+        val names = Sets.newHashSet<Name>()
 
         fun putToIndex(declaration: KtDeclaration) {
             if (declaration is KtAnonymousInitializer || declaration is KtSecondaryConstructor) return
@@ -57,7 +59,9 @@ abstract class AbstractPsiBasedDeclarationProvider(storageManager: StorageManage
                 }
                 is KtDestructuringDeclaration -> {
                     for (entry in declaration.entries) {
-                        destructuringDeclarationsEntries.put(safeNameForLazyResolve(entry.nameAsName), entry)
+                        val name = safeNameForLazyResolve(entry.nameAsName)
+                        destructuringDeclarationsEntries.put(name, entry)
+                        names.add(name)
                     }
                 }
                 is KtParameter -> {
@@ -65,11 +69,17 @@ abstract class AbstractPsiBasedDeclarationProvider(storageManager: StorageManage
                 }
                 else -> throw IllegalArgumentException("Unknown declaration: " + declaration)
             }
+
+            when (declaration) {
+                is KtNamedDeclaration -> names.add(safeNameForLazyResolve(declaration))
+            }
         }
 
         override fun toString() = "allDeclarations: " + allDeclarations.mapNotNull { it.name }
     }
 
+    override fun getDeclarationNames() = index().names
+
     private val index = storageManager.createLazyValue<Index> {
         val index = Index()
         doCreateIndex(index)

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

@@ -41,4 +41,6 @@ class CombinedPackageMemberDeclarationProvider(
     override fun getClassOrObjectDeclarations(name: Name) = providers.flatMap { it.getClassOrObjectDeclarations(name) }
 
     override fun getTypeAliasDeclarations(name: Name) = providers.flatMap { it.getTypeAliasDeclarations(name) }
+
+    override fun getDeclarationNames(): Set<Name> = providers.flatMapTo(HashSet()) { it.getDeclarationNames() }
 }

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

@@ -33,4 +33,6 @@ interface DeclarationProvider {
     fun getClassOrObjectDeclarations(name: Name): Collection<KtClassLikeInfo>
 
     fun getTypeAliasDeclarations(name: Name): Collection<KtTypeAlias>
+
+    fun getDeclarationNames(): Set<Name>
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyPackageMemberScope.kt

@@ -58,6 +58,9 @@ class LazyPackageMemberScope(
         c.lookupTracker.record(from, thisDescriptor, name)
     }
 
+    override fun getFunctionNames() = declarationProvider.getDeclarationNames()
+    override fun getVariableNames() = declarationProvider.getDeclarationNames()
+
     // Do not add details here, they may compromise the laziness during debugging
     override fun toString() = "lazy scope for package " + thisDescriptor.name
 }

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

@@ -61,6 +61,10 @@ class StubBasedPackageMemberDeclarationProvider(
         return result
     }
 
+    override fun getDeclarationNames() =
+            getDeclarations(DescriptorKindFilter.ALL, { true })
+                    .mapTo(mutableSetOf()) { ResolveSessionUtils.safeNameForLazyResolve(it as KtNamedDeclaration) }
+
     override fun getClassOrObjectDeclarations(name: Name): Collection<KtClassLikeInfo> {
         val result = ArrayList<KtClassLikeInfo>()
         runReadAction {