diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTaskHolder.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTaskHolder.java
index b9162fa9ff5..5533913bb59 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTaskHolder.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/ResolutionTaskHolder.java
@@ -63,6 +63,12 @@ public class ResolutionTaskHolder<D extends CallableDescriptor, F extends D> {
         }
     }
 
+    public void addCandidates(@NotNull List<Collection<ResolutionCandidate<D>>> candidatesList) {
+        for (Collection<ResolutionCandidate<D>> candidates : candidatesList) {
+            addCandidates(candidates);
+        }
+    }
+
     public List<ResolutionTask<D, F>> getTasks() {
         if (tasks == null) {
             tasks = Lists.newArrayList();
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java
index 099d599d790..908c9d2ea68 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java
@@ -89,16 +89,16 @@ public class TaskPrioritizer {
         }
 
         ResolutionTaskHolder<D, F> result = new ResolutionTaskHolder<D, F>(functionReference, context, new MyPriorityProvider<D>(context));
-        for (CallableDescriptorCollector<? extends D> callableDescriptorCollector : callableDescriptorCollectors) {
-            doComputeTasks(scope, explicitReceiver, name, result, context, callableDescriptorCollector);
-        }
+        doComputeTasks(scope, explicitReceiver, name, result, context, callableDescriptorCollectors);
         return result.getTasks();
     }
 
-    private static <D extends CallableDescriptor, F extends D> void doComputeTasks(@NotNull JetScope scope, @NotNull ReceiverValue receiver,
+    private static <D extends CallableDescriptor, F extends D> void doComputeTasks(
+            @NotNull JetScope scope, @NotNull ReceiverValue receiver,
             @NotNull Name name, @NotNull ResolutionTaskHolder<D, F> result,
-            @NotNull BasicCallResolutionContext context, @NotNull CallableDescriptorCollector<? extends D> callableDescriptorCollector) {
-
+            @NotNull BasicCallResolutionContext context,
+            @NotNull List<CallableDescriptorCollector<? extends D>> callableDescriptorCollectors
+    ) {
         ProgressIndicatorProvider.checkCanceled();
 
         AutoCastServiceImpl autoCastService = new AutoCastServiceImpl(context.dataFlowInfo, context.trace.getBindingContext());
@@ -110,42 +110,53 @@ public class TaskPrioritizer {
         if (receiver.exists()) {
             List<ReceiverValue> variantsForExplicitReceiver = autoCastService.getVariantsForReceiver(receiver);
 
-            Collection<ResolutionCandidate<D>> members = Lists.newArrayList();
-            for (ReceiverValue variant : variantsForExplicitReceiver) {
-                Collection<? extends D> membersForThisVariant = callableDescriptorCollector.getMembersByName(variant.getType(), name);
-                convertWithReceivers(membersForThisVariant, Collections.singletonList(variant),
-                                     Collections.singletonList(NO_RECEIVER), members, hasExplicitThisObject);
+            for (CallableDescriptorCollector<? extends D> callableDescriptorCollector : callableDescriptorCollectors) {
+                Collection<ResolutionCandidate<D>> members = Lists.newArrayList();
+                for (ReceiverValue variant : variantsForExplicitReceiver) {
+                    Collection<? extends D> membersForThisVariant = callableDescriptorCollector.getMembersByName(variant.getType(), name);
+                    convertWithReceivers(membersForThisVariant, Collections.singletonList(variant),
+                                         Collections.singletonList(NO_RECEIVER), members, hasExplicitThisObject);
+                }
+                result.addCandidates(members);
             }
 
-            result.addCandidates(members);
-
-            for (ReceiverValue implicitReceiver : implicitReceivers) {
-                Collection<? extends D> memberExtensions = callableDescriptorCollector.getNonMembersByName(
-                        implicitReceiver.getType().getMemberScope(), name);
-                List<ReceiverValue> variantsForImplicitReceiver = autoCastService.getVariantsForReceiver(implicitReceiver);
-                result.addCandidates(convertWithReceivers(memberExtensions, variantsForImplicitReceiver,
-                                                          variantsForExplicitReceiver, hasExplicitThisObject));
+            for (CallableDescriptorCollector<? extends D> callableDescriptorCollector : callableDescriptorCollectors) {
+                for (ReceiverValue implicitReceiver : implicitReceivers) {
+                    Collection<? extends D> memberExtensions = callableDescriptorCollector.getNonMembersByName(
+                            implicitReceiver.getType().getMemberScope(), name);
+                    List<ReceiverValue> variantsForImplicitReceiver = autoCastService.getVariantsForReceiver(implicitReceiver);
+                    result.addCandidates(convertWithReceivers(memberExtensions, variantsForImplicitReceiver,
+                                                              variantsForExplicitReceiver, hasExplicitThisObject));
+                }
+                Collection<ResolutionCandidate<D>> extensionFunctions = convertWithImpliedThis(
+                        scope, variantsForExplicitReceiver, callableDescriptorCollector.getNonMembersByName(scope, name));
+                result.addCandidates(extensionFunctions);
             }
-
-            Collection<ResolutionCandidate<D>> extensionFunctions = convertWithImpliedThis(
-                    scope, variantsForExplicitReceiver, callableDescriptorCollector.getNonMembersByName(scope, name));
-            result.addCandidates(extensionFunctions);
         }
         else {
-            Collection<ResolutionCandidate<D>> functions = convertWithImpliedThis(scope, Collections.singletonList(receiver), callableDescriptorCollector
-                    .getNonExtensionsByName(scope, name));
+            List<Collection<ResolutionCandidate<D>>> localsList = Lists.newArrayList();
+            List<Collection<ResolutionCandidate<D>>> nonlocalsList = Lists.newArrayList();
+            for (CallableDescriptorCollector<? extends D> callableDescriptorCollector : callableDescriptorCollectors) {
 
-            List<ResolutionCandidate<D>> nonlocals = Lists.newArrayList();
-            List<ResolutionCandidate<D>> locals = Lists.newArrayList();
-            //noinspection unchecked,RedundantTypeArguments
-            TaskPrioritizer.<D>splitLexicallyLocalDescriptors(functions, scope.getContainingDeclaration(), locals, nonlocals);
+                Collection<ResolutionCandidate<D>> functions =
+                        convertWithImpliedThis(scope, Collections.singletonList(receiver), callableDescriptorCollector
+                                .getNonExtensionsByName(scope, name));
 
-            result.addCandidates(locals);
+                List<ResolutionCandidate<D>> nonlocals = Lists.newArrayList();
+                List<ResolutionCandidate<D>> locals = Lists.newArrayList();
+                //noinspection unchecked,RedundantTypeArguments
+                TaskPrioritizer.<D>splitLexicallyLocalDescriptors(functions, scope.getContainingDeclaration(), locals, nonlocals);
+
+                localsList.add(locals);
+                nonlocalsList.add(nonlocals);
+            }
+
+            result.addCandidates(localsList);
 
             for (ReceiverValue implicitReceiver : implicitReceivers) {
-                doComputeTasks(scope, implicitReceiver, name, result, context, callableDescriptorCollector);
+                doComputeTasks(scope, implicitReceiver, name, result, context, callableDescriptorCollectors);
             }
-            result.addCandidates(nonlocals);
+            result.addCandidates(nonlocalsList);
         }
     }
 
diff --git a/compiler/testData/resolve/candidatesPriority/memberWithInvokeVsNonLocal.resolve b/compiler/testData/resolve/candidatesPriority/memberWithInvokeVsNonLocal.resolve
new file mode 100644
index 00000000000..ba5f8457364
--- /dev/null
+++ b/compiler/testData/resolve/candidatesPriority/memberWithInvokeVsNonLocal.resolve
@@ -0,0 +1,8 @@
+annotation class data
+
+public class BinaryResponse(~data~val data: () -> String) {
+    fun writeResponse() {
+
+        `data`data()
+    }
+}
diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTestGenerated.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTestGenerated.java
index 5b23f67300b..dc85ba28418 100644
--- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTestGenerated.java
+++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTestGenerated.java
@@ -228,6 +228,11 @@ public class JetResolveTestGenerated extends AbstractResolveTest {
             doTest("compiler/testData/resolve/candidatesPriority/memberVsLocalExtension.resolve");
         }
         
+        @TestMetadata("memberWithInvokeVsNonLocal.resolve")
+        public void testMemberWithInvokeVsNonLocal() throws Exception {
+            doTest("compiler/testData/resolve/candidatesPriority/memberWithInvokeVsNonLocal.resolve");
+        }
+        
         @TestMetadata("receiverVsThisObject.resolve")
         public void testReceiverVsThisObject() throws Exception {
             doTest("compiler/testData/resolve/candidatesPriority/receiverVsThisObject.resolve");