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

Refactor DelegationResolver

Browse Source 
Fix an issue in lazy resolve : filter out methods from delegated traits superclass
This commit is contained in:
Pavel V. Talanov
2013-09-17 13:24:06 +04:00
parent c3a5a9b7b5
commit 6fb7a79a1f
8 changed files with 192 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java
+118 -56
View File
@@ -32,67 +32,126 @@ import org.jetbrains.jet.lang.types.TypeUtils;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import static org.jetbrains.jet.lang.diagnostics.Errors.MANY_IMPL_MEMBER_NOT_IMPLEMENTED;
import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.*;
public class DelegationResolver {
private DelegationResolver() {}
private DelegationResolver() {
}
public static void addDelegatedMembers(@NotNull BindingTrace trace, @NotNull JetClassOrObject jetClass, @NotNull MutableClassDescriptor classDescriptor) {
@NotNull
public static Collection<CallableMemberDescriptor> generateDelegatedMembers(
@NotNull BindingTrace trace,
@NotNull JetClassOrObject jetClass,
@NotNull MutableClassDescriptor classDescriptor
) {
Collection<CallableMemberDescriptor> delegatedMembers = new HashSet<CallableMemberDescriptor>();
for (JetDelegationSpecifier delegationSpecifier : jetClass.getDelegationSpecifiers()) {
if (delegationSpecifier instanceof JetDelegatorByExpressionSpecifier) {
JetDelegatorByExpressionSpecifier specifier = (JetDelegatorByExpressionSpecifier) delegationSpecifier;
JetType type = trace.get(BindingContext.TYPE, specifier.getTypeReference());
if (type != null) {
final Collection<CallableMemberDescriptor> membersToSkip = getMembersFromClassSupertype(type);
Collection<CallableMemberDescriptor> descriptorsToDelegate = Collections2.filter(extractCallableMembers(type),
new Predicate<CallableMemberDescriptor>() {
@Override
public boolean apply(@Nullable CallableMemberDescriptor descriptor) {
for (CallableMemberDescriptor memberToSkip : membersToSkip) {
if (haveSameSignatures(memberToSkip, descriptor)) {
return false;
}
}
return true;
}
});
Collection<CallableMemberDescriptor> generatedDescriptors = generateDelegatedMembers(classDescriptor, descriptorsToDelegate);
outer:
for (CallableMemberDescriptor descriptor : generatedDescriptors) {
for (CallableMemberDescriptor existingDescriptor : classDescriptor.getAllCallableMembers()) {
if (OverridingUtil.isOverridableBy(existingDescriptor, descriptor).getResult() == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE) {
if (existingDescriptor.getKind() == CallableMemberDescriptor.Kind.DELEGATION) {
//trying to delegate to many traits with the same methods
trace.report(MANY_IMPL_MEMBER_NOT_IMPLEMENTED.on(jetClass.getNameIdentifier(), jetClass, existingDescriptor));
}
continue outer;
}
}
if (descriptor instanceof PropertyDescriptor) {
PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
classDescriptor.getBuilder().addPropertyDescriptor(propertyDescriptor);
}
else if (descriptor instanceof SimpleFunctionDescriptor) {
SimpleFunctionDescriptor functionDescriptor = (SimpleFunctionDescriptor) descriptor;
classDescriptor.getBuilder().addFunctionDescriptor(functionDescriptor);
}
}
if (!(delegationSpecifier instanceof JetDelegatorByExpressionSpecifier)) {
continue;
}
JetDelegatorByExpressionSpecifier specifier = (JetDelegatorByExpressionSpecifier) delegationSpecifier;
JetType type = trace.get(BindingContext.TYPE, specifier.getTypeReference());
if (type == null) {
continue;
}
Collection<CallableMemberDescriptor> candidates =
generateDelegationCandidates(classDescriptor, type, extractCallableMembers(type));
for (CallableMemberDescriptor candidate : candidates) {
if (existingMemberOverridesDelegatedMember(classDescriptor, candidate)) {
continue;
}
//only leave the first delegated member
if (checkClashWithOtherDelegatedMember(trace, jetClass, delegatedMembers, candidate)) {
continue;
}
delegatedMembers.add(candidate);
}
}
return delegatedMembers;
}
private static boolean haveSameSignatures(CallableDescriptor memberOne, CallableDescriptor memberTwo) {
return OverridingUtil.isOverridableBy(memberOne, memberTwo).getResult() == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE;
private static boolean checkClashWithOtherDelegatedMember(
@NotNull BindingTrace trace,
@NotNull JetClassOrObject jetClass,
@NotNull Collection<CallableMemberDescriptor> delegatedMembers,
@NotNull CallableMemberDescriptor candidate
) {
for (CallableMemberDescriptor alreadyDelegatedMember : delegatedMembers) {
if (haveSameSignatures(alreadyDelegatedMember, candidate)) {
//trying to delegate to many traits with the same methods
trace.report(MANY_IMPL_MEMBER_NOT_IMPLEMENTED.on(jetClass.getNameIdentifier(), jetClass, alreadyDelegatedMember));
return true;
}
}
return false;
}
private static Collection<CallableMemberDescriptor> getMembersFromClassSupertype(JetType type) {
private static boolean existingMemberOverridesDelegatedMember(
MutableClassDescriptor classDescriptor,
CallableMemberDescriptor candidate
) {
for (CallableMemberDescriptor existingDescriptor : classDescriptor.getAllCallableMembers()) {
if (haveSameSignatures(existingDescriptor, candidate)) {
return true;
}
}
return false;
}
@NotNull
public static <T extends CallableMemberDescriptor> Collection<T> generateDelegationCandidates(
@NotNull ClassDescriptor classDescriptor,
@NotNull JetType delegatedTraitType,
@NotNull Collection<T> membersFromTrait
) {
Collection<T> descriptorsToDelegate = filterMembersFromSuperClassOfDelegatedTrait(delegatedTraitType, membersFromTrait);
Collection<T> result = Lists.newArrayList();
for (T memberDescriptor : descriptorsToDelegate) {
if (memberDescriptor.getModality().isOverridable()) {
Modality modality = DescriptorUtils.convertModality(memberDescriptor.getModality(), true);
@SuppressWarnings("unchecked")
T copy = (T) memberDescriptor.copy(classDescriptor, modality, memberDescriptor.getVisibility(),
CallableMemberDescriptor.Kind.DELEGATION, false);
result.add(copy);
}
}
return result;
}
@NotNull
private static <T extends CallableMemberDescriptor> Collection<T> filterMembersFromSuperClassOfDelegatedTrait(
@NotNull JetType delegatedTraitType,
@NotNull Collection<T> membersFromTrait
) {
final Collection<CallableMemberDescriptor> membersToSkip = getMembersFromClassSupertypeOfTrait(delegatedTraitType);
return Collections2.filter(
membersFromTrait,
new Predicate<CallableMemberDescriptor>() {
@Override
public boolean apply(@Nullable CallableMemberDescriptor descriptor) {
for (CallableMemberDescriptor memberToSkip : membersToSkip) {
if (haveSameSignatures(memberToSkip, descriptor)) {
return false;
}
}
return true;
}
});
}
private static boolean haveSameSignatures(@NotNull CallableDescriptor memberOne, @NotNull CallableDescriptor memberTwo) {
return OverridingUtil.isOverridableBy(memberOne, memberTwo).getResult() == OVERRIDABLE;
}
@NotNull
private static Collection<CallableMemberDescriptor> getMembersFromClassSupertypeOfTrait(@NotNull JetType delegateTraitType) {
JetType classSupertype = null;
for (JetType supertype : TypeUtils.getAllSupertypes(type)) {
for (JetType supertype : TypeUtils.getAllSupertypes(delegateTraitType)) {
if (isNotTrait(supertype.getConstructor().getDeclarationDescriptor())) {
classSupertype = supertype;
break;
@@ -116,17 +175,20 @@ public class DelegationResolver {
return false;
}
public static <T extends CallableMemberDescriptor> Collection<T> generateDelegatedMembers(DeclarationDescriptor newOwner, Collection<T> delegatedDescriptors) {
Collection<CallableMemberDescriptor> result = Lists.newArrayList();
for (CallableMemberDescriptor memberDescriptor : delegatedDescriptors) {
if (memberDescriptor.getModality().isOverridable()) {
Modality modality = DescriptorUtils.convertModality(memberDescriptor.getModality(), true);
CallableMemberDescriptor copy =
memberDescriptor.copy(newOwner, modality, memberDescriptor.getVisibility(), CallableMemberDescriptor.Kind.DELEGATION, false);
result.add(copy);
public static void generateDelegatesInAClass(
@NotNull MutableClassDescriptor classDescriptor,
@NotNull BindingTrace trace,
@NotNull JetClassOrObject jetClassOrObject
) {
for (CallableMemberDescriptor descriptor : generateDelegatedMembers(trace, jetClassOrObject, classDescriptor)) {
if (descriptor instanceof PropertyDescriptor) {
PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
classDescriptor.getBuilder().addPropertyDescriptor(propertyDescriptor);
}
else if (descriptor instanceof SimpleFunctionDescriptor) {
SimpleFunctionDescriptor functionDescriptor = (SimpleFunctionDescriptor) descriptor;
classDescriptor.getBuilder().addFunctionDescriptor(functionDescriptor);
}
}
//noinspection unchecked
return (Collection) result;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java
+3 -3
View File
@@ -114,9 +114,9 @@ public class OverrideResolver {
}
}
PsiElement declaration = BindingContextUtils.classDescriptorToDeclaration(trace.getBindingContext(), classDescriptor);
DelegationResolver.addDelegatedMembers(trace, (JetClassOrObject) declaration, classDescriptor);
JetClassOrObject classOrObject = (JetClassOrObject) BindingContextUtils
.classDescriptorToDeclaration(trace.getBindingContext(), classDescriptor);
DelegationResolver.generateDelegatesInAClass(classDescriptor, trace, classOrObject);
generateOverridesInAClass(classDescriptor);
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java
+3 -3
View File
@@ -42,6 +42,8 @@ import java.util.Collections;
import java.util.List;
import java.util.Set;
import static org.jetbrains.jet.lang.resolve.DelegationResolver.generateDelegationCandidates;
public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescriptor, ClassMemberDeclarationProvider> {
@NotNull
@@ -268,9 +270,7 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
typeReference,
resolveSession.getTrace(),
false);
Collection<T> descriptors =
DelegationResolver.generateDelegatedMembers(thisDescriptor, extractor.extract(supertype, name));
result.addAll(descriptors);
result.addAll(generateDelegationCandidates(thisDescriptor, supertype, extractor.extract(supertype, name)));
}
}
}
compiler/testData/loadKotlin/fun/NoDelegationForFunctionInheritedFromTraitSuperClass.kt
+23
View File
@@ -0,0 +1,23 @@
package test
abstract class A {
abstract fun foo()
}
trait X : A {
fun bar() {
}
}
open class B() : A() {
override fun foo() {
}
}
class C() : A(), X {
override fun foo() {
}
}
class D(val c: C) : B(), X by c {
}
compiler/testData/loadKotlin/fun/NoDelegationForFunctionInheritedFromTraitSuperClass.txt
+30
View File
@@ -0,0 +1,30 @@
package test
internal abstract class A {
/*primary*/ public constructor A()
internal abstract fun foo(): jet.Unit
}
internal open class B : test.A {
/*primary*/ public constructor B()
internal open override /*1*/ fun foo(): jet.Unit
}
internal final class C : test.A, test.X {
/*primary*/ public constructor C()
internal open override /*1*/ /*fake_override*/ fun bar(): jet.Unit
internal open override /*2*/ fun foo(): jet.Unit
}
internal final class D : test.B, test.X {
/*primary*/ public constructor D(/*0*/ c: test.C)
internal final val c: test.C
internal final fun <get-c>(): test.C
internal open override /*1*/ /*delegation*/ fun bar(): jet.Unit
internal open override /*2*/ /*fake_override*/ fun foo(): jet.Unit
}
internal trait X : test.A {
internal open fun bar(): jet.Unit
internal abstract override /*1*/ /*fake_override*/ fun foo(): jet.Unit
}
compiler/tests/org/jetbrains/jet/descriptors/serialization/DescriptorSerializationTestGenerated.java
+5
View File
@@ -426,6 +426,11 @@ public class DescriptorSerializationTestGenerated extends AbstractDescriptorSeri
doTest("compiler/testData/loadKotlin/fun/InheritValsDifferentTypes.kt");
}
@TestMetadata("NoDelegationForFunctionInheritedFromTraitSuperClass.kt")
public void testNoDelegationForFunctionInheritedFromTraitSuperClass() throws Exception {
doTest("compiler/testData/loadKotlin/fun/NoDelegationForFunctionInheritedFromTraitSuperClass.kt");
}
@TestMetadata("NoSamAdapter.kt")
public void testNoSamAdapter() throws Exception {
doTest("compiler/testData/loadKotlin/fun/NoSamAdapter.kt");
compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java
+5
View File
@@ -645,6 +645,11 @@ public class LoadCompiledKotlinTestGenerated extends AbstractLoadCompiledKotlinT
doTestWithAccessors("compiler/testData/loadKotlin/fun/InheritValsDifferentTypes.kt");
}
@TestMetadata("NoDelegationForFunctionInheritedFromTraitSuperClass.kt")
public void testNoDelegationForFunctionInheritedFromTraitSuperClass() throws Exception {
doTestWithAccessors("compiler/testData/loadKotlin/fun/NoDelegationForFunctionInheritedFromTraitSuperClass.kt");
}
@TestMetadata("NoSamAdapter.kt")
public void testNoSamAdapter() throws Exception {
doTestWithAccessors("compiler/testData/loadKotlin/fun/NoSamAdapter.kt");
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java
+5
View File
@@ -647,6 +647,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadKotlin/fun/InheritValsDifferentTypes.kt");
}
@TestMetadata("NoDelegationForFunctionInheritedFromTraitSuperClass.kt")
public void testNoDelegationForFunctionInheritedFromTraitSuperClass() throws Exception {
doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadKotlin/fun/NoDelegationForFunctionInheritedFromTraitSuperClass.kt");
}
@TestMetadata("NoSamAdapter.kt")
public void testNoSamAdapter() throws Exception {
doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadKotlin/fun/NoSamAdapter.kt");