JET-49 Resolve extension functions with generic receivers

idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java

 package org.jetbrains.jet.lang.descriptors;
 
-import com.google.common.base.Function;
-import com.google.common.collect.*;
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.common.collect.Maps;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.WritableScope;
+import org.jetbrains.jet.lang.resolve.WritableScopeImpl;
 import org.jetbrains.jet.lang.types.*;
 
 import java.util.*;
@@ -230,59 +234,4 @@ public class FunctionDescriptorUtil {
         return OverrideCompatibilityInfo.success();
     }
 
-    @NotNull
-    public static FunctionGroup filteredFunctionGroup(@NotNull final FunctionGroup functionGroup, @NotNull final Function<FunctionDescriptor, Boolean> criterion) {
-        return new FunctionGroup() {
-            @NotNull
-            @Override
-            public String getName() {
-                return functionGroup.getName();
-            }
-
-            @NotNull
-            @Override
-            public OverloadResolutionResult getPossiblyApplicableFunctions(@NotNull List<JetType> typeArguments, @NotNull List<JetType> positionedValueArgumentTypes) {
-                OverloadResolutionResult possiblyApplicableFunctions = functionGroup.getPossiblyApplicableFunctions(typeArguments, positionedValueArgumentTypes);
-                List<FunctionDescriptor> functionDescriptors = Lists.newArrayList(possiblyApplicableFunctions.getFunctionDescriptors());
-                for (Iterator<FunctionDescriptor> iterator = functionDescriptors.iterator(); iterator.hasNext(); ) {
-                    FunctionDescriptor functionDescriptor = iterator.next();
-                    if (!criterion.apply(functionDescriptor)) {
-                        iterator.remove();
-                    }
-                }
-                if (functionDescriptors.isEmpty()) {
-                    return OverloadResolutionResult.nameNotFound();
-                }
-                if (possiblyApplicableFunctions.isSuccess() || possiblyApplicableFunctions.isAmbiguity()) {
-                    if (functionDescriptors.size() == 1) {
-                        return OverloadResolutionResult.success(functionDescriptors.get(0));
-                    }
-                    return OverloadResolutionResult.ambiguity(functionDescriptors);
-                }
-                if (functionDescriptors.size() == 1) {
-                    return OverloadResolutionResult.singleFunctionArgumentMismatch(functionDescriptors.get(0));
-                }
-                return OverloadResolutionResult.ambiguity(functionDescriptors);
-            }
-
-            @Override
-            public boolean isEmpty() {
-                return getFunctionDescriptors().isEmpty();
-            }
-
-            @NotNull
-            @Override
-            public Set<FunctionDescriptor> getFunctionDescriptors() {
-                Set<FunctionDescriptor> functionDescriptors = Sets.newHashSet(functionGroup.getFunctionDescriptors());
-                for (Iterator<FunctionDescriptor> iterator = functionDescriptors.iterator(); iterator.hasNext(); ) {
-                    FunctionDescriptor functionDescriptor = iterator.next();
-                    if (!criterion.apply(functionDescriptor)) {
-                        iterator.remove();
-                    }
-                }
-
-                return functionDescriptors;
-            }
-        };
-    }
 }

idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java

@@ -1394,13 +1394,13 @@ public class JetTypeInferrer {
         }
 
         private JetType getSelectorReturnType(JetType receiverType, JetExpression selectorExpression) {
-            JetScope compositeScope = new ScopeWithReceiver(scope, receiverType, semanticServices.getTypeChecker());
             if (selectorExpression instanceof JetCallExpression) {
                 JetCallExpression callExpression = (JetCallExpression) selectorExpression;
-                OverloadDomain overloadDomain = getOverloadDomain(receiverType, compositeScope, callExpression.getCalleeExpression(), callExpression.getValueArgumentList());
+                OverloadDomain overloadDomain = getOverloadDomain(receiverType, scope, callExpression.getCalleeExpression(), callExpression.getValueArgumentList());
                 return resolveOverloads(scope, callExpression, overloadDomain);
             }
             else if (selectorExpression instanceof JetSimpleNameExpression) {
+                JetScope compositeScope = new ScopeWithReceiver(scope, receiverType, semanticServices.getTypeChecker());
                 return getType(compositeScope, selectorExpression, false);
             }
             else if (selectorExpression != null) {