Delegation resolved refactored for reuse

BindingContext.DELEGATED key replaced with kind == DELEGATION

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

@@ -16,9 +16,7 @@
 
 package org.jetbrains.jet.lang.resolve;
 
-import com.intellij.openapi.util.Pair;
 import com.intellij.psi.PsiElement;
-import com.intellij.util.PlusMinus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -104,7 +102,6 @@ public interface BindingContext {
     /** Has type of current expression has been already resolved */
     WritableSlice<JetExpression, Boolean> PROCESSED = Slices.createSimpleSetSlice();
     WritableSlice<JetElement, Boolean> STATEMENT = Slices.createRemovableSetSlice();
-    WritableSlice<CallableMemberDescriptor, Boolean> DELEGATED = Slices.createRemovableSetSlice();
 
     WritableSlice<VariableDescriptor, Boolean> CAPTURED_IN_CLOSURE = Slices.createSimpleSetSlice();
     

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

@@ -16,16 +16,18 @@
 
 package org.jetbrains.jet.lang.resolve;
 
+import com.google.common.base.Predicates;
+import com.google.common.collect.Collections2;
+import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.types.JetType;
 
 import javax.inject.Inject;
+import java.util.Collection;
 import java.util.Map;
 
-import static org.jetbrains.jet.lang.resolve.BindingContext.DELEGATED;
-
 /**
  * @author abreslav
  */
@@ -67,24 +69,19 @@ public class DelegationResolver {
                 JetDelegatorByExpressionSpecifier specifier = (JetDelegatorByExpressionSpecifier) delegationSpecifier;
                 JetType type = trace.get(BindingContext.TYPE, specifier.getTypeReference());
                 if (type != null) {
-                    for (DeclarationDescriptor declarationDescriptor : type.getMemberScope().getAllDescriptors()) {
+                    @SuppressWarnings("unchecked")
-                        if (declarationDescriptor instanceof PropertyDescriptor) {
+                    Collection<CallableMemberDescriptor> callableDescriptors = (Collection) Collections2.filter(
-                            PropertyDescriptor propertyDescriptor = (PropertyDescriptor) declarationDescriptor;
+                            type.getMemberScope().getAllDescriptors(),
-                            if (propertyDescriptor.getModality().isOverridable()) {
+                            Predicates.instanceOf(CallableMemberDescriptor.class));
-                                Modality modality = DescriptorUtils.convertModality(propertyDescriptor.getModality(), true);
+                    Collection<CallableMemberDescriptor> descriptors = generateDelegatedMembers(classDescriptor, callableDescriptors);
-                                PropertyDescriptor copy = propertyDescriptor.copy(classDescriptor, modality, false, CallableMemberDescriptor.Kind.DELEGATION, true);
+                    for (CallableMemberDescriptor descriptor : descriptors) {
-                                classDescriptor.getBuilder().addPropertyDescriptor(copy);
+                        if (descriptor instanceof PropertyDescriptor) {
-                                trace.record(DELEGATED, copy);
+                            PropertyDescriptor propertyDescriptor = (PropertyDescriptor) descriptor;
-                            }
+                            classDescriptor.getBuilder().addPropertyDescriptor(propertyDescriptor);
                         }
-                        else if (declarationDescriptor instanceof SimpleFunctionDescriptor) {
+                        else if (descriptor instanceof SimpleFunctionDescriptor) {
-                            SimpleFunctionDescriptor functionDescriptor = (SimpleFunctionDescriptor) declarationDescriptor;
+                            SimpleFunctionDescriptor functionDescriptor = (SimpleFunctionDescriptor) descriptor;
-                            if (functionDescriptor.getModality().isOverridable()) {
+                            classDescriptor.getBuilder().addFunctionDescriptor(functionDescriptor);
-                                Modality modality = DescriptorUtils.convertModality(functionDescriptor.getModality(), true);
-                                SimpleFunctionDescriptor copy = functionDescriptor.copy(classDescriptor, modality, false, CallableMemberDescriptor.Kind.DELEGATION, true);
-                                classDescriptor.getBuilder().addFunctionDescriptor(copy);
-                                trace.record(DELEGATED, copy);
-                            }
                         }
                     }
                 }
@@ -92,4 +89,17 @@ public class DelegationResolver {
         }
     }
 
+    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, false, CallableMemberDescriptor.Kind.DELEGATION, true);
+                result.add(copy);
+            }
+        }
+        //noinspection unchecked
+        return (Collection) result;
+    }
 }

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

@@ -31,8 +31,6 @@ import javax.inject.Inject;
 import java.util.Collection;
 import java.util.Map;
 
-import static org.jetbrains.jet.lang.resolve.BindingContext.DELEGATED;
-
 /**
  * @author Stepan Koltsov
  */
@@ -196,7 +194,7 @@ public class OverloadResolver {
                 if (!overloadable.isSuccess()) {
                     JetDeclaration jetDeclaration = (JetDeclaration) BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), member);
                     if (jetDeclaration == null) {
-                        assert trace.get(DELEGATED, member);
+                        assert member.getKind() == CallableMemberDescriptor.Kind.DELEGATION;
                         return;
                     }
 

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

@@ -39,7 +39,6 @@ import javax.inject.Inject;
 import java.util.*;
 
 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
-import static org.jetbrains.jet.lang.resolve.BindingContext.DELEGATED;
 import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE;
 
 /**
@@ -392,11 +391,11 @@ public class OverrideResolver {
     private void checkOverrideForMember(@NotNull CallableMemberDescriptor declared) {
         JetNamedDeclaration member = (JetNamedDeclaration) BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), declared);
         if (member == null) {
-            Boolean delegated = trace.get(DELEGATED, declared);
+            if (declared.getKind() != CallableMemberDescriptor.Kind.DELEGATION)
-            if (delegated == null || !delegated)
                 throw new IllegalStateException(
                         "decriptor is not resolved to declaration" +
-                        " and it is not delegate: " + declared + ", DELEGATED: " + delegated);
+                        " and it is not delegate: " + declared + ", DELEGATED: " +
+                        (declared.getKind() == CallableMemberDescriptor.Kind.DELEGATION));
             return;
         }