From f54e2bc498c224a4958975fde621e75ee89c9b27 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Thu, 29 May 2014 21:17:21 +0400 Subject: [PATCH] OverridingUtil turned into a singleton --- .../resolver/PsiBasedMethodSignatureChecker.java | 4 +--- .../jet/lang/resolve/DelegationResolver.java | 2 +- .../org/jetbrains/jet/lang/resolve/OverloadUtil.java | 2 +- .../jetbrains/jet/lang/resolve/OverrideResolver.java | 6 +++--- .../org/jetbrains/jet/types/JetOverridingTest.java | 2 +- .../jetbrains/jet/lang/resolve/OverridingUtil.java | 12 +++++++----- .../plugin/codeInsight/OverrideMethodsHandler.java | 4 ++-- 7 files changed, 16 insertions(+), 16 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedMethodSignatureChecker.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedMethodSignatureChecker.java index 5068ac15088..42b20e1a330 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedMethodSignatureChecker.java +++ b/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) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java index c75f4a47714..82b247fb4d2 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java @@ -214,7 +214,7 @@ public final class DelegationResolver { 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 diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadUtil.java index 593619a31b1..33f22d6cfaa 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadUtil.java +++ b/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: diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java index cc151f2f595..2b091f3459f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java +++ b/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.isOverridableBy(me, other).getResult() == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE) { + && OverridingUtil.DEFAULT.isOverridableBy(other, me).getResult() == 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()"); diff --git a/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java b/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java index 0774a4ee898..48cb58b748b 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java +++ b/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); } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java index 410f5c99c6a..fd21503bc2c 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java +++ b/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 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 result2 = isOverridableBy(overrider, candidate).getResult(); + OverrideCompatibilityInfo.Result result1 = DEFAULT.isOverridableBy(candidate, overrider).getResult(); + OverrideCompatibilityInfo.Result result2 = DEFAULT.isOverridableBy(overrider, candidate).getResult(); if (result1 == OVERRIDABLE && result2 == OVERRIDABLE) { overridable.add(candidate); iterator.remove(); diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideMethodsHandler.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideMethodsHandler.java index badacc99b2b..5b0cd68b63d 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideMethodsHandler.java +++ b/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 - || OverridingUtil.isOverridableBy(another, one).getResult() == OVERRIDABLE) { + if (OverridingUtil.DEFAULT.isOverridableBy(one, another).getResult() == OVERRIDABLE + || OverridingUtil.DEFAULT.isOverridableBy(another, one).getResult() == OVERRIDABLE) { factoredMembers.put(one, another); } }