Refactor DelegationResolver so that lazy and eager resolve share the code

Also fix an exception in LazyClassMemberScope

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

@@ -20,6 +20,7 @@ import com.google.common.base.Predicate;
 import com.google.common.base.Predicates;
 import com.google.common.collect.Collections2;
 import com.google.common.collect.Lists;
+import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -27,15 +28,14 @@ import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
 import org.jetbrains.jet.lang.psi.JetDelegationSpecifier;
 import org.jetbrains.jet.lang.psi.JetDelegatorByExpressionSpecifier;
+import org.jetbrains.jet.lang.psi.JetTypeReference;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeUtils;
 
-import java.util.Collection;
+import java.util.*;
-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.*;
+import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE;
 
 public class DelegationResolver {
 
@@ -43,48 +43,75 @@ public class DelegationResolver {
     }
 
     @NotNull
-    public static Collection<CallableMemberDescriptor> generateDelegatedMembers(
+    public static <T extends CallableMemberDescriptor> Collection<T> generateDelegatedMembers(
+            @NotNull JetClassOrObject classOrObject,
+            @NotNull ClassDescriptor classDescriptor,
+            @NotNull Collection<? extends CallableDescriptor> existingMembers,
             @NotNull BindingTrace trace,
-            @NotNull JetClassOrObject jetClass,
+            @NotNull Callback<T> callback
-            @NotNull MutableClassDescriptor classDescriptor
     ) {
-        Collection<CallableMemberDescriptor> delegatedMembers = new HashSet<CallableMemberDescriptor>();
+        Collection<T> delegatedMembers = new HashSet<T>();
-        for (JetDelegationSpecifier delegationSpecifier : jetClass.getDelegationSpecifiers()) {
+        for (JetDelegationSpecifier delegationSpecifier : classOrObject.getDelegationSpecifiers()) {
             if (!(delegationSpecifier instanceof JetDelegatorByExpressionSpecifier)) {
                 continue;
             }
             JetDelegatorByExpressionSpecifier specifier = (JetDelegatorByExpressionSpecifier) delegationSpecifier;
-            JetType type = trace.get(BindingContext.TYPE, specifier.getTypeReference());
+            JetTypeReference typeReference = specifier.getTypeReference();
-            if (type == null) {
+            if (typeReference == null) {
                 continue;
             }
-            Collection<CallableMemberDescriptor> candidates =
+            JetType delegatedTraitType = callback.getTypeByTypeReference(typeReference);
-                    generateDelegationCandidates(classDescriptor, type, extractCallableMembers(type));
+            if (delegatedTraitType == null) {
-            for (CallableMemberDescriptor candidate : candidates) {
+                continue;
-                if (existingMemberOverridesDelegatedMember(classDescriptor, candidate)) {
-                    continue;
-                }
-                //only leave the first delegated member
-                if (checkClashWithOtherDelegatedMember(trace, jetClass, delegatedMembers, candidate)) {
-                    continue;
-                }
-
-                delegatedMembers.add(candidate);
             }
+            Collection<T> delegatesForTrait = generateDelegatesForOneTrait(classOrObject, classDescriptor, existingMembers,
+                                                            trace, callback, delegatedMembers, delegatedTraitType);
+            delegatedMembers.addAll(delegatesForTrait);
         }
         return delegatedMembers;
     }
 
-    private static boolean checkClashWithOtherDelegatedMember(
+    @NotNull
+    private static <T extends CallableMemberDescriptor> Collection<T> generateDelegatesForOneTrait(
+            @NotNull JetClassOrObject classOrObject,
+            @NotNull ClassDescriptor classDescriptor,
+            @NotNull Collection<? extends CallableDescriptor> existingMembers,
             @NotNull BindingTrace trace,
-            @NotNull JetClassOrObject jetClass,
+            @NotNull Callback<T> callback,
-            @NotNull Collection<CallableMemberDescriptor> delegatedMembers,
+            @NotNull Collection<T> existingDelegates,
-            @NotNull CallableMemberDescriptor candidate
+            @NotNull JetType delegatedTraitType
+    ) {
+        Collection<T> result = new HashSet<T>();
+        Collection<T> candidates = generateDelegationCandidates(classDescriptor, delegatedTraitType, callback);
+        for (T candidate : candidates) {
+            if (existingMemberOverridesDelegatedMember(candidate, existingMembers)) {
+                continue;
+            }
+            //only leave the first delegated member
+            if (checkClashWithOtherDelegatedMember(trace, classOrObject, existingDelegates, candidate)) {
+                continue;
+            }
+
+            result.add(candidate);
+        }
+        return result;
+    }
+
+    private static <T extends CallableMemberDescriptor> boolean checkClashWithOtherDelegatedMember(
+            @NotNull BindingTrace trace,
+            @Nullable JetClassOrObject jetClass,
+            @NotNull Collection<T> delegatedMembers,
+            @NotNull T 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));
+                if (jetClass != null) {
+                    PsiElement nameIdentifier = jetClass.getNameIdentifier();
+                    if (nameIdentifier != null) {
+                        trace.report(MANY_IMPL_MEMBER_NOT_IMPLEMENTED.on(nameIdentifier, jetClass, alreadyDelegatedMember));
+                    }
+                }
                 return true;
             }
         }
@@ -92,10 +119,10 @@ public class DelegationResolver {
     }
 
     private static boolean existingMemberOverridesDelegatedMember(
-            MutableClassDescriptor classDescriptor,
+            @NotNull CallableMemberDescriptor candidate,
-            CallableMemberDescriptor candidate
+            @NotNull Collection<? extends CallableDescriptor> existingMembers
     ) {
-        for (CallableMemberDescriptor existingDescriptor : classDescriptor.getAllCallableMembers()) {
+        for (CallableDescriptor existingDescriptor : existingMembers) {
             if (haveSameSignatures(existingDescriptor, candidate)) {
                 return true;
             }
@@ -104,12 +131,13 @@ public class DelegationResolver {
     }
 
     @NotNull
-    public static <T extends CallableMemberDescriptor> Collection<T> generateDelegationCandidates(
+    private static <T extends CallableMemberDescriptor> Collection<T> generateDelegationCandidates(
             @NotNull ClassDescriptor classDescriptor,
             @NotNull JetType delegatedTraitType,
-            @NotNull Collection<T> membersFromTrait
+            @NotNull Callback<T> callback
     ) {
-        Collection<T> descriptorsToDelegate = filterMembersFromSuperClassOfDelegatedTrait(delegatedTraitType, membersFromTrait);
+        Collection<T> membersFromTrait = callback.getMembersByType(delegatedTraitType);
+        Collection<T> descriptorsToDelegate = filterMembersFromSuperClassOfDelegatedTrait(delegatedTraitType, membersFromTrait, callback);
         Collection<T> result = Lists.newArrayList();
         for (T memberDescriptor : descriptorsToDelegate) {
             if (memberDescriptor.getModality().isOverridable()) {
@@ -126,9 +154,10 @@ public class DelegationResolver {
     @NotNull
     private static <T extends CallableMemberDescriptor> Collection<T> filterMembersFromSuperClassOfDelegatedTrait(
             @NotNull JetType delegatedTraitType,
-            @NotNull Collection<T> membersFromTrait
+            @NotNull Collection<T> membersFromTrait,
+            @NotNull Callback<T> callback
     ) {
-        final Collection<CallableMemberDescriptor> membersToSkip = getMembersFromClassSupertypeOfTrait(delegatedTraitType);
+        final Collection<T> membersToSkip = getMembersFromClassSupertypeOfTrait(delegatedTraitType, callback);
         return Collections2.filter(
                 membersFromTrait,
                 new Predicate<CallableMemberDescriptor>() {
@@ -149,7 +178,10 @@ public class DelegationResolver {
     }
 
     @NotNull
-    private static Collection<CallableMemberDescriptor> getMembersFromClassSupertypeOfTrait(@NotNull JetType delegateTraitType) {
+    private static <T extends CallableMemberDescriptor> Collection<T> getMembersFromClassSupertypeOfTrait(
+            @NotNull JetType delegateTraitType,
+            @NotNull Callback<T> callback
+    ) {
         JetType classSupertype = null;
         for (JetType supertype : TypeUtils.getAllSupertypes(delegateTraitType)) {
             if (isNotTrait(supertype.getConstructor().getDeclarationDescriptor())) {
@@ -157,14 +189,7 @@ public class DelegationResolver {
                 break;
             }
         }
-
+        return classSupertype != null ? callback.getMembersByType(classSupertype) : Collections.<T>emptyList();
-        return classSupertype != null ? extractCallableMembers(classSupertype) : Collections.<CallableMemberDescriptor>emptyList();
-    }
-
-    @SuppressWarnings("unchecked")
-    private static Collection<CallableMemberDescriptor> extractCallableMembers(JetType type) {
-        return (Collection) Collections2.filter(type.getMemberScope().getAllDescriptors(),
-                                                Predicates.instanceOf(CallableMemberDescriptor.class));
     }
 
     private static boolean isNotTrait(DeclarationDescriptor descriptor) {
@@ -177,10 +202,28 @@ public class DelegationResolver {
 
     public static void generateDelegatesInAClass(
             @NotNull MutableClassDescriptor classDescriptor,
-            @NotNull BindingTrace trace,
+            @NotNull final BindingTrace trace,
             @NotNull JetClassOrObject jetClassOrObject
     ) {
-        for (CallableMemberDescriptor descriptor : generateDelegatedMembers(trace, jetClassOrObject, classDescriptor)) {
+        Callback<CallableMemberDescriptor> eagerResolveCallback = new Callback<CallableMemberDescriptor>() {
+            @Nullable
+            @Override
+            public JetType getTypeByTypeReference(@NotNull JetTypeReference reference) {
+                return trace.get(BindingContext.TYPE, reference);
+            }
+
+            @NotNull
+            @Override
+            public Collection<CallableMemberDescriptor> getMembersByType(@NotNull JetType type) {
+                //noinspection unchecked
+                return (Collection) Collections2.filter(type.getMemberScope().getAllDescriptors(),
+                                                        Predicates.instanceOf(CallableMemberDescriptor.class));
+            }
+        };
+        Set<CallableMemberDescriptor> existingMembers = classDescriptor.getAllCallableMembers();
+        Collection<CallableMemberDescriptor> delegatedMembers =
+                generateDelegatedMembers(jetClassOrObject, classDescriptor, existingMembers, trace, eagerResolveCallback);
+        for (CallableMemberDescriptor descriptor : delegatedMembers) {
             if (descriptor instanceof PropertyDescriptor) {
                 PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
                 classDescriptor.getBuilder().addPropertyDescriptor(propertyDescriptor);
@@ -191,4 +234,12 @@ public class DelegationResolver {
             }
         }
     }
-}
+
+    public interface Callback<T extends CallableMemberDescriptor> {
+        @Nullable
+        JetType getTypeByTypeReference(@NotNull JetTypeReference reference);
+
+        @NotNull
+        Collection<T> getMembersByType(@NotNull JetType type);
+    }
+}

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java

@@ -42,7 +42,9 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Set;
 
-import static org.jetbrains.jet.lang.resolve.DelegationResolver.generateDelegationCandidates;
+import static org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor.Kind.DELEGATION;
+import static org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor.Kind.FAKE_OVERRIDE;
+import static org.jetbrains.jet.lang.resolve.DelegationResolver.generateDelegatedMembers;
 
 public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescriptor, ClassMemberDeclarationProvider> {
 
@@ -140,7 +142,7 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
         // TODO: this should be handled by lazy function descriptors
         Set<FunctionDescriptor> functions = super.getFunctions(name);
         for (FunctionDescriptor functionDescriptor : functions) {
-            if (functionDescriptor.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
+            if (functionDescriptor.getKind() != FAKE_OVERRIDE && functionDescriptor.getKind() != DELEGATION) {
                 OverrideResolver.resolveUnknownVisibilityForMember(functionDescriptor, resolveSession.getTrace());
             }
         }
@@ -153,7 +155,7 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
         for (JetType supertype : thisDescriptor.getTypeConstructor().getSupertypes()) {
             fromSupertypes.addAll(supertype.getMemberScope().getFunctions(name));
         }
-        generateDelegatingDescriptors(name, MemberExtractor.EXTRACT_FUNCTIONS, result);
+        result.addAll(generateDelegatingDescriptors(name, MemberExtractor.EXTRACT_FUNCTIONS, result));
         generateEnumClassObjectMethods(result, name);
         generateDataClassMethods(result, name);
         generateFakeOverrides(name, fromSupertypes, result, FunctionDescriptor.class);
@@ -213,9 +215,8 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
         Set<VariableDescriptor> properties = super.getProperties(name);
         for (VariableDescriptor variableDescriptor : properties) {
             PropertyDescriptor propertyDescriptor = (PropertyDescriptor) variableDescriptor;
-            if (propertyDescriptor.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
+            if (propertyDescriptor.getKind() == FAKE_OVERRIDE || propertyDescriptor.getKind() == DELEGATION) continue;
-                OverrideResolver.resolveUnknownVisibilityForMember(propertyDescriptor, resolveSession.getTrace());
+            OverrideResolver.resolveUnknownVisibilityForMember(propertyDescriptor, resolveSession.getTrace());
-            }
         }
         return properties;
     }
@@ -251,29 +252,40 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
         for (JetType supertype : thisDescriptor.getTypeConstructor().getSupertypes()) {
             fromSupertypes.addAll((Set) supertype.getMemberScope().getProperties(name));
         }
-        generateDelegatingDescriptors(name, MemberExtractor.EXTRACT_PROPERTIES, result);
+        result.addAll(generateDelegatingDescriptors(name, MemberExtractor.EXTRACT_PROPERTIES, result));
         generateFakeOverrides(name, fromSupertypes, (Set) result, PropertyDescriptor.class);
     }
 
-    private <T extends CallableMemberDescriptor> void generateDelegatingDescriptors(
+    @NotNull
-            @NotNull Name name,
+    private <T extends CallableMemberDescriptor> Collection<T> generateDelegatingDescriptors(
-            @NotNull MemberExtractor<T> extractor,
+            @NotNull final Name name,
-            @NotNull Set<? super T> result
+            @NotNull final MemberExtractor<T> extractor,
+            @NotNull Collection<? extends CallableDescriptor> existingDescriptors
     ) {
-        for (JetDelegationSpecifier delegationSpecifier : declarationProvider.getOwnerInfo().getDelegationSpecifiers()) {
+        //class objects do not have delegated members
-            if (delegationSpecifier instanceof JetDelegatorByExpressionSpecifier) {
+        if (thisDescriptor.getKind() == ClassKind.CLASS_OBJECT) {
-                JetDelegatorByExpressionSpecifier specifier = (JetDelegatorByExpressionSpecifier) delegationSpecifier;
+            return Collections.emptySet();
-                JetTypeReference typeReference = specifier.getTypeReference();
-                if (typeReference != null) {
-                    JetType supertype = resolveSession.getInjector().getTypeResolver().resolveType(
-                            thisDescriptor.getScopeForClassHeaderResolution(),
-                            typeReference,
-                            resolveSession.getTrace(),
-                            false);
-                    result.addAll(generateDelegationCandidates(thisDescriptor, supertype, extractor.extract(supertype, name)));
-                }
-            }
         }
+        DelegationResolver.Callback<T> lazyResolveCallback = new DelegationResolver.Callback<T>() {
+            @Nullable
+            @Override
+            public JetType getTypeByTypeReference(@NotNull JetTypeReference reference) {
+                return resolveSession.getInjector().getTypeResolver().resolveType(
+                        thisDescriptor.getScopeForClassHeaderResolution(),
+                        reference,
+                        resolveSession.getTrace(),
+                        false);
+            }
+
+            @NotNull
+            @Override
+            public Collection<T> getMembersByType(@NotNull JetType type) {
+                return extractor.extract(type, name);
+            }
+        };
+        JetClassOrObject classOrObject = declarationProvider.getOwnerInfo().getCorrespondingClassOrObject();
+        assert classOrObject != null : "Should not be null for non class object class.";
+        return generateDelegatedMembers(classOrObject, thisDescriptor, existingDescriptors, resolveSession.getTrace(), lazyResolveCallback);
     }
 
     @Override

compiler/testData/loadKotlin/fun/DeclaredMemberOverridesDelegated.kt

@@ -0,0 +1,13 @@
+package test
+
+trait X {
+    fun foo()
+}
+
+trait Y : X {
+}
+
+class B(val a: X) : X by a, Y {
+    override fun foo() {
+    }
+}

compiler/testData/loadKotlin/fun/DeclaredMemberOverridesDelegated.txt

@@ -0,0 +1,16 @@
+package test
+
+internal final class B : test.X, test.Y {
+    /*primary*/ public constructor B(/*0*/ a: test.X)
+    internal final val a: test.X
+        internal final fun <get-a>(): test.X
+    internal open override /*2*/ fun foo(): jet.Unit
+}
+
+internal trait X {
+    internal abstract fun foo(): jet.Unit
+}
+
+internal trait Y : test.X {
+    internal abstract override /*1*/ /*fake_override*/ fun foo(): jet.Unit
+}

compiler/tests/org/jetbrains/jet/descriptors/serialization/DescriptorSerializationTestGenerated.java

@@ -411,6 +411,11 @@ public class DescriptorSerializationTestGenerated extends AbstractDescriptorSeri
             JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), true);
         }
         
+        @TestMetadata("DeclaredMemberOverridesDelegated.kt")
+        public void testDeclaredMemberOverridesDelegated() throws Exception {
+            doTest("compiler/testData/loadKotlin/fun/DeclaredMemberOverridesDelegated.kt");
+        }
+        
         @TestMetadata("InheritMethodsDifferentReturnTypesAndVisibilities.kt")
         public void testInheritMethodsDifferentReturnTypesAndVisibilities() throws Exception {
             doTest("compiler/testData/loadKotlin/fun/InheritMethodsDifferentReturnTypesAndVisibilities.kt");

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadCompiledKotlinTestGenerated.java

@@ -630,6 +630,11 @@ public class LoadCompiledKotlinTestGenerated extends AbstractLoadCompiledKotlinT
             JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), true);
         }
         
+        @TestMetadata("DeclaredMemberOverridesDelegated.kt")
+        public void testDeclaredMemberOverridesDelegated() throws Exception {
+            doTestWithAccessors("compiler/testData/loadKotlin/fun/DeclaredMemberOverridesDelegated.kt");
+        }
+        
         @TestMetadata("InheritMethodsDifferentReturnTypesAndVisibilities.kt")
         public void testInheritMethodsDifferentReturnTypesAndVisibilities() throws Exception {
             doTestWithAccessors("compiler/testData/loadKotlin/fun/InheritMethodsDifferentReturnTypesAndVisibilities.kt");

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java

@@ -632,6 +632,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
                 JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("compiler/testData/loadKotlin/fun"), Pattern.compile("^(.+)\\.kt$"), true);
             }
             
+            @TestMetadata("DeclaredMemberOverridesDelegated.kt")
+            public void testDeclaredMemberOverridesDelegated() throws Exception {
+                doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadKotlin/fun/DeclaredMemberOverridesDelegated.kt");
+            }
+            
             @TestMetadata("InheritMethodsDifferentReturnTypesAndVisibilities.kt")
             public void testInheritMethodsDifferentReturnTypesAndVisibilities() throws Exception {
                 doTestCheckingPrimaryConstructorsAndAccessors("compiler/testData/loadKotlin/fun/InheritMethodsDifferentReturnTypesAndVisibilities.kt");