azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move some utilities from OverridingUtil to OverrideResolver

Browse Source 
OverridingUtil will be present at runtime and we should strive to minimize the
size of our runtime classes

Also add a comment to getOverriddenDescriptors()
This commit is contained in:
Alexander Udalov
2014-03-28 15:09:04 +04:00
parent 3dffd428ad
commit 34e7584aec
18 changed files with 292 additions and 295 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend-common/src/bridges/impl.kt
+3 -3
View File
@@ -18,7 +18,7 @@ package org.jetbrains.jet.codegen.bridges
import org.jetbrains.jet.lang.descriptors.*
import org.jetbrains.jet.lang.resolve.DescriptorUtils
import org.jetbrains.jet.lang.resolve.OverridingUtil
import org.jetbrains.jet.lang.resolve.OverrideResolver
import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil
import org.jetbrains.jet.lang.types.TypeUtils
@@ -72,8 +72,8 @@ public fun findTraitImplementation(descriptor: CallableMemberDescriptor): Callab
// TODO: this logic is quite common for bridge generation, find a way to abstract it to a single place
// TODO: don't use filterOutOverridden() here, it's an internal front-end utility (see its implementation)
val overriddenDeclarations = OverridingUtil.getOverriddenDeclarations(descriptor)
val filteredOverriddenDeclarations = OverridingUtil.filterOutOverridden(overriddenDeclarations)
val overriddenDeclarations = OverrideResolver.getOverriddenDeclarations(descriptor)
val filteredOverriddenDeclarations = OverrideResolver.filterOutOverridden(overriddenDeclarations)
var implementation: CallableMemberDescriptor? = null
for (overriddenDeclaration in filteredOverriddenDeclarations) {
compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
+2 -2
View File
@@ -40,7 +40,7 @@ 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.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.OverridingUtil;
import org.jetbrains.jet.lang.resolve.OverrideResolver;
import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil;
import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
@@ -682,7 +682,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
return true;
}
for (CallableDescriptor overridden : OverridingUtil.getOverriddenDeclarations(function)) {
for (CallableDescriptor overridden : OverrideResolver.getOverriddenDeclarations(function)) {
if (overridden instanceof CallableMemberDescriptor
&& ((CallableMemberDescriptor) overridden).getKind() == CallableMemberDescriptor.Kind.DECLARATION
&& !overridden.getContainingDeclaration().equals(KotlinBuiltIns.getInstance().getAny())) {
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedMethodSignatureChecker.java
+2 -3
View File
@@ -26,6 +26,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
import org.jetbrains.jet.lang.resolve.OverrideResolver;
import org.jetbrains.jet.lang.resolve.OverridingUtil;
import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesUtil;
import org.jetbrains.jet.lang.resolve.java.structure.*;
@@ -34,14 +35,12 @@ import org.jetbrains.jet.lang.types.ErrorUtils;
import org.jetbrains.jet.lang.types.SubstitutionUtils;
import org.jetbrains.jet.lang.types.TypeSubstitution;
import org.jetbrains.jet.lang.types.TypeSubstitutor;
import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
import javax.inject.Inject;
import java.util.ArrayList;
import java.util.List;
import static org.jetbrains.jet.lang.resolve.OverridingUtil.isOverridableBy;
import static org.jetbrains.jet.lang.resolve.OverridingUtil.isReturnTypeOkForOverride;
public class PsiBasedMethodSignatureChecker implements MethodSignatureChecker {
private static final Logger LOG = Logger.getInstance(PsiBasedMethodSignatureChecker.class);
@@ -80,7 +79,7 @@ public class PsiBasedMethodSignatureChecker implements MethodSignatureChecker {
OverridingUtil.OverrideCompatibilityInfo.Result overridableResult = isOverridableBy(superFunctionSubstituted, function).getResult();
boolean paramsOk = overridableResult == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE;
boolean returnTypeOk = isReturnTypeOkForOverride(JetTypeChecker.INSTANCE, superFunctionSubstituted, function);
boolean returnTypeOk = OverrideResolver.isReturnTypeOkForOverride(superFunctionSubstituted, function);
if (!paramsOk || !returnTypeOk) {
// This should be a LOG.error, but happens a lot of times incorrectly (e.g. on Kotlin project), because somewhere in the
// type checker we compare two types which seem the same but have different instances of class descriptors. It happens
compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java
+248 -18
View File
@@ -21,11 +21,13 @@ import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.intellij.lang.ASTNode;
import com.intellij.psi.PsiElement;
import com.intellij.util.Function;
import com.intellij.util.containers.ContainerUtil;
import com.intellij.util.containers.LinkedMultiMap;
import com.intellij.util.containers.MultiMap;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.ReadOnly;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
@@ -33,7 +35,7 @@ import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.lexer.JetTokens;
@@ -41,6 +43,7 @@ import org.jetbrains.jet.lexer.JetTokens;
import javax.inject.Inject;
import java.util.*;
import static org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor.Kind.*;
import static org.jetbrains.jet.lang.diagnostics.Errors.*;
import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE;
@@ -179,6 +182,94 @@ public class OverrideResolver {
});
}
private static enum Filtering {
RETAIN_OVERRIDING,
RETAIN_OVERRIDDEN
}
@NotNull
public static <D extends CallableDescriptor> Set<D> filterOutOverridden(@NotNull Set<D> candidateSet) {
//noinspection unchecked
return filterOverrides(candidateSet, Function.ID, Filtering.RETAIN_OVERRIDING);
}
@NotNull
public static <D> Set<D> filterOutOverriding(@NotNull Set<D> candidateSet) {
//noinspection unchecked
return filterOverrides(candidateSet, Function.ID, Filtering.RETAIN_OVERRIDDEN);
}
@NotNull
public static <D> Set<D> filterOutOverridden(
@NotNull Set<D> candidateSet,
@NotNull Function<? super D, ? extends CallableDescriptor> transform
) {
return filterOverrides(candidateSet, transform, Filtering.RETAIN_OVERRIDING);
}
@NotNull
private static <D> Set<D> filterOverrides(
@NotNull Set<D> candidateSet,
@NotNull Function<? super D, ? extends CallableDescriptor> transform,
@NotNull Filtering filtering
) {
Set<D> candidates = Sets.newLinkedHashSet();
outerLoop:
for (D meD : candidateSet) {
CallableDescriptor me = transform.fun(meD);
for (D otherD : candidateSet) {
CallableDescriptor other = transform.fun(otherD);
if (me == other) continue;
if (filtering == Filtering.RETAIN_OVERRIDING) {
if (overrides(other, me)) {
continue outerLoop;
}
}
else if (filtering == Filtering.RETAIN_OVERRIDDEN) {
if (overrides(me, other)) {
continue outerLoop;
}
}
else {
throw new AssertionError("Unexpected Filtering object: " + filtering);
}
}
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) {
continue outerLoop;
}
}
candidates.add(meD);
}
return candidates;
}
public static <D extends CallableDescriptor> boolean overrides(@NotNull D f, @NotNull D g) {
CallableDescriptor originalG = g.getOriginal();
for (CallableDescriptor overriddenFunction : getAllOverriddenDescriptors(f)) {
if (originalG.equals(overriddenFunction.getOriginal())) return true;
}
return false;
}
@NotNull
public static Set<CallableDescriptor> getAllOverriddenDescriptors(@NotNull CallableDescriptor f) {
Set<CallableDescriptor> result = new LinkedHashSet<CallableDescriptor>();
collectAllOverriddenDescriptors(f.getOriginal(), result);
return result;
}
private static void collectAllOverriddenDescriptors(@NotNull CallableDescriptor current, @NotNull Set<CallableDescriptor> result) {
if (result.contains(current)) return;
for (CallableDescriptor descriptor : current.getOriginal().getOverriddenDescriptors()) {
collectAllOverriddenDescriptors(descriptor, result);
result.add(descriptor);
}
}
private static <T extends DeclarationDescriptor> MultiMap<Name, T> groupDescriptorsByName(Collection<T> properties) {
MultiMap<Name, T> r = new LinkedMultiMap<Name, T>();
for (T property : properties) {
@@ -278,7 +369,7 @@ public class OverrideResolver {
Map<CallableMemberDescriptor, Set<CallableMemberDescriptor>> overriddenDeclarationsByDirectParent = collectOverriddenDeclarations(directOverridden);
List<CallableMemberDescriptor> allOverriddenDeclarations = ContainerUtil.flatten(overriddenDeclarationsByDirectParent.values());
Set<CallableMemberDescriptor> allFilteredOverriddenDeclarations = OverridingUtil.filterOutOverridden(
Set<CallableMemberDescriptor> allFilteredOverriddenDeclarations = filterOutOverridden(
Sets.newLinkedHashSet(allOverriddenDeclarations));
Set<CallableMemberDescriptor> relevantDirectlyOverridden =
@@ -384,13 +475,43 @@ public class OverrideResolver {
) {
Map<CallableMemberDescriptor, Set<CallableMemberDescriptor>> overriddenDeclarationsByDirectParent = Maps.newLinkedHashMap();
for (CallableMemberDescriptor descriptor : directOverriddenDescriptors) {
Set<CallableMemberDescriptor> overriddenDeclarations = OverridingUtil.getOverriddenDeclarations(descriptor);
Set<CallableMemberDescriptor> filteredOverrides = OverridingUtil.filterOutOverridden(overriddenDeclarations);
Set<CallableMemberDescriptor> overriddenDeclarations = getOverriddenDeclarations(descriptor);
Set<CallableMemberDescriptor> filteredOverrides = filterOutOverridden(overriddenDeclarations);
overriddenDeclarationsByDirectParent.put(descriptor, new LinkedHashSet<CallableMemberDescriptor>(filteredOverrides));
}
return overriddenDeclarationsByDirectParent;
}
/**
* @return overridden real descriptors (not fake overrides). Note that all usages of this method should be followed by calling
* {@link #filterOutOverridden(java.util.Set)} or {@link #filterOutOverriding(java.util.Set)}, because some of the declarations
* can override the other
* TODO: merge this method with filterOutOverridden
*/
@NotNull
public static Set<CallableMemberDescriptor> getOverriddenDeclarations(@NotNull CallableMemberDescriptor descriptor) {
Set<CallableMemberDescriptor> result = new LinkedHashSet<CallableMemberDescriptor>();
getOverriddenDeclarations(descriptor, result);
return result;
}
private static void getOverriddenDeclarations(
@NotNull CallableMemberDescriptor descriptor,
@NotNull Set<CallableMemberDescriptor> result
) {
if (descriptor.getKind().isReal()) {
result.add(descriptor);
}
else {
if (descriptor.getOverriddenDescriptors().isEmpty()) {
throw new IllegalStateException("No overridden descriptors found for (fake override) " + descriptor);
}
for (CallableMemberDescriptor overridden : descriptor.getOverriddenDescriptors()) {
getOverriddenDeclarations(overridden, result);
}
}
}
private interface CheckOverrideReportStrategy {
void overridingFinalMember(@NotNull CallableMemberDescriptor overridden);
@@ -490,22 +611,22 @@ public class OverrideResolver {
Set<? extends CallableMemberDescriptor> overriddenDescriptors = declared.getOverriddenDescriptors();
for (CallableMemberDescriptor overridden : overriddenDescriptors) {
if (overridden != null) {
if (!overridden.getModality().isOverridable()) {
reportError.overridingFinalMember(overridden);
}
if (overridden == null) continue;
if (declared instanceof PropertyDescriptor && !OverridingUtil.isPropertyTypeOkForOverride(
JetTypeChecker.INSTANCE, (PropertyDescriptor) overridden, (PropertyDescriptor) declared)) {
reportError.propertyTypeMismatchOnOverride(overridden);
}
else if (!OverridingUtil.isReturnTypeOkForOverride(JetTypeChecker.INSTANCE, overridden, declared)) {
reportError.returnTypeMismatchOnOverride(overridden);
}
if (!overridden.getModality().isOverridable()) {
reportError.overridingFinalMember(overridden);
}
if (checkPropertyKind(overridden, true) && checkPropertyKind(declared, false)) {
reportError.varOverriddenByVal(overridden);
}
if (declared instanceof PropertyDescriptor &&
!isPropertyTypeOkForOverride((PropertyDescriptor) overridden, (PropertyDescriptor) declared)) {
reportError.propertyTypeMismatchOnOverride(overridden);
}
else if (!isReturnTypeOkForOverride(overridden, declared)) {
reportError.returnTypeMismatchOnOverride(overridden);
}
if (checkPropertyKind(overridden, true) && checkPropertyKind(declared, false)) {
reportError.varOverriddenByVal(overridden);
}
}
@@ -524,6 +645,60 @@ public class OverrideResolver {
}
}
public static boolean isReturnTypeOkForOverride(
@NotNull CallableDescriptor superDescriptor,
@NotNull CallableDescriptor subDescriptor
) {
TypeSubstitutor typeSubstitutor = prepareTypeSubstitutor(superDescriptor, subDescriptor);
if (typeSubstitutor == null) return false;
JetType superReturnType = superDescriptor.getReturnType();
assert superReturnType != null;
JetType subReturnType = subDescriptor.getReturnType();
assert subReturnType != null;
JetType substitutedSuperReturnType = typeSubstitutor.substitute(superReturnType, Variance.OUT_VARIANCE);
assert substitutedSuperReturnType != null;
return JetTypeChecker.INSTANCE.isSubtypeOf(subReturnType, substitutedSuperReturnType);
}
@Nullable
private static TypeSubstitutor prepareTypeSubstitutor(
@NotNull CallableDescriptor superDescriptor,
@NotNull CallableDescriptor subDescriptor
) {
List<TypeParameterDescriptor> superTypeParameters = superDescriptor.getTypeParameters();
List<TypeParameterDescriptor> subTypeParameters = subDescriptor.getTypeParameters();
if (subTypeParameters.size() != superTypeParameters.size()) return null;
Map<TypeConstructor, TypeProjection> substitutionContext = Maps.newHashMapWithExpectedSize(superTypeParameters.size());
for (int i = 0; i < superTypeParameters.size(); i++) {
TypeParameterDescriptor superTypeParameter = superTypeParameters.get(i);
TypeParameterDescriptor subTypeParameter = subTypeParameters.get(i);
substitutionContext.put(
superTypeParameter.getTypeConstructor(),
new TypeProjectionImpl(subTypeParameter.getDefaultType())
);
}
return TypeSubstitutor.create(substitutionContext);
}
public static boolean isPropertyTypeOkForOverride(
@NotNull PropertyDescriptor superDescriptor,
@NotNull PropertyDescriptor subDescriptor
) {
TypeSubstitutor typeSubstitutor = prepareTypeSubstitutor(superDescriptor, subDescriptor);
if (typeSubstitutor == null) return false;
if (!superDescriptor.isVar()) return true;
JetType substitutedSuperReturnType = typeSubstitutor.substitute(superDescriptor.getType(), Variance.OUT_VARIANCE);
assert substitutedSuperReturnType != null;
return JetTypeChecker.INSTANCE.equalTypes(subDescriptor.getType(), substitutedSuperReturnType);
}
private void checkOverrideForComponentFunction(@NotNull final CallableMemberDescriptor componentFunction) {
final JetAnnotationEntry dataAnnotation = findDataAnnotationForDataClass(componentFunction.getContainingDeclaration());
@@ -731,4 +906,59 @@ public class OverrideResolver {
}
}
}
@NotNull
public static <D extends CallableMemberDescriptor> Set<D> getDirectlyOverriddenDeclarations(@NotNull D descriptor) {
Set<D> result = Sets.newHashSet();
//noinspection unchecked
Set<D> overriddenDescriptors = (Set<D>) descriptor.getOverriddenDescriptors();
for (D overriddenDescriptor : overriddenDescriptors) {
CallableMemberDescriptor.Kind kind = overriddenDescriptor.getKind();
if (kind == DECLARATION) {
result.add(overriddenDescriptor);
}
else if (kind == FAKE_OVERRIDE || kind == DELEGATION) {
result.addAll(getDirectlyOverriddenDeclarations(overriddenDescriptor));
}
else if (kind == SYNTHESIZED) {
//do nothing
}
else {
throw new AssertionError("Unexpected callable kind " + kind);
}
}
return filterOutOverridden(result);
}
@NotNull
public static <D extends CallableMemberDescriptor> Set<D> getAllOverriddenDeclarations(@NotNull D memberDescriptor) {
Set<D> result = Sets.newHashSet();
for (CallableMemberDescriptor overriddenDeclaration : memberDescriptor.getOverriddenDescriptors()) {
CallableMemberDescriptor.Kind kind = overriddenDeclaration.getKind();
if (kind == DECLARATION) {
//noinspection unchecked
result.add((D) overriddenDeclaration);
}
else if (kind == DELEGATION || kind == FAKE_OVERRIDE || kind == SYNTHESIZED) {
//do nothing
}
else {
throw new AssertionError("Unexpected callable kind " + kind);
}
//noinspection unchecked
result.addAll(getAllOverriddenDeclarations((D) overriddenDeclaration));
}
return result;
}
@NotNull
@ReadOnly
public static <D extends CallableMemberDescriptor> Set<D> getDeepestSuperDeclarations(@NotNull D functionDescriptor) {
Set<D> overriddenDeclarations = getAllOverriddenDeclarations(functionDescriptor);
if (overriddenDeclarations.isEmpty()) {
return Collections.singleton(functionDescriptor);
}
return filterOutOverriding(overriddenDeclarations);
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/OverloadingConflictResolver.java
+3 -3
View File
@@ -22,7 +22,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.OverridingUtil;
import org.jetbrains.jet.lang.resolve.OverrideResolver;
import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
import org.jetbrains.jet.lang.resolve.calls.model.VariableAsFunctionResolvedCall;
import org.jetbrains.jet.lang.types.JetType;
@@ -135,8 +135,8 @@ public class OverloadingConflictResolver {
}
if (OverridingUtil.overrides(f, g)) return true;
if (OverridingUtil.overrides(g, f)) return false;
if (OverrideResolver.overrides(f, g)) return true;
if (OverrideResolver.overrides(g, f)) return false;
ReceiverParameterDescriptor receiverOfF = f.getReceiverParameter();
ReceiverParameterDescriptor receiverOfG = g.getReceiverParameter();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/results/ResolutionResultsHandler.java
+3 -3
View File
@@ -20,7 +20,7 @@ import com.google.common.collect.Sets;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.OverridingUtil;
import org.jetbrains.jet.lang.resolve.OverrideResolver;
import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
import org.jetbrains.jet.lang.resolve.calls.tasks.TracingStrategy;
@@ -142,7 +142,7 @@ public class ResolutionResultsHandler {
assert false : "Should not be reachable, cause every status must belong to some level";
Set<ResolvedCallWithTrace<D>> noOverrides = OverridingUtil.filterOutOverridden(failedCandidates, MAP_TO_CANDIDATE);
Set<ResolvedCallWithTrace<D>> noOverrides = OverrideResolver.filterOutOverridden(failedCandidates, MAP_TO_CANDIDATE);
if (noOverrides.size() != 1) {
tracing.noneApplicable(trace, noOverrides);
tracing.recordAmbiguity(trace, noOverrides);
@@ -203,7 +203,7 @@ public class ResolutionResultsHandler {
}
}
Set<ResolvedCallWithTrace<D>> noOverrides = OverridingUtil.filterOutOverridden(candidates, MAP_TO_RESULT);
Set<ResolvedCallWithTrace<D>> noOverrides = OverrideResolver.filterOutOverridden(candidates, MAP_TO_RESULT);
if (noOverrides.size() == 1) {
return OverloadResolutionResultsImpl.success(noOverrides.iterator().next());
}
core/descriptors/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java
+4 -231
View File
@@ -18,22 +18,20 @@ package org.jetbrains.jet.lang.resolve;
import com.google.common.base.Predicate;
import com.google.common.collect.*;
import com.intellij.util.Function;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.ReadOnly;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.impl.FunctionDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.impl.PropertyAccessorDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorImpl;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.TypeConstructor;
import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
import java.util.*;
import static org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor.Kind.*;
import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.CONFLICT;
import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE;
@@ -48,96 +46,6 @@ public class OverridingUtil {
private OverridingUtil() {
}
private static enum Filtering {
RETAIN_OVERRIDING,
RETAIN_OVERRIDDEN
}
@NotNull
public static <D extends CallableDescriptor> Set<D> filterOutOverridden(@NotNull Set<D> candidateSet) {
//noinspection unchecked
return filterOverrides(candidateSet, Function.ID, Filtering.RETAIN_OVERRIDING);
}
@NotNull
public static <D> Set<D> filterOutOverriding(@NotNull Set<D> candidateSet) {
//noinspection unchecked
return filterOverrides(candidateSet, Function.ID, Filtering.RETAIN_OVERRIDDEN);
}
@NotNull
public static <D> Set<D> filterOutOverridden(
@NotNull Set<D> candidateSet,
@NotNull Function<? super D, ? extends CallableDescriptor> transform
) {
return filterOverrides(candidateSet, transform, Filtering.RETAIN_OVERRIDING);
}
@NotNull
private static <D> Set<D> filterOverrides(
@NotNull Set<D> candidateSet,
@NotNull Function<? super D, ? extends CallableDescriptor> transform,
@NotNull Filtering filtering
) {
Set<D> candidates = Sets.newLinkedHashSet();
outerLoop:
for (D meD : candidateSet) {
CallableDescriptor me = transform.fun(meD);
for (D otherD : candidateSet) {
CallableDescriptor other = transform.fun(otherD);
if (me == other) continue;
if (filtering == Filtering.RETAIN_OVERRIDING) {
if (overrides(other, me)) {
continue outerLoop;
}
}
else if (filtering == Filtering.RETAIN_OVERRIDDEN) {
if (overrides(me, other)) {
continue outerLoop;
}
}
else {
throw new AssertionError("Unexpected Filtering object: " + filtering);
}
}
for (D otherD : candidates) {
CallableDescriptor other = transform.fun(otherD);
if (me.getOriginal() == other.getOriginal()
&& isOverridableBy(other, me).getResult() == OverrideCompatibilityInfo.Result.OVERRIDABLE
&& isOverridableBy(me, other).getResult() == OverrideCompatibilityInfo.Result.OVERRIDABLE) {
continue outerLoop;
}
}
candidates.add(meD);
}
return candidates;
}
public static <D extends CallableDescriptor> boolean overrides(@NotNull D f, @NotNull D g) {
CallableDescriptor originalG = g.getOriginal();
for (CallableDescriptor overriddenFunction : getAllOverriddenDescriptors(f)) {
if (originalG.equals(overriddenFunction.getOriginal())) return true;
}
return false;
}
public static Set<CallableDescriptor> getAllOverriddenDescriptors(CallableDescriptor f) {
Set<CallableDescriptor> overriddenDescriptors = Sets.newHashSet();
collectAllOverriddenDescriptors(f.getOriginal(), overriddenDescriptors);
return overriddenDescriptors;
}
private static void collectAllOverriddenDescriptors(
@NotNull CallableDescriptor current,
@NotNull Set<CallableDescriptor> result
) {
if (result.contains(current)) return;
for (CallableDescriptor descriptor : current.getOriginal().getOverriddenDescriptors()) {
collectAllOverriddenDescriptors(descriptor, result);
result.add(descriptor);
}
}
@NotNull
public static OverrideCompatibilityInfo isOverridableBy(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor) {
if (superDescriptor instanceof FunctionDescriptor) {
@@ -271,77 +179,6 @@ public class OverridingUtil {
}
}
public static boolean isReturnTypeOkForOverride(@NotNull JetTypeChecker typeChecker, @NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor) {
TypeSubstitutor typeSubstitutor = prepareTypeSubstitutor(superDescriptor, subDescriptor);
if (typeSubstitutor == null) return false;
JetType superReturnType = superDescriptor.getReturnType();
assert superReturnType != null;
JetType subReturnType = subDescriptor.getReturnType();
assert subReturnType != null;
JetType substitutedSuperReturnType = typeSubstitutor.substitute(superReturnType, Variance.OUT_VARIANCE);
assert substitutedSuperReturnType != null;
return typeChecker.isSubtypeOf(subReturnType, substitutedSuperReturnType);
}
@Nullable
private static TypeSubstitutor prepareTypeSubstitutor(@NotNull CallableDescriptor superDescriptor, @NotNull CallableDescriptor subDescriptor) {
List<TypeParameterDescriptor> superTypeParameters = superDescriptor.getTypeParameters();
List<TypeParameterDescriptor> subTypeParameters = subDescriptor.getTypeParameters();
if (subTypeParameters.size() != superTypeParameters.size()) return null;
Map<TypeConstructor, TypeProjection> substitutionContext = Maps.newHashMap();
for (int i = 0; i < superTypeParameters.size(); i++) {
substitutionContext.put(
superTypeParameters.get(i).getTypeConstructor(),
new TypeProjectionImpl(subTypeParameters.get(i).getDefaultType())
);
}
return TypeSubstitutor.create(substitutionContext);
}
public static boolean isPropertyTypeOkForOverride(
@NotNull JetTypeChecker typeChecker,
@NotNull PropertyDescriptor superDescriptor,
@NotNull PropertyDescriptor subDescriptor
) {
TypeSubstitutor typeSubstitutor = prepareTypeSubstitutor(superDescriptor, subDescriptor);
if (typeSubstitutor == null) return false;
JetType substitutedSuperReturnType = typeSubstitutor.substitute(superDescriptor.getType(), Variance.OUT_VARIANCE);
assert substitutedSuperReturnType != null;
return !superDescriptor.isVar() || typeChecker.equalTypes(subDescriptor.getType(), substitutedSuperReturnType);
}
/**
* Get overridden descriptors that are declarations, delegations or synthesized and are not dominated by any other such descriptor
*/
@NotNull
public static Set<CallableMemberDescriptor> getOverriddenDeclarations(@NotNull CallableMemberDescriptor descriptor) {
Set<CallableMemberDescriptor> result = new LinkedHashSet<CallableMemberDescriptor>();
getOverriddenDeclarations(descriptor, result);
return result;
}
private static void getOverriddenDeclarations(
@NotNull CallableMemberDescriptor descriptor,
@NotNull Set<CallableMemberDescriptor> result
) {
if (descriptor.getKind().isReal()) {
result.add(descriptor);
}
else {
if (descriptor.getOverriddenDescriptors().isEmpty()) {
throw new IllegalStateException("No overridden descriptors found for (fake override) " + descriptor);
}
for (CallableMemberDescriptor overridden : descriptor.getOverriddenDescriptors()) {
getOverriddenDeclarations(overridden, result);
}
}
}
public static void bindOverride(CallableMemberDescriptor fromCurrent, CallableMemberDescriptor fromSupertype) {
fromCurrent.addOverriddenDescriptor(fromSupertype);
@@ -593,6 +430,8 @@ public class OverridingUtil {
maxVisibility = visibility;
}
}
// TODO: IDEA seems to issue an incorrect warning here
//noinspection ConstantConditions
if (maxVisibility == null) {
return null;
}
@@ -698,70 +537,4 @@ public class OverridingUtil {
return message;
}
}
@NotNull
public static Set<CallableMemberDescriptor> getDirectlyOverriddenDeclarations(@NotNull CallableMemberDescriptor descriptor) {
Set<CallableMemberDescriptor> result = Sets.newHashSet();
Set<? extends CallableMemberDescriptor> overriddenDescriptors = descriptor.getOverriddenDescriptors();
for (CallableMemberDescriptor overriddenDescriptor : overriddenDescriptors) {
CallableMemberDescriptor.Kind kind = overriddenDescriptor.getKind();
if (kind == DECLARATION) {
result.add(overriddenDescriptor);
}
else if (kind == FAKE_OVERRIDE || kind == DELEGATION) {
result.addAll(getDirectlyOverriddenDeclarations(overriddenDescriptor));
}
else if (kind == SYNTHESIZED) {
//do nothing
}
else {
throw new AssertionError("Unexpected callable kind " + kind);
}
}
return filterOutOverridden(result);
}
@NotNull
public static Set<FunctionDescriptor> getDirectlyOverriddenDeclarations(@NotNull FunctionDescriptor descriptor) {
//noinspection unchecked
return (Set) getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor);
}
@NotNull
public static Set<PropertyDescriptor> getDirectlyOverriddenDeclarations(@NotNull PropertyDescriptor descriptor) {
//noinspection unchecked
return (Set) getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor);
}
@NotNull
public static <T extends CallableMemberDescriptor> Set<T> getAllOverriddenDeclarations(@NotNull T memberDescriptor) {
Set<T> result = Sets.newHashSet();
for (CallableMemberDescriptor overriddenDeclaration : memberDescriptor.getOverriddenDescriptors()) {
CallableMemberDescriptor.Kind kind = overriddenDeclaration.getKind();
if (kind == DECLARATION) {
//noinspection unchecked
result.add((T) overriddenDeclaration);
}
else if (kind == DELEGATION || kind == FAKE_OVERRIDE || kind == SYNTHESIZED) {
//do nothing
}
else {
throw new AssertionError("Unexpected callable kind " + kind);
}
//noinspection unchecked
result.addAll(getAllOverriddenDeclarations((T) overriddenDeclaration));
}
return result;
}
@NotNull
@ReadOnly
public static <T extends CallableMemberDescriptor> Set<T> getDeepestSuperDeclarations(T functionDescriptor) {
Set<T> overriddenDeclarations = getAllOverriddenDeclarations(functionDescriptor);
if (overriddenDeclarations.isEmpty()) {
return Collections.singleton(functionDescriptor);
}
return filterOutOverriding(overriddenDeclarations);
}
}
idea/src/org/jetbrains/jet/plugin/codeInsight/GotoSuperActionHandler.java
+2 -2
View File
@@ -36,7 +36,7 @@ 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.BindingContextUtils;
import org.jetbrains.jet.lang.resolve.OverridingUtil;
import org.jetbrains.jet.lang.resolve.OverrideResolver;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.plugin.JetBundle;
@@ -83,7 +83,7 @@ public class GotoSuperActionHandler implements CodeInsightActionHandler {
message = JetBundle.message("goto.super.class.chooser.title");
}
else if (descriptor instanceof CallableMemberDescriptor) {
superDescriptors = OverridingUtil.getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor);
superDescriptors = OverrideResolver.getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor);
if (descriptor instanceof PropertyDescriptor) {
message = JetBundle.message("goto.super.property.chooser.title");
}
idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideMethodsHandler.java
+2 -1
View File
@@ -22,6 +22,7 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.resolve.OverrideResolver;
import org.jetbrains.jet.lang.resolve.OverridingUtil;
import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil;
import org.jetbrains.jet.lang.types.JetType;
@@ -67,7 +68,7 @@ public class OverrideMethodsHandler extends OverrideImplementMethodsHandler {
}
// Only those actually inherited
Set<CallableMemberDescriptor> filteredMembers = OverridingUtil.filterOutOverridden(inheritedFunctions);
Set<CallableMemberDescriptor> filteredMembers = OverrideResolver.filterOutOverridden(inheritedFunctions);
// Group members with "the same" signature
Multimap<CallableMemberDescriptor, CallableMemberDescriptor> factoredMembers = LinkedHashMultimap.create();
idea/src/org/jetbrains/jet/plugin/highlighter/JetLineMarkerProvider.java
+4 -4
View File
@@ -58,7 +58,7 @@ import org.jetbrains.jet.lang.descriptors.Modality;
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.OverridingUtil;
import org.jetbrains.jet.lang.resolve.OverrideResolver;
import org.jetbrains.jet.lexer.JetTokens;
import org.jetbrains.jet.plugin.JetBundle;
import org.jetbrains.jet.plugin.JetPluginUtil;
@@ -246,7 +246,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
return null;
}
Set<? extends CallableMemberDescriptor> overriddenMembers = OverridingUtil.getDirectlyOverriddenDeclarations(
Set<? extends CallableMemberDescriptor> overriddenMembers = OverrideResolver.getDirectlyOverriddenDeclarations(
(CallableMemberDescriptor) descriptor);
if (overriddenMembers.size() == 0) {
return null;
@@ -289,7 +289,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
return;
}
Set<CallableMemberDescriptor> overriddenMembers = OverridingUtil
Set<CallableMemberDescriptor> overriddenMembers = OverrideResolver
.getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor);
if (overriddenMembers.size() == 0) {
return;
@@ -334,7 +334,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider {
return "";
}
Set<CallableMemberDescriptor> overriddenMembers = OverridingUtil
Set<CallableMemberDescriptor> overriddenMembers = OverrideResolver
.getDirectlyOverriddenDeclarations((CallableMemberDescriptor) descriptor);
if (overriddenMembers.size() == 0) {
return "";
idea/src/org/jetbrains/jet/plugin/refactoring/JetRefactoringUtil.java
+2 -2
View File
@@ -44,7 +44,7 @@ import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.BindingContextUtils;
import org.jetbrains.jet.lang.resolve.OverridingUtil;
import org.jetbrains.jet.lang.resolve.OverrideResolver;
import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightMethod;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.jet.lang.types.PackageType;
@@ -135,7 +135,7 @@ public class JetRefactoringUtil {
final Project project = declaration.getProject();
Map<PsiElement, CallableDescriptor> overriddenElementsToDescriptor = ContainerUtil.map2Map(
OverridingUtil.getAllOverriddenDescriptors(declarationDescriptor),
OverrideResolver.getAllOverriddenDescriptors(declarationDescriptor),
new Function<CallableDescriptor, Pair<PsiElement, CallableDescriptor>>() {
@Override
public Pair<PsiElement, CallableDescriptor> fun(CallableDescriptor descriptor) {
idea/src/org/jetbrains/jet/plugin/refactoring/changeSignature/JetChangeSignature.kt
+4 -4
View File
@@ -25,7 +25,6 @@ import com.intellij.openapi.util.Disposer
import com.intellij.psi.PsiElement
import org.jetbrains.jet.lang.descriptors.*
import org.jetbrains.jet.lang.resolve.BindingContext
import org.jetbrains.jet.lang.resolve.OverridingUtil
import org.jetbrains.jet.plugin.JetBundle
import org.jetbrains.jet.renderer.DescriptorRenderer
import java.util.*
@@ -35,6 +34,7 @@ import org.jetbrains.jet.plugin.codeInsight.DescriptorToDeclarationUtil
import org.jetbrains.jet.plugin.quickfix.QuickFixUtil
import com.intellij.CommonBundle
import com.intellij.refactoring.RefactoringBundle
import org.jetbrains.jet.lang.resolve.OverrideResolver
public trait JetChangeSignatureConfiguration {
fun configure(changeSignatureData: JetChangeSignatureData, bindingContext: BindingContext)
@@ -70,7 +70,7 @@ public class JetChangeSignature(val project: Project,
val closestModifiableDescriptors = getClosestModifiableDescriptors()
assert(!closestModifiableDescriptors.isEmpty(), "Should contain functionDescriptor itself or some of its super declarations")
val deepestSuperDeclarations = OverridingUtil.getDeepestSuperDeclarations(functionDescriptor)
val deepestSuperDeclarations = OverrideResolver.getDeepestSuperDeclarations(functionDescriptor)
if (ApplicationManager.getApplication()!!.isUnitTestMode()) {
showChangeSignatureDialog(deepestSuperDeclarations)
return
@@ -104,7 +104,7 @@ public class JetChangeSignature(val project: Project,
Collections.singleton(functionDescriptor)
}
DELEGATION, FAKE_OVERRIDE -> {
OverridingUtil.getDirectlyOverriddenDeclarations(functionDescriptor)
OverrideResolver.getDirectlyOverriddenDeclarations(functionDescriptor)
}
else -> {
throw IllegalStateException("Unexpected callable kind: ${functionDescriptor.getKind()}")
@@ -229,5 +229,5 @@ TestOnly public fun getChangeSignatureDialog(project: Project,
bindingContext: BindingContext,
defaultValueContext: PsiElement): JetChangeSignatureDialog? {
val jetChangeSignature = JetChangeSignature(project, functionDescriptor, configuration, bindingContext, defaultValueContext, null)
return jetChangeSignature.createChangeSignatureDialog(OverridingUtil.getDeepestSuperDeclarations(functionDescriptor))
return jetChangeSignature.createChangeSignatureDialog(OverrideResolver.getDeepestSuperDeclarations(functionDescriptor))
}
idea/src/org/jetbrains/jet/plugin/refactoring/rename/RenameKotlinPropertyProcessor.kt
+2 -1
View File
@@ -43,6 +43,7 @@ import com.intellij.openapi.ui.Messages
import org.jetbrains.jet.lang.resolve.OverridingUtil
import org.jetbrains.jet.lang.descriptors.PropertyDescriptor
import org.jetbrains.jet.asJava.namedUnwrappedElement
import org.jetbrains.jet.lang.resolve.OverrideResolver
public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
override fun canProcessElement(element: PsiElement): Boolean = element.namedUnwrappedElement is JetProperty
@@ -179,7 +180,7 @@ public class RenameKotlinPropertyProcessor : RenamePsiElementProcessor() {
if (descriptor != null) {
assert(descriptor is PropertyDescriptor, "Property descriptor is expected")
val supers = OverridingUtil.getDeepestSuperDeclarations(descriptor as PropertyDescriptor)
val supers = OverrideResolver.getDeepestSuperDeclarations(descriptor as PropertyDescriptor)
// Take one of supers for now - API doesn't support substitute to several elements (IDEA-48796)
val deepest = supers.first()
idea/src/org/jetbrains/jet/plugin/search/usagesSearch/utils.kt
+2 -9
View File
@@ -16,11 +16,8 @@
package org.jetbrains.jet.plugin.search.usagesSearch
import com.intellij.psi.PsiClass
import com.intellij.psi.PsiConstructorCall
import com.intellij.psi.PsiElement
import com.intellij.psi.PsiMethod
import com.intellij.psi.util.PsiTreeUtil
import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
import org.jetbrains.jet.lang.psi.*
@@ -29,21 +26,17 @@ import org.jetbrains.jet.lang.resolve.BindingContext
import org.jetbrains.jet.lang.resolve.BindingContextUtils
import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache
import com.intellij.psi.PsiReference
import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightMethod
import org.jetbrains.jet.lang.resolve.OverridingUtil
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor
import org.jetbrains.jet.lang.descriptors.ClassDescriptor
import org.jetbrains.jet.lang.resolve.DescriptorUtils
import org.jetbrains.jet.lang.descriptors.CallableDescriptor
import org.jetbrains.jet.plugin.findUsages.JetUsageTypeProvider
import org.jetbrains.jet.plugin.findUsages.JetUsageTypes
import com.intellij.usages.impl.rules.UsageType
import org.jetbrains.jet.asJava.LightClassUtil
import org.jetbrains.jet.lang.resolve.java.JvmAbi
import org.jetbrains.jet.codegen.PropertyCodegen
import org.jetbrains.jet.lang.descriptors.PropertyDescriptor
import org.jetbrains.jet.lang.resolve.java.jetAsJava.KotlinLightMethod
import org.jetbrains.jet.asJava.unwrapped
import org.jetbrains.jet.lang.resolve.OverrideResolver
// Navigation element of the resolved reference
// For property accessor return enclosing property
@@ -151,7 +144,7 @@ fun PsiReference.isCallableOverrideUsage(declaration: JetNamedDeclaration): Bool
return checkUsageVsOriginalDescriptor(declaration, decl2Desc) { (usageDescriptor, targetDescriptor) ->
usageDescriptor is CallableDescriptor && targetDescriptor is CallableDescriptor
&& OverridingUtil.overrides(usageDescriptor, targetDescriptor)
&& OverrideResolver.overrides(usageDescriptor, targetDescriptor)
}
}
idea/tests/org/jetbrains/jet/plugin/codeInsight/AbstractOverrideImplementTest.java
+2 -2
View File
@@ -38,7 +38,7 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.psi.JetClassOrObject;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.OverridingUtil;
import org.jetbrains.jet.lang.resolve.OverrideResolver;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.plugin.JetLightProjectDescriptor;
import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache;
@@ -134,7 +134,7 @@ public abstract class AbstractOverrideImplementTest extends LightCodeInsightFixt
@Override
public Boolean invoke(CallableMemberDescriptor descriptor) {
ClassDescriptor any = KotlinBuiltIns.getInstance().getAny();
for (CallableMemberDescriptor overridden : OverridingUtil.getOverriddenDeclarations(descriptor)) {
for (CallableMemberDescriptor overridden : OverrideResolver.getOverriddenDeclarations(descriptor)) {
if (overridden.getContainingDeclaration().equals(any)) {
return false;
}
js/js.translator/src/org/jetbrains/k2js/translate/intrinsic/functions/patterns/PatternBuilder.java
+3 -3
View File
@@ -20,7 +20,7 @@ import com.google.common.collect.Lists;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.OverridingUtil;
import org.jetbrains.jet.lang.resolve.OverrideResolver;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.k2js.translate.context.Namer;
@@ -175,14 +175,14 @@ public final class PatternBuilder {
return matches(functionDescriptor);
}
for (CallableMemberDescriptor real : OverridingUtil.getOverriddenDeclarations(functionDescriptor)) {
for (CallableMemberDescriptor real : OverrideResolver.getOverriddenDeclarations(functionDescriptor)) {
if (matches(real)) {
return true;
}
}
if (checkOverridden) {
for (CallableDescriptor overridden : OverridingUtil.getAllOverriddenDescriptors(functionDescriptor)) {
for (CallableDescriptor overridden : OverrideResolver.getAllOverriddenDescriptors(functionDescriptor)) {
if (matches(overridden)) {
return true;
}
js/js.translator/src/org/jetbrains/k2js/translate/utils/AnnotationsUtils.java
+2 -2
View File
@@ -24,7 +24,7 @@ import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
import org.jetbrains.jet.lang.resolve.OverridingUtil;
import org.jetbrains.jet.lang.resolve.OverrideResolver;
import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -80,7 +80,7 @@ public final class AnnotationsUtils {
isOverride((CallableMemberDescriptor) declarationDescriptor)) {
Set<CallableMemberDescriptor> overriddenDeclarations =
OverridingUtil.getAllOverriddenDeclarations((CallableMemberDescriptor) declarationDescriptor);
OverrideResolver.getAllOverriddenDeclarations((CallableMemberDescriptor) declarationDescriptor);
descriptors = ContainerUtil.mapNotNull(overriddenDeclarations, new Function<CallableMemberDescriptor, DeclarationDescriptor>() {
@Override
js/js.translator/src/org/jetbrains/k2js/translate/utils/TranslationUtils.java
+2 -2
View File
@@ -26,7 +26,7 @@ import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.OverridingUtil;
import org.jetbrains.jet.lang.resolve.OverrideResolver;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.JetType;
import org.jetbrains.k2js.translate.context.TemporaryConstVariable;
@@ -465,7 +465,7 @@ public final class TranslationUtils {
private static boolean isNativeOrOverrideNative(FunctionDescriptor descriptor) {
if (AnnotationsUtils.isNativeObject(descriptor)) return true;
Set<FunctionDescriptor> declarations = OverridingUtil.getAllOverriddenDeclarations(descriptor);
Set<FunctionDescriptor> declarations = OverrideResolver.getAllOverriddenDeclarations(descriptor);
for (FunctionDescriptor memberDescriptor : declarations) {
if (AnnotationsUtils.isNativeObject(memberDescriptor)) return true;
}