Revert "use the power of DescriptorPredicate in completion"

This reverts commit 65b74a19b4.

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

@@ -32,9 +32,9 @@ 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.name.NamePredicate;
 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;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.JetType;
@@ -52,8 +52,7 @@ public final class TipsManager {
     }
 
     @NotNull
-    public static Collection<DeclarationDescriptor> getReferenceVariants(
+    public static Collection<DeclarationDescriptor> getReferenceVariants(JetSimpleNameExpression expression, BindingContext context) {
-            JetSimpleNameExpression expression, BindingContext context, @NotNull NamePredicate name) {
         JetExpression receiverExpression = expression.getReceiverExpression();
         if (receiverExpression != null) {
             // Process as call expression
@@ -75,30 +74,32 @@ public final class TipsManager {
 
                     for (ReceiverDescriptor descriptor : variantsForExplicitReceiver) {
                         descriptors.addAll(includeExternalCallableExtensions(
-                                excludePrivateDescriptors(descriptor.getType().getMemberScope().getAllDescriptors(DescriptorPredicate.hasName(name))),
+                                // TODO: better predicate
-                                resolutionScope, descriptor, name));
+                                excludePrivateDescriptors(descriptor.getType().getMemberScope().getAllDescriptors(DescriptorPredicate.all())),
+                                resolutionScope, descriptor));
                     }
 
                     return descriptors;
                 }
 
                 return includeExternalCallableExtensions(
-                        excludePrivateDescriptors(expressionType.getMemberScope().getAllDescriptors(DescriptorPredicate.hasName(name))),
+                        // TODO: better predicate
-                        resolutionScope, new ExpressionReceiver(receiverExpression, expressionType), name);
+                        excludePrivateDescriptors(expressionType.getMemberScope().getAllDescriptors(DescriptorPredicate.all())),
+                        resolutionScope, new ExpressionReceiver(receiverExpression, expressionType));
             }
             return Collections.emptyList();
         }
         else {
-            return getVariantsNoReceiver(expression, context, name);
+            return getVariantsNoReceiver(expression, context);
         }
     }
 
