OverridingUtil turned into a singleton

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedMethodSignatureChecker.java

@@ -40,8 +40,6 @@ import javax.inject.Inject;
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.jetbrains.jet.lang.resolve.OverridingUtil.isOverridableBy;
-
 public class PsiBasedMethodSignatureChecker implements MethodSignatureChecker {
     private static final Logger LOG = Logger.getInstance(PsiBasedMethodSignatureChecker.class);
 
@@ -77,7 +75,7 @@ public class PsiBasedMethodSignatureChecker implements MethodSignatureChecker {
 
         assert superFunctionSubstituted != null : "Couldn't substitute super function: " + superFunction + ", substitutor = " + substitutor;
 
-        OverridingUtil.OverrideCompatibilityInfo.Result overridableResult = isOverridableBy(superFunctionSubstituted, function).getResult();
+        OverridingUtil.OverrideCompatibilityInfo.Result overridableResult = OverridingUtil.DEFAULT.isOverridableBy(superFunctionSubstituted, function).getResult();
         boolean paramsOk = overridableResult == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE;
         boolean returnTypeOk = OverrideResolver.isReturnTypeOkForOverride(superFunctionSubstituted, function);
         if (!paramsOk || !returnTypeOk) {

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

@@ -214,7 +214,7 @@ public final class DelegationResolver<T extends CallableMemberDescriptor> {
 
     private static boolean haveSameSignatures(@NotNull CallableDescriptor memberOne, @NotNull CallableDescriptor memberTwo) {
         //isOverridableBy ignores return types
-        return OverridingUtil.isOverridableBy(memberOne, memberTwo).getResult() == OVERRIDABLE;
+        return OverridingUtil.DEFAULT.isOverridableBy(memberOne, memberTwo).getResult() == OVERRIDABLE;
     }
 
     @NotNull

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

@@ -34,7 +34,7 @@ public class OverloadUtil {
             return OverloadCompatibilityInfo.success();
         }
         
-        OverridingUtil.OverrideCompatibilityInfo overrideCompatibilityInfo = OverridingUtil.isOverridableByImpl(a, b, false);
+        OverridingUtil.OverrideCompatibilityInfo overrideCompatibilityInfo = OverridingUtil.DEFAULT.isOverridableByImpl(a, b, false);
         switch (overrideCompatibilityInfo.getResult()) {
             case OVERRIDABLE:
             case CONFLICT:

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

@@ -277,8 +277,8 @@ public class OverrideResolver {
             for (D otherD : candidates) {
                 CallableDescriptor other = transform.fun(otherD);
                 if (me.getOriginal() == other.getOriginal()
-                    && OverridingUtil.isOverridableBy(other, me).getResult() == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE
+                    && OverridingUtil.DEFAULT.isOverridableBy(other, me).getResult() == OVERRIDABLE
-                    && OverridingUtil.isOverridableBy(me, other).getResult() == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE) {
+                    && OverridingUtil.DEFAULT.isOverridableBy(me, other).getResult() == OVERRIDABLE) {
                     continue outerLoop;
                 }
             }
@@ -838,7 +838,7 @@ public class OverrideResolver {
             //noinspection unchecked
             all.addAll((Collection) supertype.getMemberScope().getProperties(declared.getName()));
             for (CallableMemberDescriptor fromSuper : all) {
-                if (OverridingUtil.isOverridableBy(fromSuper, declared).getResult() == OVERRIDABLE) {
+                if (OverridingUtil.DEFAULT.isOverridableBy(fromSuper, declared).getResult() == OVERRIDABLE) {
                     if (Visibilities.isVisible(fromSuper, declared)) {
                         throw new IllegalStateException("Descriptor " + fromSuper + " is overridable by " + declared +
                                                         " and visible but does not appear in its getOverriddenDescriptors()");

compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java

@@ -163,7 +163,7 @@ public class JetOverridingTest extends JetLiteFixture {
     private void assertOverridabilityRelation(String superFun, String subFun, boolean expectedIsError) {
         FunctionDescriptor a = makeFunction(superFun);
         FunctionDescriptor b = makeFunction(subFun);
-        OverridingUtil.OverrideCompatibilityInfo overridableWith = OverridingUtil.isOverridableBy(a, b);
+        OverridingUtil.OverrideCompatibilityInfo overridableWith = OverridingUtil.DEFAULT.isOverridableBy(a, b);
         assertEquals(overridableWith.getMessage(), expectedIsError, overridableWith.getResult() != OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE);
     }
 

core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java

@@ -45,11 +45,13 @@ public class OverridingUtil {
                     ExternalOverridabilityCondition.class.getClassLoader()).iterator()
             );
 
+    public static final OverridingUtil DEFAULT = new OverridingUtil();
+
     private OverridingUtil() {
     }
 
     @NotNull
-    public static OverrideCompatibilityInfo isOverridableBy(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor) {
+    public OverrideCompatibilityInfo isOverridableBy(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor) {
         if (superDescriptor instanceof FunctionDescriptor) {
             if (!(subDescriptor instanceof FunctionDescriptor)) return OverrideCompatibilityInfo.memberKindMismatch();
         }
@@ -71,7 +73,7 @@ public class OverridingUtil {
     /**
      * @param forOverride true for override, false for overload
      */
-    static OverrideCompatibilityInfo isOverridableByImpl(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor, boolean forOverride) {
+    OverrideCompatibilityInfo isOverridableByImpl(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor, boolean forOverride) {
 
         // TODO : Visibility
 
@@ -229,7 +231,7 @@ public class OverridingUtil {
     ) {
         Collection<CallableMemberDescriptor> bound = Lists.newArrayList();
         for (CallableMemberDescriptor fromSupertype : descriptorsFromSuper) {
-            OverrideCompatibilityInfo.Result result = isOverridableBy(fromSupertype, fromCurrent).getResult();
+            OverrideCompatibilityInfo.Result result = DEFAULT.isOverridableBy(fromSupertype, fromCurrent).getResult();
 
             boolean isVisible = Visibilities.isVisible(fromSupertype, current);
             switch (result) {
@@ -361,8 +363,8 @@ public class OverridingUtil {
                 continue;
             }
 
-            OverrideCompatibilityInfo.Result result1 = isOverridableBy(candidate, overrider).getResult();
+            OverrideCompatibilityInfo.Result result1 = DEFAULT.isOverridableBy(candidate, overrider).getResult();
-            OverrideCompatibilityInfo.Result result2 = isOverridableBy(overrider, candidate).getResult();
+            OverrideCompatibilityInfo.Result result2 = DEFAULT.isOverridableBy(overrider, candidate).getResult();
             if (result1 == OVERRIDABLE && result2 == OVERRIDABLE) {
                 overridable.add(candidate);
                 iterator.remove();

idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideMethodsHandler.java

@@ -77,8 +77,8 @@ public class OverrideMethodsHandler extends OverrideImplementMethodsHandler {
             for (CallableMemberDescriptor another : filteredMembers) {
 //                if (one == another) continue;
                 factoredMembers.put(one, one);
-                if (OverridingUtil.isOverridableBy(one, another).getResult() == OVERRIDABLE
+                if (OverridingUtil.DEFAULT.isOverridableBy(one, another).getResult() == OVERRIDABLE
-                    || OverridingUtil.isOverridableBy(another, one).getResult() == OVERRIDABLE) {
+                    || OverridingUtil.DEFAULT.isOverridableBy(another, one).getResult() == OVERRIDABLE) {
                     factoredMembers.put(one, another);
                 }
             }