Moved KindFilter and DescriptorKindExclude out of JetScope, moved constants as well and renamed them

compiler/backend/src/org/jetbrains/jet/codegen/PackageCodegen.java

@@ -54,6 +54,7 @@ import org.jetbrains.jet.lang.resolve.java.jvmSignature.JvmMethodSignature;
 import org.jetbrains.jet.lang.resolve.kotlin.PackagePartClassUtils;
 import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalPackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
 import org.jetbrains.org.objectweb.asm.MethodVisitor;
@@ -151,7 +152,7 @@ public class PackageCodegen {
             return Collections.emptyList();
         }
         List<DeserializedCallableMemberDescriptor> callables = Lists.newArrayList();
-        for (DeclarationDescriptor member : packageFragment.getMemberScope().getDescriptors(JetScope.KindFilter.CALLABLES, JetScope.ALL_NAME_FILTER)) {
+        for (DeclarationDescriptor member : packageFragment.getMemberScope().getDescriptors(DescriptorKindFilter.CALLABLES, JetScope.ALL_NAME_FILTER)) {
             if (member instanceof DeserializedCallableMemberDescriptor) {
                 callables.add((DeserializedCallableMemberDescriptor) member);
             }

compiler/builtins-serializer/src/BuiltInsSerializer.kt

@@ -47,7 +47,7 @@ import org.jetbrains.jet.analyzer.ModuleInfo
 import org.jetbrains.jet.lang.resolve.java.JvmPlatformParameters
 import org.jetbrains.jet.analyzer.ModuleContent
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils
-import org.jetbrains.jet.lang.resolve.scopes.JetScope
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public class BuiltInsSerializer(val out: PrintStream?) {
     private var totalSize = 0
@@ -117,7 +117,7 @@ public class BuiltInsSerializer(val out: PrintStream?) {
         })
 
         val classNames = ArrayList<Name>()
-        val classifierDescriptors = DescriptorSerializer.sort(packageView.getMemberScope().getDescriptors(JetScope.KindFilter.CLASSIFIERS))
+        val classifierDescriptors = DescriptorSerializer.sort(packageView.getMemberScope().getDescriptors(DescriptorKindFilter.CLASSIFIERS))
 
         ClassSerializationUtil.serializeClasses(classifierDescriptors, serializer, object : ClassSerializationUtil.Sink {
             override fun writeClass(classDescriptor: ClassDescriptor, classProto: ProtoBuf.Class) {

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java

@@ -38,15 +38,21 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.BindingTraceContext;
+import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
+import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
-import java.util.*;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
 
 /**
  * This class solves the problem of interdependency between analyzing Kotlin code and generating JetLightClasses
@@ -216,7 +222,7 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport
         PackageViewDescriptor packageView = getModule().getPackage(fqn);
         if (packageView == null) return Collections.emptyList();
 
-        Collection<DeclarationDescriptor> members = packageView.getMemberScope().getDescriptors(JetScope.KindFilter.PACKAGES, JetScope.ALL_NAME_FILTER);
+        Collection<DeclarationDescriptor> members = packageView.getMemberScope().getDescriptors(DescriptorKindFilter.PACKAGES, JetScope.ALL_NAME_FILTER);
         return ContainerUtil.mapNotNull(members, new Function<DeclarationDescriptor, FqName>() {
             @Override
             public FqName fun(DeclarationDescriptor member) {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.kt

@@ -158,7 +158,7 @@ public class LazyImportScope(private val resolveSession: ResolveSession,
 
     override fun getDeclarationsByLabel(labelName: Name): Collection<DeclarationDescriptor> = listOf()
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
+    override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
         return resolveSession.getStorageManager().compute {
             val descriptors = LinkedHashSet<DeclarationDescriptor>()
             for (directive in importsProvider.getAllImports()) {

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

@@ -28,7 +28,7 @@ import org.jetbrains.jet.storage.StorageManager
 
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils.safeNameForLazyResolve
 import java.util.ArrayList
-import org.jetbrains.jet.lang.resolve.scopes.JetScope
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public abstract class AbstractPsiBasedDeclarationProvider(storageManager: StorageManager) : DeclarationProvider {
 
@@ -73,7 +73,7 @@ public abstract class AbstractPsiBasedDeclarationProvider(storageManager: Storag
 
     protected abstract fun doCreateIndex(index: Index)
 
-    override fun getDeclarations(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): List<JetDeclaration>
+    override fun getDeclarations(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): List<JetDeclaration>
             = index().allDeclarations
 
     override fun getFunctionDeclarations(name: Name): List<JetNamedFunction>

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

@@ -21,10 +21,10 @@ import org.jetbrains.jet.lang.psi.JetNamedFunction
 import org.jetbrains.jet.lang.psi.JetProperty
 import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo
 import org.jetbrains.jet.lang.resolve.name.Name
-import org.jetbrains.jet.lang.resolve.scopes.JetScope
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public trait DeclarationProvider {
-    public fun getDeclarations(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): List<JetDeclaration>
+    public fun getDeclarations(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): List<JetDeclaration>
 
     public fun getFunctionDeclarations(name: Name): Collection<JetNamedFunction>
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/AbstractLazyMemberScope.kt

@@ -34,6 +34,7 @@ import org.jetbrains.jet.utils.Printer
 import java.util.*
 import org.jetbrains.jet.storage.StorageManager
 import org.jetbrains.jet.utils.toReadOnlyList
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public abstract class AbstractLazyMemberScope<D : DeclarationDescriptor, DP : DeclarationProvider> protected(
         protected val resolveSession: ResolveSession,
@@ -118,7 +119,7 @@ public abstract class AbstractLazyMemberScope<D : DeclarationDescriptor, DP : De
 
     override fun getDeclarationsByLabel(labelName: Name) = setOf<DeclarationDescriptor>()
 
-    protected fun computeDescriptorsFromDeclaredElements(kindFilter: JetScope.KindFilter,
+    protected fun computeDescriptorsFromDeclaredElements(kindFilter: DescriptorKindFilter,
                                                          nameFilter: (Name) -> Boolean): List<DeclarationDescriptor> {
         val declarations = declarationProvider.getDeclarations(kindFilter, nameFilter)
         val result = ArrayList<DeclarationDescriptor>(declarations.size())

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.kt

@@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor.Kind.DELEGATI
 import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor.Kind.FAKE_OVERRIDE
 import org.jetbrains.jet.lang.resolve.DelegationResolver.generateDelegatedMembers
 import org.jetbrains.jet.storage.NotNullLazyValue
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public open class LazyClassMemberScope(resolveSession: ResolveSession,
                                   declarationProvider: ClassMemberDeclarationProvider,
@@ -46,13 +47,13 @@ public open class LazyClassMemberScope(resolveSession: ResolveSession,
 : AbstractLazyMemberScope<LazyClassDescriptor, ClassMemberDeclarationProvider>(resolveSession, declarationProvider, thisClass, trace) {
 
     private val descriptorsFromDeclaredElements = storageManager.createLazyValue {
-        computeDescriptorsFromDeclaredElements(JetScope.KindFilter.ALL, JetScope.ALL_NAME_FILTER)
+        computeDescriptorsFromDeclaredElements(DescriptorKindFilter.ALL, JetScope.ALL_NAME_FILTER)
     }
     private val extraDescriptors: NotNullLazyValue<Collection<DeclarationDescriptor>> = storageManager.createLazyValue {
         computeExtraDescriptors()
     }
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter,
+    override fun getDescriptors(kindFilter: DescriptorKindFilter,
                                 nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
         val result = LinkedHashSet(descriptorsFromDeclaredElements())
         result.addAll(extraDescriptors())

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

@@ -21,7 +21,7 @@ import org.jetbrains.jet.lang.psi.JetDeclaration
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession
 import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider
 import org.jetbrains.jet.lang.resolve.name.Name
-import org.jetbrains.jet.lang.resolve.scopes.JetScope
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public class LazyPackageMemberScope(
         resolveSession: ResolveSession,
@@ -29,7 +29,7 @@ public class LazyPackageMemberScope(
         thisPackage: PackageFragmentDescriptor)
 : AbstractLazyMemberScope<PackageFragmentDescriptor, PackageMemberDeclarationProvider>(resolveSession, declarationProvider, thisPackage, resolveSession.getTrace()) {
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
+    override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
         return computeDescriptorsFromDeclaredElements(kindFilter, nameFilter)
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.kt

@@ -95,7 +95,7 @@ public class WritableScopeImpl(scope: JetScope,
         super.clearImports()
     }
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter,
+    override fun getDescriptors(kindFilter: DescriptorKindFilter,
                                 nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
         checkMayRead()
         changeLockLevel(WritableScope.LockLevel.READING)

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.kt

@@ -164,7 +164,7 @@ public class WriteThroughScope(outerScope: JetScope, private val writableWorker:
         writableWorker.setImplicitReceiver(implicitReceiver)
     }
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter,
+    override fun getDescriptors(kindFilter: DescriptorKindFilter,
                                 nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
         checkMayRead()
 

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

@@ -16,11 +16,10 @@
 
 package org.jetbrains.jet.lang.resolve.java.descriptor
 
-import org.jetbrains.jet.lang.descriptors.ClassOrPackageFragmentDescriptor
 import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl
 import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor
-import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindExclude
 
 public class SamConstructorDescriptor(
         containingDeclaration: DeclarationDescriptor,
@@ -34,6 +33,6 @@ public class SamConstructorDescriptor(
         samInterface.getSource()
 )
 
-public object SamConstructorDescriptorKindExclude : JetScope.DescriptorKindExclude {
+public object SamConstructorDescriptorKindExclude : DescriptorKindExclude {
         override fun matches(descriptor: DeclarationDescriptor) = descriptor is SamConstructorDescriptor
 }

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

@@ -35,7 +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
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public class LazyJavaClassMemberScope(
         c: LazyJavaResolverContextWithTypes,
@@ -47,7 +47,7 @@ public class LazyJavaClassMemberScope(
         return object : ClassMemberIndex(jClass, { !it.isStatic() }) {
             // For SAM-constructors
             override fun getMethodNames(nameFilter: (Name) -> Boolean): Collection<Name>
-                    = super.getMethodNames(nameFilter) + getClassNames(JetScope.KindFilter.CLASSIFIERS, nameFilter)
+                    = super.getMethodNames(nameFilter) + getClassNames(DescriptorKindFilter.CLASSIFIERS, nameFilter)
         }
     }
 
@@ -233,7 +233,7 @@ public class LazyJavaClassMemberScope(
 
     override fun getClassifier(name: Name): ClassifierDescriptor? = nestedClasses(name)
 
-    override fun getClassNames(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<Name>
+    override fun getClassNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection<Name>
             = nestedClassIndex().keySet() + enumEntryIndex().keySet()
 
     // TODO

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

@@ -44,7 +44,8 @@ import org.jetbrains.jet.lang.resolve.java.resolver.ExternalSignatureResolver
 import org.jetbrains.jet.utils.*
 import org.jetbrains.jet.lang.resolve.java.PLATFORM_TYPES
 import org.jetbrains.jet.lang.descriptors.annotations.Annotations
-import org.jetbrains.jet.lang.resolve.scopes.JetScope.DescriptorKindExclude.NonExtensions
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindExclude.NonExtensions
 
 public abstract class LazyJavaMemberScope(
         protected val c: LazyJavaResolverContextWithTypes,
@@ -53,7 +54,7 @@ public abstract class LazyJavaMemberScope(
     // this lazy value is not used at all in LazyPackageFragmentScopeForJavaPackage because we do not use caching there
     // but is placed in the base class to not duplicate code
     private val allDescriptors = c.storageManager.createRecursionTolerantLazyValue<Collection<DeclarationDescriptor>>(
-            { computeDescriptors(JetScope.KindFilter.ALL, JetScope.ALL_NAME_FILTER) },
+            { computeDescriptors(DescriptorKindFilter.ALL, JetScope.ALL_NAME_FILTER) },
             // This is to avoid the following recursive case:
             //    when computing getAllPackageNames() we ask the JavaPsiFacade for all subpackages of foo
             //    it, in turn, asks JavaElementFinder for subpackages of Kotlin package foo, which calls getAllPackageNames() recursively
@@ -212,7 +213,7 @@ public abstract class LazyJavaMemberScope(
 
     override fun getFunctions(name: Name) = functions(name)
 
-    protected open fun getFunctionNames(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<Name>
+    protected open fun getFunctionNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection<Name>
             = memberIndex().getMethodNames(nameFilter)
 
     protected abstract fun computeNonDeclaredProperties(name: Name, result: MutableCollection<PropertyDescriptor>)
@@ -294,14 +295,14 @@ public abstract class LazyJavaMemberScope(
 
     override fun getOwnDeclaredDescriptors() = getDescriptors()
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter,
+    override fun getDescriptors(kindFilter: DescriptorKindFilter,
                                 nameFilter: (Name) -> Boolean) = allDescriptors()
 
-    protected fun computeDescriptors(kindFilter: JetScope.KindFilter,
+    protected fun computeDescriptors(kindFilter: DescriptorKindFilter,
                                      nameFilter: (Name) -> Boolean): List<DeclarationDescriptor> {
         val result = LinkedHashSet<DeclarationDescriptor>()
 
-        if (kindFilter.acceptsKind(JetScope.CLASSIFIERS_MASK)) {
+        if (kindFilter.acceptsKind(DescriptorKindFilter.CLASSIFIERS_MASK)) {
             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)
@@ -310,7 +311,7 @@ public abstract class LazyJavaMemberScope(
             }
         }
 
-        if (kindFilter.acceptsKind(JetScope.FUNCTION) && !kindFilter.excludes.contains(NonExtensions)) {
+        if (kindFilter.acceptsKind(DescriptorKindFilter.FUNCTIONS_MASK) && !kindFilter.excludes.contains(NonExtensions)) {
             for (name in getFunctionNames(kindFilter, nameFilter)) {
                 if (nameFilter(name)) {
                     result.addAll(getFunctions(name))
@@ -318,7 +319,7 @@ public abstract class LazyJavaMemberScope(
             }
         }
 
-        if (kindFilter.acceptsKind(JetScope.VARIABLE) && !kindFilter.excludes.contains(NonExtensions)) {
+        if (kindFilter.acceptsKind(DescriptorKindFilter.VARIABLES_MASK) && !kindFilter.excludes.contains(NonExtensions)) {
             for (name in getAllPropertyNames()) {
                 if (nameFilter(name)) {
                     result.addAll(getProperties(name))
@@ -332,12 +333,12 @@ public abstract class LazyJavaMemberScope(
     }
 
     protected open fun addExtraDescriptors(result: MutableSet<DeclarationDescriptor>,
-                                           kindFilter: JetScope.KindFilter,
+                                           kindFilter: DescriptorKindFilter,
                                            nameFilter: (Name) -> Boolean) {
         // Do nothing
     }
 
-    protected abstract fun getClassNames(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<Name>
+    protected abstract fun getClassNames(kindFilter: DescriptorKindFilter, 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,7 +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
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public class LazyJavaStaticClassScope(
         c: LazyJavaResolverContext,
@@ -43,14 +43,14 @@ public class LazyJavaStaticClassScope(
         }
     }
 
-    override fun getFunctionNames(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<Name> {
+    override fun getFunctionNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection<Name> {
         if (jClass.isEnum()) {
             return super.getFunctionNames(kindFilter, nameFilter) + listOf(DescriptorUtils.ENUM_VALUE_OF, DescriptorUtils.ENUM_VALUES)
         }
         return super.getFunctionNames(kindFilter, nameFilter)
     }
     
-    override fun getClassNames(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<Name> = listOf()
+    override fun getClassNames(kindFilter: DescriptorKindFilter, 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

@@ -27,6 +27,7 @@ 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
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public class LazyPackageFragmentScopeForJavaPackage(
         c: LazyJavaResolverContext,
@@ -69,26 +70,26 @@ public class LazyPackageFragmentScopeForJavaPackage(
     override fun getFunctions(name: Name) = deserializedPackageScope().getFunctions(name) + super.getFunctions(name)
 
     override fun addExtraDescriptors(result: MutableSet<DeclarationDescriptor>,
-                                     kindFilter: JetScope.KindFilter,
+                                     kindFilter: DescriptorKindFilter,
                                      nameFilter: (Name) -> Boolean) {
         result.addAll(deserializedPackageScope().getDescriptors(kindFilter, nameFilter))
     }
 
     override fun computeMemberIndex(): MemberIndex = object : MemberIndex by EMPTY_MEMBER_INDEX {
         // For SAM-constructors
-        override fun getMethodNames(nameFilter: (Name) -> Boolean): Collection<Name> = getClassNames(JetScope.KindFilter.CLASSIFIERS, nameFilter)
+        override fun getMethodNames(nameFilter: (Name) -> Boolean): Collection<Name> = getClassNames(DescriptorKindFilter.CLASSIFIERS, nameFilter)
     }
 
-    override fun getClassNames(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<Name> {
+    override fun getClassNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection<Name> {
         // neither objects nor enum members can be in java package
-        if (!kindFilter.acceptsKind(JetScope.NON_SINGLETON_CLASSIFIER)) return listOf()
+        if (!kindFilter.acceptsKind(DescriptorKindFilter.NON_SINGLETON_CLASSIFIERS_MASK)) 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> {
+    override fun getFunctionNames(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection<Name> {
         // optimization: only SAM-constructors may exist in java package
         if (kindFilter.excludes.contains(SamConstructorDescriptorKindExclude)) return listOf()
 
@@ -112,7 +113,7 @@ public class LazyPackageFragmentScopeForJavaPackage(
     override fun getAllPropertyNames() = listOf<Name>()
 
     // we don't use implementation from super which caches all descriptors and does not use filters
-    override fun getDescriptors(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
+    override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
         return computeDescriptors(kindFilter, nameFilter)
     }
 }

core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/EnumEntrySyntheticClassDescriptor.java

@@ -26,6 +26,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorFactory;
 import org.jetbrains.jet.lang.resolve.OverridingUtil;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.name.SpecialNames;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl;
 import org.jetbrains.jet.lang.resolve.scopes.StaticScopeForKotlinClass;
@@ -257,7 +258,7 @@ public class EnumEntrySyntheticClassDescriptor extends ClassDescriptorBase {
         @NotNull
         @Override
         public Collection<DeclarationDescriptor> getDescriptors(
-                @NotNull JetScope.KindFilter kindFilter,
+                @NotNull DescriptorKindFilter kindFilter,
                 @NotNull Function1<? super Name, ? extends Boolean> nameFilter
         ) {
             return allDescriptors.invoke();

core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/SubpackagesScope.kt

@@ -24,6 +24,7 @@ import org.jetbrains.jet.utils.*
 
 import java.util.ArrayList
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public class SubpackagesScope(private val containingDeclaration: PackageViewDescriptor) : JetScopeImpl() {
     override fun getContainingDeclaration(): DeclarationDescriptor {
@@ -34,9 +35,9 @@ public class SubpackagesScope(private val containingDeclaration: PackageViewDesc
         return if (name.isSpecial()) null else containingDeclaration.getModule().getPackage(containingDeclaration.getFqName().child(name))
     }
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter,
+    override fun getDescriptors(kindFilter: DescriptorKindFilter,
                                 nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
-        if (!kindFilter.acceptsKind(JetScope.PACKAGE)) return listOf()
+        if (!kindFilter.acceptsKind(DescriptorKindFilter.PACKAGES_MASK)) return listOf()
 
         val subFqNames = containingDeclaration.getModule().getPackageFragmentProvider().getSubPackagesOf(containingDeclaration.getFqName(), nameFilter)
         val result = ArrayList<DeclarationDescriptor>(subFqNames.size())

core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/AbstractScopeAdapter.kt

@@ -58,7 +58,7 @@ public abstract class AbstractScopeAdapter : JetScope {
         return workerScope.getDeclarationsByLabel(labelName)
     }
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter,
+    override fun getDescriptors(kindFilter: DescriptorKindFilter,
                                 nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
         return workerScope.getDescriptors(kindFilter, nameFilter)
     }

core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.kt

@@ -59,7 +59,7 @@ public class ChainedScope(private val containingDeclaration: DeclarationDescript
 
     override fun getDeclarationsByLabel(labelName: Name) = scopeChain.flatMap { it.getDeclarationsByLabel(labelName) }
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter,
+    override fun getDescriptors(kindFilter: DescriptorKindFilter,
                                 nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
         val result = LinkedHashSet<DeclarationDescriptor>()
         scopeChain.flatMapTo(result) { it.getDescriptors(kindFilter, nameFilter) }

core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/FilteringScope.kt

@@ -37,7 +37,7 @@ public class FilteringScope(private val workerScope: JetScope, private val predi
 
     override fun getLocalVariable(name: Name) = filterDescriptor(workerScope.getLocalVariable(name))
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter,
+    override fun getDescriptors(kindFilter: DescriptorKindFilter,
                                 nameFilter: (Name) -> Boolean) = workerScope.getDescriptors(kindFilter, nameFilter).filter(predicate)
 
     override fun getImplicitReceiversHierarchy() = workerScope.getImplicitReceiversHierarchy()

core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.kt

@@ -25,9 +25,9 @@ public class InnerClassesScopeWrapper(override val workerScope: JetScope) : Abst
 
     override fun getDeclarationsByLabel(labelName: Name) = workerScope.getDeclarationsByLabel(labelName).filterIsInstance(javaClass<ClassDescriptor>())
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter,
+    override fun getDescriptors(kindFilter: DescriptorKindFilter,
                                 nameFilter: (Name) -> Boolean): List<ClassDescriptor> {
-        val restrictedFilter = kindFilter.restrictedToKinds(JetScope.CLASSIFIERS_MASK) ?: return listOf()
+        val restrictedFilter = kindFilter.restrictedToKinds(DescriptorKindFilter.CLASSIFIERS_MASK) ?: return listOf()
         return workerScope.getDescriptors(restrictedFilter, nameFilter).filterIsInstance(javaClass<ClassDescriptor>())
     }
 

core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.kt

@@ -50,7 +50,7 @@ public trait JetScope {
      * All visible descriptors from current scope possibly filtered by the given name and kind filters
      * (that means that the implementation is not obliged to use the filters but may do so when it gives any performance advantage).
      */
-    public fun getDescriptors(kindFilter: JetScope.KindFilter = KindFilter(ALL_KINDS_MASK),
+    public fun getDescriptors(kindFilter: DescriptorKindFilter = DescriptorKindFilter.ALL,
                               nameFilter: (Name) -> Boolean = ALL_NAME_FILTER): Collection<DeclarationDescriptor>
 
     /**
@@ -77,77 +77,7 @@ public trait JetScope {
         }
     }
 
-    public trait DescriptorKindExclude {
-        public fun matches(descriptor: DeclarationDescriptor): Boolean
-
-        public object Extensions : DescriptorKindExclude {
-            override fun matches(descriptor: DeclarationDescriptor)
-                    = descriptor is CallableDescriptor && descriptor.getExtensionReceiverParameter() != null
-        }
-
-        public object NonExtensions : DescriptorKindExclude {
-            override fun matches(descriptor: DeclarationDescriptor)
-                    = descriptor !is CallableDescriptor || descriptor.getExtensionReceiverParameter() == null
-        }
-    }
-
-    public class KindFilter(
-            public val kindMask: Int,
-            public val excludes: List<DescriptorKindExclude> = listOf()
-    ) {
-        public fun accepts(descriptor: DeclarationDescriptor): Boolean
-                = kindMask and descriptor.kind() != 0 && excludes.all { !it.matches(descriptor) }
-
-        public fun acceptsKind(kinds: Int): Boolean
-                = kindMask and kinds != 0
-
-        public fun exclude(exclude: DescriptorKindExclude): KindFilter
-                = KindFilter(kindMask, excludes + listOf(exclude))
-
-        public fun withoutKind(kinds: Int): KindFilter
-                = KindFilter(kindMask and kinds.inv(), excludes)
-
-        public fun restrictedToKinds(kinds: Int): KindFilter? {
-            val mask = kindMask and kinds
-            if (mask == 0) return null
-            return KindFilter(mask, excludes)
-        }
-
-        class object {
-            public val ALL: KindFilter = KindFilter(ALL_KINDS_MASK)
-            public val CALLABLES: KindFilter = KindFilter(FUNCTION or VARIABLE)
-            public val NON_SINGLETON_CLASSIFIERS: KindFilter = KindFilter(NON_SINGLETON_CLASSIFIER)
-            public val SINGLETON_CLASSIFIERS: KindFilter = KindFilter(SINGLETON_CLASSIFIER)
-            public val CLASSIFIERS: KindFilter = KindFilter(CLASSIFIERS_MASK)
-            public val PACKAGES: KindFilter = KindFilter(PACKAGE)
-            public val FUNCTIONS: KindFilter = KindFilter(FUNCTION)
-            public val VARIABLES: KindFilter = KindFilter(VARIABLE)
-            public val VALUES: KindFilter = KindFilter(VALUES_MASK)
-        }
-    }
-
     class object {
-        public val NON_SINGLETON_CLASSIFIER: Int = 0x01
-        public val SINGLETON_CLASSIFIER: Int = 0x02
-        public val PACKAGE: Int = 0x04
-        public val FUNCTION: Int = 0x08
-        public val VARIABLE: Int = 0x10
-
-        public val ALL_KINDS_MASK: Int = 0x1F
-        public val CLASSIFIERS_MASK: Int = NON_SINGLETON_CLASSIFIER or SINGLETON_CLASSIFIER
-        public val VALUES_MASK: Int = SINGLETON_CLASSIFIER or FUNCTION or VARIABLE
-
-        public fun DeclarationDescriptor.kind(): Int {
-            return when (this) {
-                is ClassDescriptor -> if (this.getKind().isSingleton()) SINGLETON_CLASSIFIER else NON_SINGLETON_CLASSIFIER
-                is ClassifierDescriptor -> NON_SINGLETON_CLASSIFIER
-                is PackageFragmentDescriptor, is PackageViewDescriptor -> PACKAGE
-                is FunctionDescriptor -> FUNCTION
-                is VariableDescriptor -> VARIABLE
-                else -> 0
-            }
-        }
-
         public val ALL_NAME_FILTER: (Name) -> Boolean = { true }
     }
 }
@@ -156,11 +86,78 @@ public trait JetScope {
  * The same as getDescriptors(kindFilter, nameFilter) but the result is guaranteed to be filtered by kind and name.
  */
 public fun JetScope.getDescriptorsFiltered(
-        kindFilter: JetScope.KindFilter,
+        kindFilter: DescriptorKindFilter,
         nameFilter: (Name) -> Boolean
 ): Collection<DeclarationDescriptor> {
     return getDescriptors(kindFilter, nameFilter).filter { kindFilter.accepts(it) && nameFilter(it.getName()) }
 }
 
+public class DescriptorKindFilter(
+        public val kindMask: Int,
+        public val excludes: List<DescriptorKindExclude> = listOf()
+) {
+    public fun accepts(descriptor: DeclarationDescriptor): Boolean
+            = kindMask and descriptor.kind() != 0 && excludes.all { !it.matches(descriptor) }
 
+    public fun acceptsKind(kinds: Int): Boolean
+            = kindMask and kinds != 0
 
+    public fun exclude(exclude: DescriptorKindExclude): DescriptorKindFilter
+            = DescriptorKindFilter(kindMask, excludes + listOf(exclude))
+
+    public fun withoutKind(kinds: Int): DescriptorKindFilter
+            = DescriptorKindFilter(kindMask and kinds.inv(), excludes)
+
+    public fun restrictedToKinds(kinds: Int): DescriptorKindFilter? {
+        val mask = kindMask and kinds
+        if (mask == 0) return null
+        return DescriptorKindFilter(mask, excludes)
+    }
+
+    private fun DeclarationDescriptor.kind(): Int {
+        return when (this) {
+            is ClassDescriptor -> if (this.getKind().isSingleton()) SINGLETON_CLASSIFIERS_MASK else NON_SINGLETON_CLASSIFIERS_MASK
+            is ClassifierDescriptor -> NON_SINGLETON_CLASSIFIERS_MASK
+            is PackageFragmentDescriptor, is PackageViewDescriptor -> PACKAGES_MASK
+            is FunctionDescriptor -> FUNCTIONS_MASK
+            is VariableDescriptor -> VARIABLES_MASK
+            else -> 0
+        }
+    }
+
+    class object {
+        public val NON_SINGLETON_CLASSIFIERS_MASK: Int = 0x01
+        public val SINGLETON_CLASSIFIERS_MASK: Int = 0x02
+        public val PACKAGES_MASK: Int = 0x04
+        public val FUNCTIONS_MASK: Int = 0x08
+        public val VARIABLES_MASK: Int = 0x10
+
+        public val ALL_KINDS_MASK: Int = 0x1F
+        public val CLASSIFIERS_MASK: Int = NON_SINGLETON_CLASSIFIERS_MASK or SINGLETON_CLASSIFIERS_MASK
+        public val VALUES_MASK: Int = SINGLETON_CLASSIFIERS_MASK or FUNCTIONS_MASK or VARIABLES_MASK
+
+        public val ALL: DescriptorKindFilter = DescriptorKindFilter(ALL_KINDS_MASK)
+        public val CALLABLES: DescriptorKindFilter = DescriptorKindFilter(FUNCTIONS_MASK or VARIABLES_MASK)
+        public val NON_SINGLETON_CLASSIFIERS: DescriptorKindFilter = DescriptorKindFilter(NON_SINGLETON_CLASSIFIERS_MASK)
+        public val SINGLETON_CLASSIFIERS: DescriptorKindFilter = DescriptorKindFilter(SINGLETON_CLASSIFIERS_MASK)
+        public val CLASSIFIERS: DescriptorKindFilter = DescriptorKindFilter(CLASSIFIERS_MASK)
+        public val PACKAGES: DescriptorKindFilter = DescriptorKindFilter(PACKAGES_MASK)
+        public val FUNCTIONS: DescriptorKindFilter = DescriptorKindFilter(FUNCTIONS_MASK)
+        public val VARIABLES: DescriptorKindFilter = DescriptorKindFilter(VARIABLES_MASK)
+        public val VALUES: DescriptorKindFilter = DescriptorKindFilter(VALUES_MASK)
+    }
+}
+
+public trait DescriptorKindExclude {
+    public fun matches(descriptor: DeclarationDescriptor): Boolean
+
+    public object Extensions : DescriptorKindExclude {
+        override fun matches(descriptor: DeclarationDescriptor)
+                = descriptor is CallableDescriptor && descriptor.getExtensionReceiverParameter() != null
+    }
+
+    public object NonExtensions : DescriptorKindExclude {
+        override fun matches(descriptor: DeclarationDescriptor)
+                = descriptor !is CallableDescriptor || descriptor.getExtensionReceiverParameter() == null
+    }
+}

core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.kt

@@ -34,7 +34,7 @@ public abstract class JetScopeImpl : JetScope {
 
     override fun getDeclarationsByLabel(labelName: Name): Collection<DeclarationDescriptor> = listOf()
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter,
+    override fun getDescriptors(kindFilter: DescriptorKindFilter,
                                 nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> = listOf()
 
     override fun getImplicitReceiversHierarchy(): List<ReceiverParameterDescriptor> = listOf()

core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/StaticScopeForKotlinClass.kt

@@ -37,7 +37,7 @@ public class StaticScopeForKotlinClass(
         }
     }
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter,
+    override fun getDescriptors(kindFilter: DescriptorKindFilter,
                                 nameFilter: (Name) -> Boolean) = functions
 
     override fun getOwnDeclaredDescriptors() = functions

core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.kt

@@ -84,7 +84,7 @@ public class SubstitutingScope(private val workerScope: JetScope, private val su
         throw UnsupportedOperationException() // TODO
     }
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter,
+    override fun getDescriptors(kindFilter: DescriptorKindFilter,
                                 nameFilter: (Name) -> Boolean) = _allDescriptors
 
     override fun getOwnDeclaredDescriptors() = substitute(workerScope.getOwnDeclaredDescriptors())

core/descriptors/src/org/jetbrains/jet/lang/types/ErrorUtils.java

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.resolve.ImportPath;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.error.ErrorSimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -126,7 +127,7 @@ public class ErrorUtils {
         @NotNull
         @Override
         public Collection<DeclarationDescriptor> getDescriptors(
-                @NotNull JetScope.KindFilter kindFilter, @NotNull Function1<? super Name, ? extends Boolean> nameFilter
+                @NotNull DescriptorKindFilter kindFilter, @NotNull Function1<? super Name, ? extends Boolean> nameFilter
         ) {
             return Collections.emptyList();
         }
@@ -206,7 +207,7 @@ public class ErrorUtils {
         @NotNull
         @Override
         public Collection<DeclarationDescriptor> getDescriptors(
-                @NotNull JetScope.KindFilter kindFilter, @NotNull Function1<? super Name, ? extends Boolean> nameFilter
+                @NotNull DescriptorKindFilter kindFilter, @NotNull Function1<? super Name, ? extends Boolean> nameFilter
         ) {
             throw new IllegalStateException();
         }

core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.kt

@@ -40,6 +40,7 @@ import org.jetbrains.jet.lang.resolve.name.SpecialNames.getClassObjectName
 import org.jetbrains.jet.descriptors.serialization.classKind
 import org.jetbrains.jet.utils.addIfNotNull
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public fun DeserializedClassDescriptor(globalContext: DeserializationGlobalContext, classData: ClassData): DeserializedClassDescriptor
         = DeserializedClassDescriptor(globalContext.withNameResolver(classData.getNameResolver()), classData.getClassProto())
@@ -181,9 +182,9 @@ public class DeserializedClassDescriptor(outerContext: DeserializationContext, p
 
     private inner class DeserializedClassMemberScope : DeserializedMemberScope(context, this@DeserializedClassDescriptor.classProto.getMemberList()) {
         private val classDescriptor: DeserializedClassDescriptor = this@DeserializedClassDescriptor
-        private val allDescriptors = context.storageManager.createLazyValue { computeDescriptors(JetScope.KindFilter.ALL, JetScope.ALL_NAME_FILTER) }
+        private val allDescriptors = context.storageManager.createLazyValue { computeDescriptors(DescriptorKindFilter.ALL, JetScope.ALL_NAME_FILTER) }
 
-        override fun getDescriptors(kindFilter: JetScope.KindFilter,
+        override fun getDescriptors(kindFilter: DescriptorKindFilter,
                                     nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> = allDescriptors()
 
         override fun computeNonDeclaredFunctions(name: Name, functions: MutableCollection<FunctionDescriptor>) {

core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.kt

@@ -26,6 +26,7 @@ import org.jetbrains.jet.utils.Printer
 
 import java.util.*
 import org.jetbrains.jet.utils.toReadOnlyList
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public abstract class DeserializedMemberScope protected(
         private val context: DeserializationContextWithTypes,
@@ -101,16 +102,16 @@ public abstract class DeserializedMemberScope protected(
 
     override fun getDeclarationsByLabel(labelName: Name): Collection<DeclarationDescriptor> = listOf()
 
-    protected fun computeDescriptors(kindFilter: JetScope.KindFilter,
+    protected fun computeDescriptors(kindFilter: DescriptorKindFilter,
                                      nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
         val result = LinkedHashSet<DeclarationDescriptor>(0)
 
         for (name in membersProtos().keySet()) {
             if (nameFilter(name)) {
-                if (kindFilter.acceptsKind(JetScope.FUNCTION)) {
+                if (kindFilter.acceptsKind(DescriptorKindFilter.FUNCTIONS_MASK)) {
                     result.addAll(getFunctions(name))
                 }
-                if (kindFilter.acceptsKind(JetScope.VARIABLE)) {
+                if (kindFilter.acceptsKind(DescriptorKindFilter.VARIABLES_MASK)) {
                     result.addAll(getProperties(name))
                 }
             }
@@ -118,7 +119,7 @@ public abstract class DeserializedMemberScope protected(
 
         addNonDeclaredDescriptors(result)
 
-        if (kindFilter.acceptsKind(JetScope.CLASSIFIERS_MASK)) {
+        if (kindFilter.acceptsKind(DescriptorKindFilter.CLASSIFIERS_MASK)) {
             addClassDescriptors(result, nameFilter)
         }
 

core/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.kt

@@ -24,8 +24,8 @@ import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
 import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor
 import org.jetbrains.jet.lang.resolve.name.ClassId
 import org.jetbrains.jet.lang.resolve.name.Name
-import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.utils.addIfNotNull
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 
 public fun DeserializedPackageMemberScope(packageDescriptor: PackageFragmentDescriptor,
@@ -44,7 +44,7 @@ public open class DeserializedPackageMemberScope(
     private val packageFqName = packageDescriptor.fqName
     private val classNames = context.storageManager.createLazyValue(classNames)
 
-    override fun getDescriptors(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean)
+    override fun getDescriptors(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean)
             = computeDescriptors(kindFilter, nameFilter)
 
     override fun getClassDescriptor(name: Name) = context.deserializeClass(ClassId(packageFqName, name))

idea/idea-analysis/src/org/jetbrains/jet/plugin/stubindex/resolve/CombinedPackageMemberDeclarationProvider.kt

@@ -18,14 +18,14 @@ package org.jetbrains.jet.plugin.stubindex.resolve
 
 import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider
 import org.jetbrains.jet.lang.resolve.name.Name
-import org.jetbrains.jet.lang.resolve.scopes.JetScope
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public class CombinedPackageMemberDeclarationProvider(val providers: Collection<PackageMemberDeclarationProvider>) : PackageMemberDeclarationProvider {
     override fun getAllDeclaredSubPackages() = providers.flatMap { it.getAllDeclaredSubPackages() }
 
     override fun getPackageFiles() = providers.flatMap { it.getPackageFiles() }
 
-    override fun getDeclarations(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean)
+    override fun getDeclarations(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean)
             = providers.flatMap { it.getDeclarations(kindFilter, nameFilter) }
 
     override fun getFunctionDeclarations(name: Name) = providers.flatMap { it.getFunctionDeclarations(name) }

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

@@ -30,8 +30,8 @@ import org.jetbrains.jet.plugin.stubindex.PackageIndexUtil
 import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo
 import org.jetbrains.jet.lang.resolve.lazy.data.JetClassInfoUtil
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils
-import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import java.util.ArrayList
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 public class StubBasedPackageMemberDeclarationProvider(
         private val fqName: FqName,
@@ -39,18 +39,18 @@ public class StubBasedPackageMemberDeclarationProvider(
         private val searchScope: GlobalSearchScope
 ) : PackageMemberDeclarationProvider {
 
-    override fun getDeclarations(kindFilter: JetScope.KindFilter, nameFilter: (Name) -> Boolean): List<JetDeclaration> {
+    override fun getDeclarations(kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean): List<JetDeclaration> {
         val result = ArrayList<JetDeclaration>()
 
-        if (kindFilter.acceptsKind(JetScope.CLASSIFIERS_MASK)) {
+        if (kindFilter.acceptsKind(DescriptorKindFilter.CLASSIFIERS_MASK)) {
             result.addDeclarations(JetFullClassNameIndex.getInstance(), nameFilter)
         }
 
-        if (kindFilter.acceptsKind(JetScope.FUNCTION)) {
+        if (kindFilter.acceptsKind(DescriptorKindFilter.FUNCTIONS_MASK)) {
             result.addDeclarations(JetTopLevelFunctionsFqnNameIndex.getInstance(), nameFilter)
         }
 
-        if (kindFilter.acceptsKind(JetScope.VARIABLE)) {
+        if (kindFilter.acceptsKind(DescriptorKindFilter.VARIABLES_MASK)) {
             result.addDeclarations(JetTopLevelPropertiesFqnNameIndex.getInstance(), nameFilter)
         }
 

idea/src/org/jetbrains/jet/plugin/codeInsight/TipsManager.kt

@@ -31,12 +31,14 @@ import org.jetbrains.jet.lang.resolve.bindingContextUtil.getDataFlowInfo
 import org.jetbrains.jet.lang.resolve.name.Name
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.jet.lang.resolve.scopes.getDescriptorsFiltered
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindExclude
 
 public object TipsManager{
 
     public fun getReferenceVariants(expression: JetSimpleNameExpression,
                                     context: BindingContext,
-                                    kindFilter: JetScope.KindFilter,
+                                    kindFilter: DescriptorKindFilter,
                                     nameFilter: (Name) -> Boolean,
                                     visibilityFilter: (DeclarationDescriptor) -> Boolean): Collection<DeclarationDescriptor> {
         return getReferenceVariants(expression, context, kindFilter, nameFilter).filter(visibilityFilter)
@@ -44,7 +46,7 @@ public object TipsManager{
 
     private fun getReferenceVariants(expression: JetSimpleNameExpression,
                                      context: BindingContext,
-                                     kindFilter: JetScope.KindFilter,
+                                     kindFilter: DescriptorKindFilter,
                                      nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
         val receiverExpression = expression.getReceiverExpression()
         val parent = expression.getParent()
@@ -65,7 +67,7 @@ public object TipsManager{
                 val qualifier = context[BindingContext.QUALIFIER, receiverExpression]
                 if (qualifier != null) {
                     // It's impossible to add extension function for package or class (if it's class object, expression type is not null)
-                    qualifier.scope.getDescriptorsFiltered(kindFilter exclude JetScope.DescriptorKindExclude.Extensions, nameFilter).filterTo(descriptors, ::filterIfInfix)
+                    qualifier.scope.getDescriptorsFiltered(kindFilter exclude DescriptorKindExclude.Extensions, nameFilter).filterTo(descriptors, ::filterIfInfix)
                 }
 
                 val expressionType = context[BindingContext.EXPRESSION_TYPE, receiverExpression]
@@ -73,7 +75,7 @@ public object TipsManager{
                     val receiverValue = ExpressionReceiver(receiverExpression, expressionType)
                     val dataFlowInfo = context.getDataFlowInfo(expression)
 
-                    val mask = kindFilter.withoutKind(JetScope.NON_SINGLETON_CLASSIFIER).exclude(JetScope.DescriptorKindExclude.Extensions)
+                    val mask = kindFilter.withoutKind(DescriptorKindFilter.NON_SINGLETON_CLASSIFIERS_MASK).exclude(DescriptorKindExclude.Extensions)
                     for (variant in SmartCastUtils.getSmartCastVariants(receiverValue, context, dataFlowInfo)) {
                         variant.getMemberScope().getDescriptorsFiltered(mask, nameFilter).filterTo(descriptors, ::filterIfInfix)
                     }
@@ -86,7 +88,7 @@ public object TipsManager{
         }
 
         if (parent is JetImportDirective || parent is JetPackageDirective) {
-            val restrictedFilter = kindFilter.restrictedToKinds(JetScope.PACKAGE) ?: return listOf()
+            val restrictedFilter = kindFilter.restrictedToKinds(DescriptorKindFilter.PACKAGES_MASK) ?: return listOf()
             return resolutionScope.getDescriptorsFiltered(restrictedFilter, nameFilter)
         }
         else {
@@ -94,7 +96,7 @@ public object TipsManager{
 
             val receivers = resolutionScope.getImplicitReceiversHierarchy()
             receivers.flatMapTo(descriptorsSet) {
-                it.getType().getMemberScope().getDescriptorsFiltered(kindFilter exclude JetScope.DescriptorKindExclude.Extensions, nameFilter)
+                it.getType().getMemberScope().getDescriptorsFiltered(kindFilter exclude DescriptorKindExclude.Extensions, nameFilter)
             }
 
             val dataFlowInfo = context.getDataFlowInfo(expression)
@@ -117,10 +119,10 @@ public object TipsManager{
             context: BindingContext,
             dataFlowInfo: DataFlowInfo,
             isInfixCall: Boolean,
-            kindFilter: JetScope.KindFilter,
+            kindFilter: DescriptorKindFilter,
             nameFilter: (Name) -> Boolean
     ) {
-        if (!kindFilter.excludes.contains(JetScope.DescriptorKindExclude.Extensions)) {
+        if (!kindFilter.excludes.contains(DescriptorKindExclude.Extensions)) {
             resolutionScope.getDescriptorsFiltered(kindFilter, nameFilter)
                     .stream()
                     .filterIsInstance(javaClass<CallableDescriptor>())
@@ -141,6 +143,6 @@ public object TipsManager{
                                            context: BindingContext,
                                            nameFilter: (Name) -> Boolean): Collection<DeclarationDescriptor> {
         val resolutionScope = context[BindingContext.RESOLUTION_SCOPE, expression] ?: return listOf()
-        return resolutionScope.getDescriptorsFiltered(JetScope.KindFilter.PACKAGES, nameFilter)
+        return resolutionScope.getDescriptorsFiltered(DescriptorKindFilter.PACKAGES, nameFilter)
     }
 }

idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt

@@ -35,6 +35,7 @@ import com.intellij.psi.search.DelegatingGlobalSearchScope
 import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.jet.lang.resolve.scopes.JetScope
 import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptorKindExclude
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter
 
 class CompletionSessionConfiguration(
         val completeNonImportedDeclarations: Boolean,
@@ -94,7 +95,7 @@ abstract class CompletionSessionBase(protected val configuration: CompletionSess
 
     protected abstract fun doComplete()
 
-    protected fun getReferenceVariants(kindFilter: JetScope.KindFilter): Collection<DeclarationDescriptor> {
+    protected fun getReferenceVariants(kindFilter: DescriptorKindFilter): Collection<DeclarationDescriptor> {
         return TipsManager.getReferenceVariants(jetReference!!.expression,
                                                 bindingContext!!,
                                                 kindFilter,
@@ -141,10 +142,10 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
 
             if (completeReference) {
                 val kindMask = if (onlyTypes)
-                    JetScope.NON_SINGLETON_CLASSIFIER or JetScope.PACKAGE
+                    DescriptorKindFilter.NON_SINGLETON_CLASSIFIERS_MASK or DescriptorKindFilter.PACKAGES_MASK
                 else
-                    JetScope.ALL_KINDS_MASK
+                    DescriptorKindFilter.ALL_KINDS_MASK
-                addReferenceVariants(JetScope.KindFilter(kindMask))
+                addReferenceVariants(DescriptorKindFilter(kindMask))
 
                 if (onlyTypes) {
                     collector.addDescriptorElements(listOf(KotlinBuiltIns.getInstance().getUnit()), false)
@@ -195,7 +196,7 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
         return false
     }
 
-    private fun addReferenceVariants(kindFilter: JetScope.KindFilter) {
+    private fun addReferenceVariants(kindFilter: DescriptorKindFilter) {
         collector.addDescriptorElements(getReferenceVariants(kindFilter), suppressAutoInsertion = false)
     }
 }
@@ -204,7 +205,7 @@ class SmartCompletionSession(configuration: CompletionSessionConfiguration, para
 : CompletionSessionBase(configuration, parameters, resultSet) {
 
     // we do not include SAM-constructors because they are handled separately and adding them requires iterating of java classes
-    private val DESCRIPTOR_KIND_MASK = JetScope.KindFilter.VALUES exclude SamConstructorDescriptorKindExclude
+    private val DESCRIPTOR_KIND_MASK = DescriptorKindFilter.VALUES exclude SamConstructorDescriptorKindExclude
 
     override fun doComplete() {
         if (jetReference != null) {

idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/BaseJetVariableMacro.java

@@ -36,13 +36,17 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils;
 import org.jetbrains.jet.lang.resolve.calls.smartcasts.DataFlowInfo;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents;
 import org.jetbrains.jet.plugin.caches.resolve.ResolvePackage;
 import org.jetbrains.jet.plugin.codeInsight.TipsManager;
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
 
 import static org.jetbrains.jet.lang.resolve.bindingContextUtil.BindingContextUtilPackage.getDataFlowInfo;
 
@@ -74,7 +78,7 @@ public abstract class BaseJetVariableMacro extends Macro {
         DataFlowInfo dataFlowInfo = getDataFlowInfo(bindingContext, contextExpression);
 
         List<VariableDescriptor> filteredDescriptors = new ArrayList<VariableDescriptor>();
-        for (DeclarationDescriptor declarationDescriptor : scope.getDescriptors(JetScope.KindFilter.VARIABLES, JetScope.ALL_NAME_FILTER)) {
+        for (DeclarationDescriptor declarationDescriptor : scope.getDescriptors(DescriptorKindFilter.VARIABLES, JetScope.ALL_NAME_FILTER)) {
             if (declarationDescriptor instanceof VariableDescriptor) {
                 VariableDescriptor variableDescriptor = (VariableDescriptor) declarationDescriptor;
 

idea/src/org/jetbrains/jet/plugin/liveTemplates/macro/JetAnonymousSuperMacro.java

@@ -37,11 +37,15 @@ import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.plugin.JetBundle;
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
 
 public class JetAnonymousSuperMacro extends Macro {
     @Override
@@ -93,7 +97,7 @@ public class JetAnonymousSuperMacro extends Macro {
 
         List<PsiNamedElement> result = new ArrayList<PsiNamedElement>();
 
-        for (DeclarationDescriptor descriptor : scope.getDescriptors(JetScope.KindFilter.NON_SINGLETON_CLASSIFIERS, JetScope.ALL_NAME_FILTER)) {
+        for (DeclarationDescriptor descriptor : scope.getDescriptors(DescriptorKindFilter.NON_SINGLETON_CLASSIFIERS, JetScope.ALL_NAME_FILTER)) {
             if (!(descriptor instanceof ClassDescriptor)) continue;
             ClassDescriptor classDescriptor = (ClassDescriptor) descriptor;
             if (!classDescriptor.getModality().isOverridable()) continue;

idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java

@@ -40,6 +40,8 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils;
 import org.jetbrains.jet.lang.resolve.JetVisibilityChecker;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindExclude;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
@@ -408,7 +410,7 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith
             }
         };
         Collection<DeclarationDescriptor> variants = TipsManager.INSTANCE$.getReferenceVariants(
-                callNameExpression, bindingContext, new JetScope.KindFilter(JetScope.FUNCTION | JetScope.CLASSIFIERS_MASK, Collections.<JetScope.DescriptorKindExclude>emptyList()), nameFilter, visibilityFilter);
+                callNameExpression, bindingContext, new DescriptorKindFilter(DescriptorKindFilter.FUNCTIONS_MASK | DescriptorKindFilter.CLASSIFIERS_MASK, Collections.<DescriptorKindExclude>emptyList()), nameFilter, visibilityFilter);
 
         Collection<Pair<? extends DeclarationDescriptor, ResolveSessionForBodies>> itemsToShow = new ArrayList<Pair<? extends DeclarationDescriptor, ResolveSessionForBodies>>();
         for (DeclarationDescriptor variant : variants) {

js/js.translator/src/org/jetbrains/k2js/translate/utils/ManglingUtils.java

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.*;
@@ -144,7 +145,7 @@ public class ManglingUtils {
         int counter = 0;
 
         if (jetScope != null) {
-            Collection<DeclarationDescriptor> declarations = jetScope.getDescriptors(JetScope.KindFilter.CALLABLES, JetScope.ALL_NAME_FILTER);
+            Collection<DeclarationDescriptor> declarations = jetScope.getDescriptors(DescriptorKindFilter.CALLABLES, JetScope.ALL_NAME_FILTER);
             List<CallableMemberDescriptor>
                     overloadedFunctions = ContainerUtil.mapNotNull(declarations, new Function<DeclarationDescriptor, CallableMemberDescriptor>() {
                 @Override