-    public static Collection<DeclarationDescriptor> getVariantsNoReceiver(
+    public static Collection<DeclarationDescriptor> getVariantsNoReceiver(JetExpression expression, BindingContext context) {
-            JetExpression expression, BindingContext context, @NotNull NamePredicate name) {
         JetScope resolutionScope = context.get(BindingContext.RESOLUTION_SCOPE, expression);
         if (resolutionScope != null) {
             if (expression.getParent() instanceof JetImportDirective || expression.getParent() instanceof JetNamespaceHeader) {
-                return resolutionScope.getAllDescriptors(DescriptorPredicate.namespaces(name));
+                // TODO: better predicate
+                return excludeNonPackageDescriptors(resolutionScope.getAllDescriptors(DescriptorPredicate.all()));
             }
             else {
                 Collection<DeclarationDescriptor> descriptorsSet = Sets.newHashSet();
@@ -108,11 +109,13 @@ public final class TipsManager {
 
                 for (ReceiverDescriptor receiverDescriptor : result) {
                     JetType receiverType = receiverDescriptor.getType();
-                    descriptorsSet.addAll(receiverType.getMemberScope().getAllDescriptors(DescriptorPredicate.hasName(name)));
+                    // TODO: better predicate
+                    descriptorsSet.addAll(receiverType.getMemberScope().getAllDescriptors(DescriptorPredicate.all()));
                 }
 
-                descriptorsSet.addAll(resolutionScope.getAllDescriptors(DescriptorPredicate.hasName(name)));
+                // TODO: better predicate
-                return excludeNotCallableExtensions(excludePrivateDescriptors(descriptorsSet), resolutionScope, name);
+                descriptorsSet.addAll(resolutionScope.getAllDescriptors(DescriptorPredicate.all()));
+                return excludeNotCallableExtensions(excludePrivateDescriptors(descriptorsSet), resolutionScope);
             }
         }
         return Collections.emptyList();
@@ -145,9 +148,7 @@ public final class TipsManager {
     }
 
     public static Collection<DeclarationDescriptor> excludeNotCallableExtensions(
-            @NotNull Collection<? extends DeclarationDescriptor> descriptors,
+            @NotNull Collection<? extends DeclarationDescriptor> descriptors, @NotNull final JetScope scope
-            @NotNull final JetScope scope,
-            @NotNull NamePredicate name
     ) {
         final Set<DeclarationDescriptor> descriptorsSet = Sets.newHashSet(descriptors);
 
@@ -155,10 +156,9 @@ public final class TipsManager {
         scope.getImplicitReceiversHierarchy(result);
 
         descriptorsSet.removeAll(
-                Collections2.filter(scope.getAllDescriptors(DescriptorPredicate.extension(name)), new Predicate<DeclarationDescriptor>() {
+                Collections2.filter(JetScopeUtils.getAllExtensions(scope), new Predicate<CallableDescriptor>() {
                     @Override
-                    public boolean apply(DeclarationDescriptor declarationDescriptor) {
+                    public boolean apply(CallableDescriptor callableDescriptor) {
-                        CallableDescriptor callableDescriptor = (CallableDescriptor) declarationDescriptor;
                         if (!callableDescriptor.getReceiverParameter().exists()) {
                             return false;
                         }
@@ -187,8 +187,7 @@ public final class TipsManager {
     private static Set<DeclarationDescriptor> includeExternalCallableExtensions(
             @NotNull Collection<DeclarationDescriptor> descriptors,
             @NotNull final JetScope externalScope,
-            @NotNull final ReceiverDescriptor receiverDescriptor,
+            @NotNull final ReceiverDescriptor receiverDescriptor
-            @NotNull NamePredicate name
     ) {
         // It's impossible to add extension function for namespace
         JetType receiverType = receiverDescriptor.getType();
@@ -199,13 +198,13 @@ public final class TipsManager {
         Set<DeclarationDescriptor> descriptorsSet = Sets.newHashSet(descriptors);
 
         descriptorsSet.addAll(
-                Collections2.filter(externalScope.getAllDescriptors(DescriptorPredicate.extension(name)),
+                Collections2.filter(JetScopeUtils.getAllExtensions(externalScope),
-                                  new Predicate<DeclarationDescriptor>() {
+                                                  new Predicate<CallableDescriptor>() {
-                                      @Override
+                                                      @Override
-                                      public boolean apply(DeclarationDescriptor callableDescriptor) {
+                                                      public boolean apply(CallableDescriptor callableDescriptor) {
-                                          return ExpressionTypingUtils.checkIsExtensionCallable(receiverDescriptor, (CallableDescriptor) callableDescriptor);
+                                                          return ExpressionTypingUtils.checkIsExtensionCallable(receiverDescriptor, callableDescriptor);
-                                      }
+                                                      }
-                                  }));
+                                                  }));
 
         return descriptorsSet;
     }

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

@@ -128,9 +128,9 @@ public abstract class DescriptorPredicate {
 
     private static class HasName extends DescriptorPredicate {
         @NotNull
-        private final NamePredicate required;
+        private final Name required;
 
-        private HasName(@NotNull NamePredicate required) {
+        private HasName(@NotNull Name required) {
             this.required = required;
         }
 
@@ -151,24 +151,18 @@ public abstract class DescriptorPredicate {
 
         @Override
         public boolean includeName(@NotNull Name name) {
-            return required.matches(name);
+            return required.equals(name);
         }
 
     }
 
-    public static DescriptorPredicate hasName(@NotNull NamePredicate required) {
+    public static DescriptorPredicate hasName(@NotNull Name name) {
-        return new HasName(required);
+        return new HasName(name);
     }
 
 
-    private static class MembersOfType extends DescriptorPredicate {
+    private static class CallableMembers extends DescriptorPredicate {
-
+        public static final CallableMembers instance = new CallableMembers();
-        @NotNull
-        private final DescriptorKind required;
-
-        private MembersOfType(@NotNull DescriptorKind required) {
-            this.required = required;
-        }
 
         @Override
         public boolean includeName(@NotNull Name name) {
@@ -182,71 +176,24 @@ public abstract class DescriptorPredicate {
 
         @Override
         public boolean include(@NotNull DeclarationDescriptor descriptor) {
-            return descriptorKind(descriptor) == required;
+            return descriptor instanceof CallableMemberDescriptor;
         }
 
         @Override
         public boolean includeKind(@NotNull DescriptorKind kind) {
-            return kind == required;
+            return kind == DescriptorKind.CALLABLE_MEMBER;
         }
 
     }
 
-
-    private static final DescriptorPredicate callableMembers = new MembersOfType(DescriptorKind.CALLABLE_MEMBER);
-
     public static DescriptorPredicate callableMembers() {
-        return callableMembers;
+        return CallableMembers.instance;
-    }
-
-    private static final DescriptorPredicate namespaces = new MembersOfType(DescriptorKind.NAMESPACE);
-
-    public static DescriptorPredicate namespaces() {
-        return namespaces;
     }
 
 
-    private static class MembersOrTypeWithName extends MembersOfType {
+    private static class Extension extends CallableMembers {
-        @NotNull
-        private final NamePredicate required;
-
-        private MembersOrTypeWithName(@NotNull DescriptorKind descriptorKind, @NotNull NamePredicate required) {
-            super(descriptorKind);
-            this.required = required;
-        }
-
-        @Override
-        public boolean includeName(@NotNull Name name) {
-            return required.matches(name);
-        }
-    }
-
-    public static DescriptorPredicate callableMembers(@NotNull NamePredicate required) {
-        if (required.isAll()) {
-            return callableMembers();
-        }
-        else {
-            return new MembersOrTypeWithName(DescriptorKind.CALLABLE_MEMBER, required);
-        }
-    }
-
-    public static DescriptorPredicate namespaces(@NotNull NamePredicate required) {
-        if (required.isAll()) {
-            return namespaces();
-        }
-        else {
-            return new MembersOrTypeWithName(DescriptorKind.NAMESPACE, required);
-        }
-    }
-
-
-    private static class Extension extends MembersOfType {
         private static final Extension instance = new Extension();
 
-        private Extension() {
-            super(DescriptorKind.CALLABLE_MEMBER);
-        }
-
         @Override
         public boolean includeExtension(boolean extension) {
             return extension;
@@ -258,31 +205,6 @@ public abstract class DescriptorPredicate {
     }
 
 
-
-    private static class ExtensionWithName extends Extension {
-        @NotNull
-        private final NamePredicate required;
-
-        private ExtensionWithName(@NotNull NamePredicate required) {
-            this.required = required;
-        }
-
-        @Override
-        public boolean includeName(@NotNull Name name) {
-            return required.matches(name);
-        }
-    }
-
-    public static DescriptorPredicate extension(@NotNull NamePredicate required) {
-        if (required.isAll()) {
-            return extension();
-        }
-        else {
-            return new ExtensionWithName(required);
-        }
-    }
-
-
     public Predicate<DeclarationDescriptor> asGuavaPredicate() {
         return new Predicate<DeclarationDescriptor>() {
             @Override

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

@@ -158,7 +158,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
         if (!allDescriptorsDone) {
             if (!predicate.includeAll()) {
                 // super-optimized version
-                return concat(DescriptorPredicateUtils.filter(allDescriptors, predicate), getInheritedDescriptors(predicate));
+                return concat(allDescriptors, getInheritedDescriptors(predicate));
             }
 
             allDescriptorsDone = true;

idea/src/org/jetbrains/jet/plugin/completion/JetCompletionContributor.java

@@ -35,8 +35,6 @@ import org.jetbrains.jet.cli.jvm.compiler.TipsManager;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.name.NamePredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.plugin.caches.JetCacheManager;
@@ -349,15 +347,7 @@ public class JetCompletionContributor extends CompletionContributor {
                 (JetFile)reference.getExpression().getContainingFile())
                 .getBindingContext();
 
-        class PrefixMatcherNamePredicate extends NamePredicate {
+        Collection<DeclarationDescriptor> descriptors = TipsManager.getReferenceVariants(reference.getExpression(), bindingContext);
-            @Override
-            public boolean matches(@NotNull Name name) {
-                return result.getPrefixMatcher().prefixMatches(name.getName());
-            }
-        }
-
-        Collection<DeclarationDescriptor> descriptors = TipsManager.getReferenceVariants(
-                reference.getExpression(), bindingContext, new PrefixMatcherNamePredicate());
 
         Collection<DeclarationDescriptor> checkedDescriptors = Collections2.filter(descriptors, new Predicate<DeclarationDescriptor>() {
             @Override
@@ -366,7 +356,7 @@ public class JetCompletionContributor extends CompletionContributor {
                     return false;
                 }
 
-                return isVisibleDescriptor(descriptor, session);
+                return result.getPrefixMatcher().prefixMatches(descriptor.getName().getName()) && isVisibleDescriptor(descriptor, session);
             }
         });
 

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

@@ -36,7 +36,6 @@ 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.name.NamePredicate;
 import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
@@ -85,7 +84,7 @@ public abstract class BaseJetVariableMacro extends Macro {
         }
 
         List<JetNamedDeclaration> declarations = new ArrayList<JetNamedDeclaration>();
-        for (DeclarationDescriptor declarationDescriptor : TipsManager.excludeNotCallableExtensions(filteredDescriptors, scope, NamePredicate.all())) {
+        for (DeclarationDescriptor declarationDescriptor : TipsManager.excludeNotCallableExtensions(filteredDescriptors, scope)) {
             PsiElement declaration = BindingContextUtils.descriptorToDeclaration(bc, declarationDescriptor);
             assert declaration == null || declaration instanceof PsiNamedElement;
 

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

@@ -33,7 +33,6 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.JetVisibilityChecker;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.name.NamePredicate;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
@@ -356,7 +355,7 @@ public class JetFunctionParameterInfoHandler implements
             if (scope != null) {
                 placeDescriptor = scope.getContainingDeclaration();
             }
-            Collection<DeclarationDescriptor> variants = TipsManager.getReferenceVariants(refExpression, bindingContext, NamePredicate.all());
+            Collection<DeclarationDescriptor> variants = TipsManager.getReferenceVariants(refExpression, bindingContext);
             Name refName = refExpression.getReferencedNameAsName();
             PsiReference[] references = refExpression.getReferences();
             if (references.length == 0) return null;

idea/src/org/jetbrains/jet/plugin/refactoring/JetNameValidatorImpl.java

@@ -27,7 +27,6 @@ import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetVisitorVoid;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.name.NamePredicate;
 import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade;
 
 import java.util.Collection;
@@ -107,7 +106,7 @@ public class JetNameValidatorImpl implements JetNameValidator {
             @Override
             public void visitExpression(JetExpression expression) {
                 Collection<DeclarationDescriptor> variants =
-                        TipsManager.getVariantsNoReceiver(expression, myBindingContext, NamePredicate.all());
+                        TipsManager.getVariantsNoReceiver(expression, myBindingContext);
                 for (DeclarationDescriptor variant : variants) {
                     if (variant.getName().getName().equals(name) && variant instanceof VariableDescriptor) {
                         result.set(false);

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

@@ -25,7 +25,6 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiFactory;
 import org.jetbrains.jet.lang.psi.JetSimpleNameExpression;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.name.NamePredicate;
 import org.jetbrains.jet.plugin.completion.DescriptorLookupConverter;
 import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade;
 
@@ -67,7 +66,7 @@ public class JetSimpleNameReference extends JetPsiReference {
                     .getBindingContext();
 
         return DescriptorLookupConverter.collectLookupElements(
-                bindingContext, TipsManager.getReferenceVariants(myExpression, bindingContext, NamePredicate.all()));
+                bindingContext, TipsManager.getReferenceVariants(myExpression, bindingContext));
     }
 
     @Override