Completion optimizations: do not search classes in java package when no SAM-constructors needed or when only singleton classifiers needed

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SamConversionResolverImpl.kt

@@ -30,7 +30,6 @@ import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor
 import org.jetbrains.jet.lang.types.TypeUtils
 import java.util.ArrayList
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker
-import org.jetbrains.jet.lang.descriptors.SamConstructorDescriptor
 
 public object SamConversionResolverImpl : SamConversionResolver {
     override fun resolveSamConstructor(name: Name, scope: JetScope): SamConstructorDescriptor? {

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt

@@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaVisibilities
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaConstructorDescriptor
 import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils
 import org.jetbrains.jet.lang.types.JetType
+import org.jetbrains.jet.lang.resolve.scopes.JetScope
 
 public class LazyJavaClassMemberScope(
         c: LazyJavaResolverContextWithTypes,
@@ -45,7 +46,8 @@ public class LazyJavaClassMemberScope(
     override fun computeMemberIndex(): MemberIndex {
         return object : ClassMemberIndex(jClass, { !it.isStatic() }) {
             // For SAM-constructors
-            override fun getMethodNames(nameFilter: (Name) -> Boolean): Collection<Name> = super.getMethodNames(nameFilter) + getClassNames(nameFilter)
+            override fun getMethodNames(nameFilter: (Name) -> Boolean): Collection<Name>
+                    = super.getMethodNames(nameFilter) + getClassNames(JetScope.KindFilter.CLASSIFIERS, nameFilter)
         }
     }
 
@@ -230,7 +232,9 @@ public class LazyJavaClassMemberScope(
             DescriptorUtils.getDispatchReceiverParameterIfNeeded(getContainingDeclaration())
 
     override fun getClassifier(name: Name): ClassifierDescriptor? = nestedClasses(name)
-    override fun getClassNames(nameFilter: (Name) -> Boolean): Collection<Name> = nestedClassIndex().keySet() + enumEntryIndex().keySet()
+
+    override fun getClassNames(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<Name>
+            = nestedClassIndex().keySet() + enumEntryIndex().keySet()
 
     // TODO
     override fun getImplicitReceiversHierarchy(): List<ReceiverParameterDescriptor> = listOf()

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaMemberScope.kt

@@ -210,7 +210,9 @@ public abstract class LazyJavaMemberScope(
     }
 
     override fun getFunctions(name: Name) = functions(name)
-    protected open fun getFunctionNames(nameFilter: (Name) -> Boolean): Collection<Name> = memberIndex().getMethodNames(nameFilter)
+
+    protected open fun getFunctionNames(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<Name>
+            = memberIndex().getMethodNames(nameFilter)
 
     protected abstract fun computeNonDeclaredProperties(name: Name, result: MutableCollection<PropertyDescriptor>)
 
@@ -298,9 +300,8 @@ public abstract class LazyJavaMemberScope(
                                      nameFilter: (Name) -> Boolean): List<DeclarationDescriptor> {
         val result = LinkedHashSet<DeclarationDescriptor>()
 
-        //TODO: only non-singleton classifiers in package!
         if (kindFilter.acceptsKind(JetScope.CLASSIFIERS_MASK)) {
-            for (name in getClassNames(nameFilter)) {
+            for (name in getClassNames(kindFilter, nameFilter)) {
                 if (nameFilter(name)) {
                     // Null signifies that a class found in Java is not present in Kotlin (e.g. package class)
                     result.addIfNotNull(getClassifier(name))
@@ -308,9 +309,8 @@ public abstract class LazyJavaMemberScope(
             }
         }
 
-        //TODO: SAM-constructors only in package!
         if (kindFilter.acceptsKind(JetScope.FUNCTION) && !kindFilter.excludes.contains(JetScope.DescriptorKindExclude.NonExtensions)) {
-            for (name in getFunctionNames(nameFilter)) {
+            for (name in getFunctionNames(kindFilter, nameFilter)) {
                 if (nameFilter(name)) {
                     result.addAll(getFunctions(name))
                 }
@@ -336,7 +336,7 @@ public abstract class LazyJavaMemberScope(
         // Do nothing
     }
 
-    protected abstract fun getClassNames(nameFilter: (Name) -> Boolean): Collection<Name>
+    protected abstract fun getClassNames(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<Name>
 
     override fun toString() = "Lazy scope for ${getContainingDeclaration()}"
     

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaStaticClassScope.kt

@@ -23,6 +23,7 @@ import org.jetbrains.jet.lang.resolve.java.lazy.LazyJavaResolverContext
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass
 import org.jetbrains.jet.lang.resolve.DescriptorFactory.*
 import org.jetbrains.jet.utils.addIfNotNull
+import org.jetbrains.jet.lang.resolve.scopes.JetScope
 
 public class LazyJavaStaticClassScope(
         c: LazyJavaResolverContext,
@@ -42,14 +43,14 @@ public class LazyJavaStaticClassScope(
         }
     }
 
-    override fun getFunctionNames(nameFilter: (Name) -> Boolean): Collection<Name> {
+    override fun getFunctionNames(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<Name> {
         if (jClass.isEnum()) {
-            return super.getFunctionNames(nameFilter) + listOf(DescriptorUtils.ENUM_VALUE_OF, DescriptorUtils.ENUM_VALUES)
+            return super.getFunctionNames(kindFilter, nameFilter) + listOf(DescriptorUtils.ENUM_VALUE_OF, DescriptorUtils.ENUM_VALUES)
         }
-        return super.getFunctionNames(nameFilter)
+        return super.getFunctionNames(kindFilter, nameFilter)
     }
     
-    override fun getClassNames(nameFilter: (Name) -> Boolean): Collection<Name> = listOf()
+    override fun getClassNames(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<Name> = listOf()
     override fun getClassifier(name: Name): ClassifierDescriptor? = null
 
     override fun getSubPackages(): Collection<FqName> = listOf()

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyPackageFragmentScopeForJavaPackage.kt

@@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.resolve.java.PackageClassUtils
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass
 import org.jetbrains.jet.utils.addIfNotNull
+import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptorKindExclude
 
 public class LazyPackageFragmentScopeForJavaPackage(
         c: LazyJavaResolverContext,
@@ -75,15 +76,25 @@ public class LazyPackageFragmentScopeForJavaPackage(
 
     override fun computeMemberIndex(): MemberIndex = object : MemberIndex by EMPTY_MEMBER_INDEX {
         // For SAM-constructors
-        override fun getMethodNames(nameFilter: (Name) -> Boolean): Collection<Name> = getClassNames(nameFilter)
+        override fun getMethodNames(nameFilter: (Name) -> Boolean): Collection<Name> = getClassNames(JetScope.KindFilter.CLASSIFIERS, nameFilter)
     }
 
-    override fun getClassNames(nameFilter: (Name) -> Boolean): Collection<Name> {
+    override fun getClassNames(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<Name> {
+        // neither objects nor enum members can be in java package
+        if (!kindFilter.acceptsKind(JetScope.NON_SINGLETON_CLASSIFIER)) return listOf()
+
         return jPackage.getClasses(nameFilter).stream()
                 .filter { c -> c.getOriginKind() != JavaClass.OriginKind.KOTLIN_LIGHT_CLASS }
                 .map { c -> c.getName() }.toList()
     }
 
+    override fun getFunctionNames(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<Name> {
+        // optimization: only SAM-constructors may exist in java package
+        if (kindFilter.excludes.contains(SamConstructorDescriptorKindExclude)) return listOf()
+
+        return super.getFunctionNames(kindFilter, nameFilter)
+    }
+
     private val subPackages = c.storageManager.createRecursionTolerantLazyValue(
             {
                 jPackage.getSubPackages().map { sp -> sp.getFqName() }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/SamConversionResolver.kt

@@ -22,7 +22,7 @@ import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
 import org.jetbrains.jet.lang.types.JetType
 import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor
-import org.jetbrains.jet.lang.descriptors.SamConstructorDescriptor
+import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor
 
 public trait SamConversionResolver {
     public fun resolveSamConstructor(name: Name, scope: JetScope): SamConstructorDescriptor?