From 709e4b3561fafd4d54488a922e33de244c5a96b2 Mon Sep 17 00:00:00 2001
From: Stepan Koltsov <stepan.koltsov@jetbrains.com>
Date: Mon, 28 Nov 2011 17:54:45 +0400
Subject: [PATCH] move TaskPrioritizer.isLocal to DescriptorUtils

---
 .../jet/lang/resolve/DescriptorUtils.java     | 31 ++++++++++++++++
 .../lang/resolve/calls/TaskPrioritizer.java   | 36 ++-----------------
 2 files changed, 33 insertions(+), 34 deletions(-)

diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java
index ba492a83cde..c66af6e8f03 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java
@@ -123,4 +123,35 @@ public class DescriptorUtils {
         }
         return NO_RECEIVER;
     }
+
+    /**
+     * The primary case for local extensions is the following:
+     *
+     * I had a locally declared extension function or a local variable of function type called foo
+     * And I called it on my x
+     * Now, someone added function foo() to the class of x
+     * My code should not change
+     *
+     * thus
+     *
+     * local extension prevail over members (and members prevail over all non-local extensions)
+     */
+    public static boolean isLocal(DeclarationDescriptor containerOfTheCurrentLocality, DeclarationDescriptor candidate) {
+        if (candidate instanceof ValueParameterDescriptor) {
+            return true;
+        }
+        DeclarationDescriptor parent = candidate.getContainingDeclaration();
+        if (!(parent instanceof FunctionDescriptor)) {
+            return false;
+        }
+        FunctionDescriptor functionDescriptor = (FunctionDescriptor) parent;
+        DeclarationDescriptor current = containerOfTheCurrentLocality;
+        while (current != null) {
+            if (current == functionDescriptor) {
+                return true;
+            }
+            current = current.getContainingDeclaration();
+        }
+        return false;
+    }
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java
index 872781fb28b..823666d4ed2 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java
@@ -5,12 +5,11 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.psi.Call;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetSuperExpression;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.AutoCastService;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.AutoCastServiceImpl;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo;
@@ -36,7 +35,7 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
             Collection<ResolvedCallImpl<D>> allDescriptors, DeclarationDescriptor containerOfTheCurrentLocality, Collection<ResolvedCallImpl<D>> local, Collection<ResolvedCallImpl<D>> nonlocal) {
 
         for (ResolvedCallImpl<D> resolvedCall : allDescriptors) {
-            if (isLocal(containerOfTheCurrentLocality, resolvedCall.getCandidateDescriptor())) {
+            if (DescriptorUtils.isLocal(containerOfTheCurrentLocality, resolvedCall.getCandidateDescriptor())) {
                 local.add(resolvedCall);
             }
             else {
@@ -45,37 +44,6 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
         }
     }
 
-    /**
-     * The primary case for local extensions is the following:
-     *
-     * I had a locally declared extension function or a local variable of function type called foo
-     * And I called it on my x
-     * Now, someone added function foo() to the class of x
-     * My code should not change
-     *
-     * thus
-     *
-     * local extension prevail over members (and members prevail over all non-local extensions)
-     */
-    private static boolean isLocal(DeclarationDescriptor containerOfTheCurrentLocality, DeclarationDescriptor candidate) {
-        if (candidate instanceof ValueParameterDescriptor) {
-            return true;
-        }
-        DeclarationDescriptor parent = candidate.getContainingDeclaration();
-        if (!(parent instanceof FunctionDescriptor)) {
-            return false;
-        }
-        FunctionDescriptor functionDescriptor = (FunctionDescriptor) parent;
-        DeclarationDescriptor current = containerOfTheCurrentLocality;
-        while (current != null) {
-            if (current == functionDescriptor) {
-                return true;
-            }
-            current = current.getContainingDeclaration();
-        }
-        return false;
-    }
-
     @Nullable
     /*package*/ static JetSuperExpression getReceiverSuper(@NotNull ReceiverDescriptor receiver) {
         if (receiver instanceof ExpressionReceiver) {