DescriptorMatcher

compiler/backend/src/org/jetbrains/jet/cli/jvm/compiler/TipsManager.java

@@ -32,6 +32,7 @@ import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.AutoCastServiceImpl;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.JetScopeUtils;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
@@ -73,7 +74,8 @@ public final class TipsManager {
 
                     for (ReceiverDescriptor descriptor : variantsForExplicitReceiver) {
                         descriptors.addAll(includeExternalCallableExtensions(
-                                excludePrivateDescriptors(descriptor.getType().getMemberScope().getAllDescriptors()),
+                                // TODO: better predicate
+                                excludePrivateDescriptors(descriptor.getType().getMemberScope().getAllDescriptors(DescriptorPredicate.all())),
                                 resolutionScope, descriptor));
                     }
 
@@ -81,7 +83,8 @@ public final class TipsManager {
                 }
 
                 return includeExternalCallableExtensions(
-                        excludePrivateDescriptors(expressionType.getMemberScope().getAllDescriptors()),
+                        // TODO: better predicate
+                        excludePrivateDescriptors(expressionType.getMemberScope().getAllDescriptors(DescriptorPredicate.all())),
                         resolutionScope, new ExpressionReceiver(receiverExpression, expressionType));
             }
             return Collections.emptyList();
@@ -95,7 +98,8 @@ public final class TipsManager {
         JetScope resolutionScope = context.get(BindingContext.RESOLUTION_SCOPE, expression);
         if (resolutionScope != null) {
             if (expression.getParent() instanceof JetImportDirective || expression.getParent() instanceof JetNamespaceHeader) {
-                return excludeNonPackageDescriptors(resolutionScope.getAllDescriptors());
+                // TODO: better predicate
+                return excludeNonPackageDescriptors(resolutionScope.getAllDescriptors(DescriptorPredicate.all()));
             }
             else {
                 Collection<DeclarationDescriptor> descriptorsSet = Sets.newHashSet();
@@ -105,10 +109,12 @@ public final class TipsManager {
 
                 for (ReceiverDescriptor receiverDescriptor : result) {
                     JetType receiverType = receiverDescriptor.getType();
-                    descriptorsSet.addAll(receiverType.getMemberScope().getAllDescriptors());
+                    // TODO: better predicate
+                    descriptorsSet.addAll(receiverType.getMemberScope().getAllDescriptors(DescriptorPredicate.all()));
                 }
 
-                descriptorsSet.addAll(resolutionScope.getAllDescriptors());
+                // TODO: better predicate
+                descriptorsSet.addAll(resolutionScope.getAllDescriptors(DescriptorPredicate.all()));
                 return excludeNotCallableExtensions(excludePrivateDescriptors(descriptorsSet), resolutionScope);
             }
         }
@@ -119,7 +125,8 @@ public final class TipsManager {
     public static Collection<DeclarationDescriptor> getReferenceVariants(JetNamespaceHeader expression, BindingContext context) {
         JetScope resolutionScope = context.get(BindingContext.RESOLUTION_SCOPE, expression);
         if (resolutionScope != null) {
-            return excludeNonPackageDescriptors(resolutionScope.getAllDescriptors());
+            // TODO: better predicate
+            return excludeNonPackageDescriptors(resolutionScope.getAllDescriptors(DescriptorPredicate.all()));
         }
 
         return Collections.emptyList();

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

@@ -34,6 +34,7 @@ import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.objectweb.asm.AnnotationVisitor;
@@ -134,7 +135,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             v.visitOuterClass(typeMapper.mapType(container.getDefaultType(), MapTypeMode.IMPL).getInternalName(), null, null);
         }
 
-        for (DeclarationDescriptor declarationDescriptor : descriptor.getUnsubstitutedInnerClassesScope().getAllDescriptors()) {
+        for (DeclarationDescriptor declarationDescriptor : descriptor.getUnsubstitutedInnerClassesScope().getAllDescriptors(DescriptorPredicate.all())) {
             assert declarationDescriptor instanceof ClassDescriptor;
             ClassDescriptor innerClass = (ClassDescriptor) declarationDescriptor;
             // TODO: proper access
@@ -1024,19 +1025,17 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         final PropertyCodegen propertyCodegen = new PropertyCodegen(delegateContext, v, functionCodegen, state);
 
         ClassDescriptor classDescriptor = bindingContext.get(BindingContext.CLASS, toClass);
-        for (DeclarationDescriptor declaration : descriptor.getDefaultType().getMemberScope().getAllDescriptors()) {
+        for (DeclarationDescriptor declaration : descriptor.getDefaultType().getMemberScope().getAllDescriptors(DescriptorPredicate.callableMembers())) {
-            if (declaration instanceof CallableMemberDescriptor) {
+            CallableMemberDescriptor callableMemberDescriptor = (CallableMemberDescriptor) declaration;
-                CallableMemberDescriptor callableMemberDescriptor = (CallableMemberDescriptor) declaration;
+            if (callableMemberDescriptor.getKind() == CallableMemberDescriptor.Kind.DELEGATION) {
-                if (callableMemberDescriptor.getKind() == CallableMemberDescriptor.Kind.DELEGATION) {
+                Set<? extends CallableMemberDescriptor> overriddenDescriptors = callableMemberDescriptor.getOverriddenDescriptors();
-                    Set<? extends CallableMemberDescriptor> overriddenDescriptors = callableMemberDescriptor.getOverriddenDescriptors();
+                for (CallableMemberDescriptor overriddenDescriptor : overriddenDescriptors) {
-                    for (CallableMemberDescriptor overriddenDescriptor : overriddenDescriptors) {
+                    if (overriddenDescriptor.getContainingDeclaration() == classDescriptor) {
-                        if (overriddenDescriptor.getContainingDeclaration() == classDescriptor) {
+                        if (declaration instanceof PropertyDescriptor) {
-                            if (declaration instanceof PropertyDescriptor) {
+                            propertyCodegen.genDelegate((PropertyDescriptor) declaration, (PropertyDescriptor) overriddenDescriptor, field);
-                                propertyCodegen.genDelegate((PropertyDescriptor) declaration, (PropertyDescriptor) overriddenDescriptor, field);
+                        }
-                            }
+                        else if (declaration instanceof SimpleFunctionDescriptor) {
-                            else if (declaration instanceof SimpleFunctionDescriptor) {
+                            functionCodegen.genDelegate((SimpleFunctionDescriptor) declaration, overriddenDescriptor, field);
-                                functionCodegen.genDelegate((SimpleFunctionDescriptor) declaration, overriddenDescriptor, field);
-                            }
                         }
                     }
                 }
@@ -1070,11 +1069,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
         List<Pair<CallableMemberDescriptor, CallableMemberDescriptor>> r = Lists.newArrayList();
         
         root:
-        for (DeclarationDescriptor decl : classDescriptor.getDefaultType().getMemberScope().getAllDescriptors()) {
+        for (DeclarationDescriptor decl : classDescriptor.getDefaultType().getMemberScope().getAllDescriptors(DescriptorPredicate.callableMembers())) {
-            if (!(decl instanceof CallableMemberDescriptor)) {
-                continue;
-            }
-
             CallableMemberDescriptor callableMemberDescriptor = (CallableMemberDescriptor) decl;
             if (callableMemberDescriptor.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
                 continue;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java

@@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
 import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
@@ -187,7 +188,7 @@ public class IntrinsicMethods {
 
     private void declareIntrinsicStringMethods() {
         final ClassDescriptor stringClass = myStdLib.getString();
-        final Collection<DeclarationDescriptor> stringMembers = stringClass.getMemberScope(Collections.<TypeProjection>emptyList()).getAllDescriptors();
+        final Collection<DeclarationDescriptor> stringMembers = stringClass.getMemberScope(Collections.<TypeProjection>emptyList()).getAllDescriptors(DescriptorPredicate.all());
         final PsiClass stringPsiClass = JavaPsiFacade.getInstance(myProject).findClass(
                 "java.lang.String",
                 new DelegatingGlobalSearchScope(ProjectScope.getLibrariesScope(myProject)) {

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassOrPackageScope.java

@@ -24,6 +24,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicateUtils;
 import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl;
 
 import java.util.Collection;
@@ -69,7 +71,7 @@ public abstract class JavaClassOrPackageScope extends JetScopeImpl {
 
     @NotNull
     @Override
-    public Collection<DeclarationDescriptor> getAllDescriptors() {
+    public Collection<DeclarationDescriptor> getAllDescriptors(@NotNull DescriptorPredicate predicate) {
         if (allDescriptors == null) {
             allDescriptors = Sets.newHashSet();
 
@@ -127,6 +129,6 @@ public abstract class JavaClassOrPackageScope extends JetScopeImpl {
             }
         }
 
-        return allDescriptors;
+        return DescriptorPredicateUtils.filter(allDescriptors, predicate);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java

@@ -20,6 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
@@ -104,7 +105,7 @@ public abstract class AbstractScopeAdapter implements JetScope {
 
     @NotNull
     @Override
-    public Collection<DeclarationDescriptor> getAllDescriptors() {
+    public Collection<DeclarationDescriptor> getAllDescriptors(@NotNull DescriptorPredicate predicate) {
-        return getWorkerScope().getAllDescriptors();
+        return getWorkerScope().getAllDescriptors(predicate);
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java

@@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.resolve;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.types.JetType;
 
 import javax.inject.Inject;
@@ -67,7 +68,7 @@ public class DelegationResolver {
                 JetDelegatorByExpressionSpecifier specifier = (JetDelegatorByExpressionSpecifier) delegationSpecifier;
                 JetType type = trace.get(BindingContext.TYPE, specifier.getTypeReference());
                 if (type != null) {
-                    for (DeclarationDescriptor declarationDescriptor : type.getMemberScope().getAllDescriptors()) {
+                    for (DeclarationDescriptor declarationDescriptor : type.getMemberScope().getAllDescriptors(DescriptorPredicate.callableMembers())) {
                         if (declarationDescriptor instanceof PropertyDescriptor) {
                             PropertyDescriptor propertyDescriptor = (PropertyDescriptor) declarationDescriptor;
                             if (propertyDescriptor.getModality().isOverridable()) {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java

@@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
@@ -238,7 +239,7 @@ public class OverrideResolver {
 
     private static List<CallableMemberDescriptor> getCallableMembersFromType(JetScope scope) {
         List<CallableMemberDescriptor> r = Lists.newArrayList();
-        for (DeclarationDescriptor decl : scope.getAllDescriptors()) {
+        for (DeclarationDescriptor decl : scope.getAllDescriptors(DescriptorPredicate.all())) {
             if (decl instanceof PropertyDescriptor || decl instanceof SimpleFunctionDescriptor) {
                 r.add((CallableMemberDescriptor) decl);
             }
@@ -332,7 +333,7 @@ public class OverrideResolver {
     public static Multimap<CallableMemberDescriptor, CallableMemberDescriptor> collectSuperMethods(MutableClassDescriptor classDescriptor) {
         Set<CallableMemberDescriptor> inheritedFunctions = Sets.newLinkedHashSet();
         for (JetType supertype : classDescriptor.getSupertypes()) {
-            for (DeclarationDescriptor descriptor : supertype.getMemberScope().getAllDescriptors()) {
+            for (DeclarationDescriptor descriptor : supertype.getMemberScope().getAllDescriptors(DescriptorPredicate.all())) {
                 if (descriptor instanceof CallableMemberDescriptor) {
                     CallableMemberDescriptor memberDescriptor = (CallableMemberDescriptor) descriptor;
                     inheritedFunctions.add(memberDescriptor);

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

@@ -16,6 +16,7 @@
 
 package org.jetbrains.jet.lang.resolve.lazy;
 
+import com.google.common.collect.Collections2;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
@@ -25,6 +26,8 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicateUtils;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
@@ -192,7 +195,9 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
 
     @NotNull
     @Override
-    public Collection<DeclarationDescriptor> getAllDescriptors() {
+    public Collection<DeclarationDescriptor> getAllDescriptors(@NotNull DescriptorPredicate predicate) {
+        // TODO: cache only what matches predicate
+
         for (JetDeclaration declaration : declarationProvider.getAllDeclarations()) {
             if (declaration instanceof JetClassOrObject) {
                 JetClassOrObject classOrObject = (JetClassOrObject) declaration;
@@ -222,7 +227,8 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
         }
         addExtraDescriptors();
         allDescriptorsComputed = true;
-        return allDescriptors;
+
+        return DescriptorPredicateUtils.filter(allDescriptors, predicate);
     }
 
     protected abstract void addExtraDescriptors();

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

@@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorResolver;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.DeferredType;
@@ -86,7 +87,7 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
                     public void conflict(@NotNull CallableMemberDescriptor fromSuper, @NotNull CallableMemberDescriptor fromCurrent) {
                         BindingTrace trace = resolveSession.getTrace();
                         JetDeclaration declaration = (JetDeclaration) BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(),
-                                                                                                                  fromCurrent);
+                                fromCurrent);
                         assert declaration != null : "fromCurrent can not be a fake override";
                         trace.report(Errors.CONFLICTING_OVERLOADS.on(declaration, fromCurrent, fromCurrent.getContainingDeclaration().getName().getName()));
                     }
@@ -134,7 +135,7 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
     @Override
     protected void addExtraDescriptors() {
         for (JetType supertype : thisDescriptor.getTypeConstructor().getSupertypes()) {
-            for (DeclarationDescriptor descriptor : supertype.getMemberScope().getAllDescriptors()) {
+            for (DeclarationDescriptor descriptor : supertype.getMemberScope().getAllDescriptors(DescriptorPredicate.callableMembers())) {
                 if (descriptor instanceof FunctionDescriptor) {
                     getFunctions(descriptor.getName());
                 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java

@@ -157,11 +157,11 @@ public class ChainedScope implements JetScope {
 
     @NotNull
     @Override
-    public Collection<DeclarationDescriptor> getAllDescriptors() {
+    public Collection<DeclarationDescriptor> getAllDescriptors(@NotNull DescriptorPredicate predicate) {
         if (allDescriptors == null) {
             allDescriptors = Sets.newHashSet();
             for (JetScope scope : scopeChain) {
-                allDescriptors.addAll(scope.getAllDescriptors());
+                allDescriptors.addAll(scope.getAllDescriptors(DescriptorPredicate.all()));
             }
         }
         return allDescriptors;

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/DescriptorPredicate.java

@@ -0,0 +1,216 @@
+/*
+ * Copyright 2010-2012 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.jet.lang.resolve.scopes;
+
+import com.google.common.base.Predicate;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.resolve.name.Name;
+
+/**
+ * @author Stepan Koltsov
+ */
+public abstract class DescriptorPredicate {
+
+    public boolean includeAll() {
+        return this instanceof All;
+    }
+
+    public abstract boolean includeName(@NotNull Name name);
+
+    public enum DescriptorKind {
+        CLASS,
+        CALLABLE_MEMBER,
+        CALLABLE_NON_MEMBER,
+        NAMESPACE,
+        OTHER,
+        ;
+
+        public boolean isCallable() {
+            return this == CALLABLE_MEMBER || this == CALLABLE_NON_MEMBER;
+        }
+    }
+
+    public abstract boolean includeKind(@NotNull DescriptorKind kind);
+
+    private static DescriptorKind descriptorKind(@NotNull DeclarationDescriptor descriptor) {
+        if (descriptor instanceof CallableMemberDescriptor) {
+            return DescriptorKind.CALLABLE_MEMBER;
+        }
+        else if (descriptor instanceof CallableDescriptor) {
+            return DescriptorKind.CALLABLE_NON_MEMBER;
+        }
+        else if (descriptor instanceof ClassDescriptor) {
+            return DescriptorKind.CLASS;
+        }
+        else if (descriptor instanceof NamespaceDescriptor) {
+            return DescriptorKind.NAMESPACE;
+        }
+        else {
+            return DescriptorKind.OTHER;
+        }
+    }
+
+    /**
+     * Should be called only if includeKind(CALLABLE_MEMBER) returned true.
+     */
+    public abstract boolean includeExtension(boolean extension);
+
+
+    public boolean include(@NotNull DeclarationDescriptor descriptor) {
+        if (!includeKind(descriptorKind(descriptor))) {
+            return false;
+        }
+
+        if (descriptor instanceof CallableMemberDescriptor) {
+            CallableMemberDescriptor callable = (CallableMemberDescriptor) descriptor;
+            boolean extension = callable.getReceiverParameter().exists();
+            if (!includeExtension(extension)) {
+                return false;
+            }
+        }
+
+        if (!includeName(descriptor.getName())) {
+            return false;
+        }
+
+        return true;
+    }
+
+
+    private static class All extends DescriptorPredicate {
+        private static final All instance = new All();
+
+        @Override
+        public boolean include(@NotNull DeclarationDescriptor descriptor) {
+            return true;
+        }
+
+        @Override
+        public boolean includeKind(@NotNull DescriptorKind kind) {
+            return true;
+        }
+
+        @Override
+        public boolean includeName(@NotNull Name name) {
+            return true;
+        }
+
+        @Override
+        public boolean includeExtension(boolean extension) {
+            return true;
+        }
+    }
+
+    public static DescriptorPredicate all() {
+        return All.instance;
+    }
+
+
+    private static class HasName extends DescriptorPredicate {
+        @NotNull
+        private final Name required;
+
+        private HasName(@NotNull Name required) {
+            this.required = required;
+        }
+
+        @Override
+        public boolean includeKind(@NotNull DescriptorKind kind) {
+            return true;
+        }
+
+        @Override
+        public boolean includeExtension(boolean extension) {
+            return true;
+        }
+
+        @Override
+        public boolean include(@NotNull DeclarationDescriptor descriptor) {
+            return includeName(descriptor.getName());
+        }
+
+        @Override
+        public boolean includeName(@NotNull Name name) {
+            return required.equals(name);
+        }
+
+    }
+
+    public static DescriptorPredicate hasName(@NotNull Name name) {
+        return new HasName(name);
+    }
+
+
+    private static class CallableMembers extends DescriptorPredicate {
+        public static final CallableMembers instance = new CallableMembers();
+
+        @Override
+        public boolean includeName(@NotNull Name name) {
+            return true;
+        }
+
+        @Override
+        public boolean includeExtension(boolean extension) {
+            return true;
+        }
+
+        @Override
+        public boolean include(@NotNull DeclarationDescriptor descriptor) {
+            return descriptor instanceof CallableMemberDescriptor;
+        }
+
+        @Override
+        public boolean includeKind(@NotNull DescriptorKind kind) {
+            return kind == DescriptorKind.CALLABLE_MEMBER;
+        }
+
+    }
+
+    public static DescriptorPredicate callableMembers() {
+        return CallableMembers.instance;
+    }
+
+
+    private static class Extension extends CallableMembers {
+        private static final Extension instance = new Extension();
+
+        @Override
+        public boolean includeExtension(boolean extension) {
+            return extension;
+        }
+    }
+
+    public static DescriptorPredicate extension() {
+        return Extension.instance;
+    }
+
+
+    public Predicate<DeclarationDescriptor> asGuavaPredicate() {
+        return new Predicate<DeclarationDescriptor>() {
+            @Override
+            public boolean apply(@NotNull DeclarationDescriptor descriptor) {
+                return include(descriptor);
+            }
+        };
+    }
+
+}

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/DescriptorPredicateUtils.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2012 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.jet.lang.resolve.scopes;
+
+import com.google.common.collect.Collections2;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+
+import java.util.Collection;
+
+/**
+ * @author Stepan Koltsov
+ */
+public class DescriptorPredicateUtils {
+
+    public static Collection<DeclarationDescriptor> filter(
+            @NotNull Collection<DeclarationDescriptor> descriptors,
+            @NotNull DescriptorPredicate predicate) {
+        if (predicate.includeAll()) {
+            return descriptors;
+        }
+        else {
+            return Collections2.filter(descriptors, predicate.asGuavaPredicate());
+        }
+    }
+
+}

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.java

@@ -72,8 +72,9 @@ public class InnerClassesScopeWrapper extends JetScopeImpl {
 
     @NotNull
     @Override
-    public Collection<DeclarationDescriptor> getAllDescriptors() {
+    public Collection<DeclarationDescriptor> getAllDescriptors(@NotNull DescriptorPredicate predicate) {
-        Collection<DeclarationDescriptor> allDescriptors = actualScope.getAllDescriptors();
+        // TODO: use better predicate
+        Collection<DeclarationDescriptor> allDescriptors = actualScope.getAllDescriptors(predicate);
         return Collections2.filter(allDescriptors, new Predicate<DeclarationDescriptor>() {
             @Override
             public boolean apply(@Nullable DeclarationDescriptor descriptor) {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java

@@ -84,7 +84,7 @@ public interface JetScope {
      * @return All visible descriptors from current scope.
      */
     @NotNull
-    Collection<DeclarationDescriptor> getAllDescriptors();
+    Collection<DeclarationDescriptor> getAllDescriptors(@NotNull DescriptorPredicate predicate);
 
     /**
      * @return EFFECTIVE implicit receiver at this point (may be corresponding to an outer scope)

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.java

@@ -88,7 +88,7 @@ public abstract class JetScopeImpl implements JetScope {
 
     @NotNull
     @Override
-    public Collection<DeclarationDescriptor> getAllDescriptors() {
+    public Collection<DeclarationDescriptor> getAllDescriptors(@NotNull DescriptorPredicate predicate) {
         return Collections.emptyList();
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeUtils.java

@@ -53,18 +53,8 @@ public final class JetScopeUtils {
      * @param scope Scope for query extensions.
      * @return extension descriptors.
      */
+    @SuppressWarnings("unchecked")
     public static Collection<CallableDescriptor> getAllExtensions(@NotNull JetScope scope) {
-        final Set<CallableDescriptor> result = Sets.newHashSet();
+        return (Collection<CallableDescriptor>) (Object) scope.getAllDescriptors(DescriptorPredicate.extension());
-
-        for (DeclarationDescriptor descriptor : scope.getAllDescriptors()) {
-            if (descriptor instanceof CallableDescriptor) {
-                CallableDescriptor callDescriptor = (CallableDescriptor) descriptor;
-                if (callDescriptor.getReceiverParameter().exists()) {
-                    result.add(callDescriptor);
-                }
-            }
-        }
-
-        return result;
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java

@@ -149,10 +149,10 @@ public class SubstitutingScope implements JetScope {
 
     @NotNull
     @Override
-    public Collection<DeclarationDescriptor> getAllDescriptors() {
+    public Collection<DeclarationDescriptor> getAllDescriptors(@NotNull DescriptorPredicate predicate) {
         if (allDescriptors == null) {
             allDescriptors = Sets.newHashSet();
-            for (DeclarationDescriptor descriptor : workerScope.getAllDescriptors()) {
+            for (DeclarationDescriptor descriptor : workerScope.getAllDescriptors(DescriptorPredicate.all())) {
                 DeclarationDescriptor substitute = substitute(descriptor);
 //                assert substitute != null : descriptor;
                 if (substitute != null) {

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

@@ -126,7 +126,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
 
     @NotNull
     @Override
-    public Collection<DeclarationDescriptor> getAllDescriptors() {
+    public Collection<DeclarationDescriptor> getAllDescriptors(@NotNull DescriptorPredicate predicate) {
         checkMayRead();
 
         if (!allDescriptorsDone) {
@@ -135,12 +135,12 @@ public class WritableScopeImpl extends WritableScopeWithImports {
             // make sure no descriptors added to allDescriptors collection
             changeLockLevel(LockLevel.READING);
 
-            allDescriptors.addAll(getWorkerScope().getAllDescriptors());
+            allDescriptors.addAll(getWorkerScope().getAllDescriptors(DescriptorPredicate.all()));
             for (JetScope imported : getImports()) {
-                allDescriptors.addAll(imported.getAllDescriptors());
+                allDescriptors.addAll(imported.getAllDescriptors(DescriptorPredicate.all()));
             }
         }
-        return allDescriptors;
+        return DescriptorPredicateUtils.filter(allDescriptors, predicate);
     }
 
     @NotNull

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

@@ -283,19 +283,19 @@ public class WriteThroughScope extends WritableScopeWithImports {
 
     @NotNull
     @Override
-    public Collection<DeclarationDescriptor> getAllDescriptors() {
+    public Collection<DeclarationDescriptor> getAllDescriptors(@NotNull DescriptorPredicate predicate) {
         checkMayRead();
 
         if (allDescriptors == null) {
             allDescriptors = Lists.newArrayList();
-            allDescriptors.addAll(writableWorker.getAllDescriptors());
+            allDescriptors.addAll(writableWorker.getAllDescriptors(DescriptorPredicate.all()));
-            allDescriptors.addAll(getWorkerScope().getAllDescriptors());
+            allDescriptors.addAll(getWorkerScope().getAllDescriptors(DescriptorPredicate.all()));
 
             for (JetScope imported : getImports()) {
-                allDescriptors.addAll(imported.getAllDescriptors());
+                allDescriptors.addAll(imported.getAllDescriptors(DescriptorPredicate.all()));
             }
         }
-        return allDescriptors;
+        return DescriptorPredicateUtils.filter(allDescriptors, predicate);
     }
 
     @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java

@@ -22,6 +22,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.error.ErrorSimpleFunctionDescriptorImpl;
@@ -112,7 +113,7 @@ public class ErrorUtils {
 
         @NotNull
         @Override
-        public Collection<DeclarationDescriptor> getAllDescriptors() {
+        public Collection<DeclarationDescriptor> getAllDescriptors(@NotNull DescriptorPredicate predicate) {
             return Collections.emptyList();
         }
 

compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardClasses.java

@@ -499,6 +499,6 @@ public class JetStandardClasses {
 
     @NotNull
     public static Collection<DeclarationDescriptor> getAllStandardClasses() {
-        return STANDARD_CLASSES.getAllDescriptors();
+        return STANDARD_CLASSES.getAllDescriptors(DescriptorPredicate.all());
     }
 }

compiler/tests/org/jetbrains/jet/jvm/compiler/NamespaceComparator.java

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver;
 import org.jetbrains.jet.lang.types.ErrorUtils;
@@ -98,13 +99,13 @@ public class NamespaceComparator {
 
         sb.append("namespace " + nsa.getName() + "\n\n");
 
-        Assert.assertTrue(!nsa.getMemberScope().getAllDescriptors().isEmpty());
+        Assert.assertTrue(!nsa.getMemberScope().getAllDescriptors(DescriptorPredicate.all()).isEmpty());
 
         Set<Name> classifierNames = new HashSet<Name>();
         Set<Name> propertyNames = new HashSet<Name>();
         Set<Name> functionNames = new HashSet<Name>();
 
-        for (DeclarationDescriptor ad : nsa.getMemberScope().getAllDescriptors()) {
+        for (DeclarationDescriptor ad : nsa.getMemberScope().getAllDescriptors(DescriptorPredicate.all())) {
             if (ad instanceof ClassifierDescriptor) {
                 classifierNames.add(ad.getName());
             }
@@ -563,7 +564,7 @@ public class NamespaceComparator {
             }
 
             JetScope memberScope = klass.getMemberScope(typeArguments);
-            for (DeclarationDescriptor member : memberScope.getAllDescriptors()) {
+            for (DeclarationDescriptor member : memberScope.getAllDescriptors(DescriptorPredicate.all())) {
                 if (!includeObject) {
                     if (member.getName().getName().matches("equals|hashCode|finalize|wait|notify(All)?|toString|clone|getClass")) {
                         continue;

compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java

@@ -36,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.java.CompilerDependencies;
 import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -196,7 +197,7 @@ public class ResolveDescriptorsFromExternalLibraries {
                     if (clazz == null) {
                         throw new IllegalStateException("class not found by name " + className + " in " + libDescription);
                     }
-                    clazz.getDefaultType().getMemberScope().getAllDescriptors();
+                    clazz.getDefaultType().getMemberScope().getAllDescriptors(DescriptorPredicate.all());
                 }
                 catch (Exception e) {
                     System.err.println("failed to resolve " + className);

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java

@@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 
 import java.io.File;
 import java.io.IOException;
@@ -101,6 +102,6 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
     }
 
     private NamespaceDescriptor theOnlySubPackage(NamespaceDescriptor namespace) {
-        return (NamespaceDescriptor) namespace.getMemberScope().getAllDescriptors().iterator().next();
+        return (NamespaceDescriptor) namespace.getMemberScope().getAllDescriptors(DescriptorPredicate.all()).iterator().next();
     }
 }

idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java

@@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.resolve.DescriptorRenderer;
 
 import java.util.*;
@@ -89,7 +90,8 @@ class DecompiledDataFactory {
             NamespaceDescriptor nd = myJavaDescriptorResolver.resolveNamespace(new FqName(packageName), DescriptorSearchRule.INCLUDE_KOTLIN);
 
             if (nd != null) {
-                for (DeclarationDescriptor member : sortDeclarations(nd.getMemberScope().getAllDescriptors())) {
+                // TODO: better predicate
+                for (DeclarationDescriptor member : sortDeclarations(nd.getMemberScope().getAllDescriptors(DescriptorPredicate.all()))) {
                     if (member instanceof ClassDescriptor || member instanceof NamespaceDescriptor) {
                         continue;
                     }
@@ -155,7 +157,7 @@ class DecompiledDataFactory {
                 myBuilder.append(subindent).append("class ");
                 appendDescriptor(classDescriptor.getClassObjectDescriptor(), subindent);
             }
-            for (DeclarationDescriptor member : sortDeclarations(classDescriptor.getDefaultType().getMemberScope().getAllDescriptors())) {
+            for (DeclarationDescriptor member : sortDeclarations(classDescriptor.getDefaultType().getMemberScope().getAllDescriptors(DescriptorPredicate.all()))) {
                 if (member.getContainingDeclaration() != descriptor) {
                     continue;
                 }

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

@@ -36,6 +36,7 @@ import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade;
@@ -72,7 +73,8 @@ public abstract class BaseJetVariableMacro extends Macro {
         ExpressionTypingServices callResolverContext = new InjectorForMacros(project).getExpressionTypingServices();
 
         List<VariableDescriptor> filteredDescriptors = new ArrayList<VariableDescriptor>();
-        for (DeclarationDescriptor declarationDescriptor : scope.getAllDescriptors()) {
+        // TODO: better predicate
+        for (DeclarationDescriptor declarationDescriptor : scope.getAllDescriptors(DescriptorPredicate.all())) {
             if (declarationDescriptor instanceof VariableDescriptor) {
                 VariableDescriptor variableDescriptor = (VariableDescriptor) declarationDescriptor;
                 if (isSuitable(variableDescriptor, scope, project, callResolverContext)) {

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

@@ -37,6 +37,7 @@ 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.BindingContextUtils;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.plugin.JetBundle;
 import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade;
@@ -101,7 +102,8 @@ public class JetAnonymousSuperMacro extends Macro {
 
         List<PsiNamedElement> result = new ArrayList<PsiNamedElement>();
 
-        for (DeclarationDescriptor descriptor : scope.getAllDescriptors()) {
+        // TODO: better predicate
+        for (DeclarationDescriptor descriptor : scope.getAllDescriptors(DescriptorPredicate.all())) {
             if (!(descriptor instanceof ClassDescriptor)) continue;
             ClassDescriptor classDescriptor = (ClassDescriptor) descriptor;
             if (!classDescriptor.getModality().isOverridable()) continue;

idea/src/org/jetbrains/jet/plugin/references/StandardLibraryReferenceResolver.java

@@ -36,6 +36,7 @@ import org.jetbrains.jet.lang.psi.JetReferenceExpression;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
@@ -139,7 +140,7 @@ public class StandardLibraryReferenceResolver extends AbstractProjectComponent {
                 return null;
             }
             String renderedOriginal = DescriptorRenderer.TEXT.render(originalDescriptor);
-            for (DeclarationDescriptor member : memberScope.getAllDescriptors()) {
+            for (DeclarationDescriptor member : memberScope.getAllDescriptors(DescriptorPredicate.all())) {
                 if (renderedOriginal.equals(DescriptorRenderer.TEXT.render(member).replace(TUPLE0_FQ_NAME.getFqName(),
                                                                                            JetStandardClasses.UNIT_ALIAS.getName()))) {
                     return member;

idea/tests/org/jetbrains/jet/plugin/references/StandardLibraryReferenceResolverTest.java

@@ -23,6 +23,7 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitorEmptyBodies;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
 
@@ -88,13 +89,13 @@ public class StandardLibraryReferenceResolverTest extends ResolveTestCase {
             @Override
             public Void visitClassDescriptor(ClassDescriptor descriptor, Void data) {
                 descriptors.add(descriptor);
-                return visitDescriptors(descriptor.getDefaultType().getMemberScope().getAllDescriptors());
+                return visitDescriptors(descriptor.getDefaultType().getMemberScope().getAllDescriptors(DescriptorPredicate.all()));
             }
 
             @Override
             public Void visitNamespaceDescriptor(NamespaceDescriptor descriptor, Void data) {
                 descriptors.add(descriptor);
-                return visitDescriptors(descriptor.getMemberScope().getAllDescriptors());
+                return visitDescriptors(descriptor.getMemberScope().getAllDescriptors(DescriptorPredicate.all()));
             }
 
             @Override

js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/Intrinsics.java

@@ -22,6 +22,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.JetStandardClasses;
@@ -193,7 +194,7 @@ public final class Intrinsics {
 
     private void declareOperatorIntrinsics() {
         IntrinsicDeclarationVisitor visitor = new IntrinsicDeclarationVisitor();
-        for (DeclarationDescriptor descriptor : library.getLibraryScope().getAllDescriptors()) {
+        for (DeclarationDescriptor descriptor : library.getLibraryScope().getAllDescriptors(DescriptorPredicate.all())) {
             //noinspection NullableProblems
             descriptor.accept(visitor, null);
         }
@@ -231,7 +232,7 @@ public final class Intrinsics {
         @Override
         public Void visitClassDescriptor(@NotNull ClassDescriptor descriptor, @Nullable Void nothing) {
             for (DeclarationDescriptor memberDescriptor :
-                descriptor.getDefaultType().getMemberScope().getAllDescriptors()) {
+                descriptor.getDefaultType().getMemberScope().getAllDescriptors(DescriptorPredicate.all())) {
                 //noinspection NullableProblems
                 memberDescriptor.accept(this, null);
             }

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

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
@@ -229,7 +230,7 @@ public final class JsDescriptorUtils {
     @NotNull
     public static List<DeclarationDescriptor> getContainedDescriptorsWhichAreNotPredefined(@NotNull NamespaceDescriptor namespace) {
         List<DeclarationDescriptor> result = Lists.newArrayList();
-        for (DeclarationDescriptor descriptor : namespace.getMemberScope().getAllDescriptors()) {
+        for (DeclarationDescriptor descriptor : namespace.getMemberScope().getAllDescriptors(DescriptorPredicate.all())) {
             if (!AnnotationsUtils.isPredefinedObject(descriptor)) {
                 result.add(descriptor);
             }