diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java
index 852453f93cb..a7e6384f6b7 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java
@@ -16,8 +16,11 @@
 
 package org.jetbrains.jet.lang.types.expressions;
 
+import com.google.common.base.Predicate;
+import com.google.common.collect.Collections2;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Pair;
 import com.intellij.psi.PsiElement;
@@ -43,6 +46,7 @@ import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScopeUtils;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
@@ -240,6 +244,32 @@ public class ExpressionTypingUtils {
         return callableExtensionDescriptors;
     }
 
+    public static Collection<CallableDescriptor> filterCallableExtensions(
+            @NotNull final ReceiverValue receiverArgument, @NotNull Collection<CallableDescriptor> extensions) {
+        final Map<JetType, Boolean> filterCache = new HashMap<JetType, Boolean>();
+
+        return Collections2.filter(extensions,
+            new Predicate<CallableDescriptor>() {
+                @Override
+                public boolean apply(CallableDescriptor callableDescriptor) {
+                    ReceiverParameterDescriptor receiverParameter = callableDescriptor.getReceiverParameter();
+                    if (receiverParameter == null) {
+                        return false;
+                    }
+
+                    JetType type = receiverParameter.getType();
+                    if (filterCache.containsKey(type)) {
+                        return filterCache.get(type);
+                    }
+
+                    boolean isExtensionCallable = checkIsExtensionCallable(receiverArgument, callableDescriptor);
+                    filterCache.put(type, isExtensionCallable);
+
+                    return isExtensionCallable;
+                }
+            });
+    }
+
     /*
     * Checks if receiver declaration could be resolved to call expected receiver.
     */
@@ -294,7 +324,7 @@ public class ExpressionTypingUtils {
     }
 
     private static Set<Name> collectUsedTypeNames(@NotNull JetType jetType) {
-        Set<Name> typeNames = new HashSet<Name>();
+        Set<Name> typeNames = Sets.newHashSet();
 
         ClassifierDescriptor descriptor = jetType.getConstructor().getDeclarationDescriptor();
         if (descriptor != null) {
diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/checker/TypeCheckingProcedure.java b/core/descriptors/src/org/jetbrains/jet/lang/types/checker/TypeCheckingProcedure.java
index cacaf3edd7b..1a8677fdd1c 100644
--- a/core/descriptors/src/org/jetbrains/jet/lang/types/checker/TypeCheckingProcedure.java
+++ b/core/descriptors/src/org/jetbrains/jet/lang/types/checker/TypeCheckingProcedure.java
@@ -39,11 +39,11 @@ public class TypeCheckingProcedure {
     // as the second parameter, applying the substitution of type arguments to it
     @Nullable
     public static JetType findCorrespondingSupertype(@NotNull JetType subtype, @NotNull JetType supertype, @NotNull TypingConstraints typingConstraints) {
-        TypeConstructor constructor = subtype.getConstructor();
-        if (typingConstraints.assertEqualTypeConstructors(constructor, supertype.getConstructor())) {
+        TypeConstructor subtypeConstructor = subtype.getConstructor();
+        if (typingConstraints.assertEqualTypeConstructors(subtypeConstructor, supertype.getConstructor())) {
             return subtype;
         }
-        for (JetType immediateSupertype : constructor.getSupertypes()) {
+        for (JetType immediateSupertype : subtypeConstructor.getSupertypes()) {
             JetType correspondingSupertype = findCorrespondingSupertype(immediateSupertype, supertype, typingConstraints);
             if (correspondingSupertype != null) {
                 return TypeSubstitutor.create(subtype).safeSubstitute(correspondingSupertype, Variance.INVARIANT);
diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/TipsManager.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/TipsManager.java
index 2a78d3e0691..c5c61f669eb 100644
--- a/idea/src/org/jetbrains/jet/plugin/codeInsight/TipsManager.java
+++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/TipsManager.java
@@ -194,7 +194,7 @@ public final class TipsManager {
     private static Set<DeclarationDescriptor> includeExternalCallableExtensions(
             @NotNull Collection<DeclarationDescriptor> descriptors,
             @NotNull JetScope externalScope,
-            @NotNull final ReceiverValue receiverValue
+            @NotNull ReceiverValue receiverValue
     ) {
         // It's impossible to add extension function for package
         JetType receiverType = receiverValue.getType();
@@ -203,15 +203,7 @@ public final class TipsManager {
         }
 
         Set<DeclarationDescriptor> descriptorsSet = Sets.newHashSet(descriptors);
-
-        descriptorsSet.addAll(
-                Collections2.filter(JetScopeUtils.getAllExtensions(externalScope),
-                                    new Predicate<CallableDescriptor>() {
-                                        @Override
-                                        public boolean apply(CallableDescriptor callableDescriptor) {
-                                            return ExpressionTypingUtils.checkIsExtensionCallable(receiverValue, callableDescriptor);
-                                        }
-                                    }));
+        descriptorsSet.addAll(ExpressionTypingUtils.filterCallableExtensions(receiverValue, JetScopeUtils.getAllExtensions(externalScope)));
 
         return descriptorsSet;
     }