From 3f2d65762bbe2673fb648114e1d0e32e45b59dc6 Mon Sep 17 00:00:00 2001 From: Nikolay Krasko Date: Wed, 25 Jun 2014 14:52:41 +0400 Subject: [PATCH] Revert temporary commit "-- Attempt to fix completion for extensions" This reverts commit b70f9cd6750827cee4ef42dbe493b2a6c321a58f. --- .../expressions/ExpressionTypingUtils.java | 32 +------------------ .../types/checker/TypeCheckingProcedure.java | 6 ++-- .../jet/plugin/codeInsight/TipsManager.java | 12 +++++-- 3 files changed, 14 insertions(+), 36 deletions(-) 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 a7e6384f6b7..852453f93cb 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,11 +16,8 @@ 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; @@ -46,7 +43,6 @@ 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; @@ -244,32 +240,6 @@ public class ExpressionTypingUtils { return callableExtensionDescriptors; } - public static Collection filterCallableExtensions( - @NotNull final ReceiverValue receiverArgument, @NotNull Collection extensions) { - final Map filterCache = new HashMap(); - - return Collections2.filter(extensions, - new Predicate() { - @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. */ @@ -324,7 +294,7 @@ public class ExpressionTypingUtils { } private static Set collectUsedTypeNames(@NotNull JetType jetType) { - Set typeNames = Sets.newHashSet(); + Set typeNames = new HashSet(); 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 1a8677fdd1c..cacaf3edd7b 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 subtypeConstructor = subtype.getConstructor(); - if (typingConstraints.assertEqualTypeConstructors(subtypeConstructor, supertype.getConstructor())) { + TypeConstructor constructor = subtype.getConstructor(); + if (typingConstraints.assertEqualTypeConstructors(constructor, supertype.getConstructor())) { return subtype; } - for (JetType immediateSupertype : subtypeConstructor.getSupertypes()) { + for (JetType immediateSupertype : constructor.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 c5c61f669eb..2a78d3e0691 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 includeExternalCallableExtensions( @NotNull Collection descriptors, @NotNull JetScope externalScope, - @NotNull ReceiverValue receiverValue + @NotNull final ReceiverValue receiverValue ) { // It's impossible to add extension function for package JetType receiverType = receiverValue.getType(); @@ -203,7 +203,15 @@ public final class TipsManager { } Set descriptorsSet = Sets.newHashSet(descriptors); - descriptorsSet.addAll(ExpressionTypingUtils.filterCallableExtensions(receiverValue, JetScopeUtils.getAllExtensions(externalScope))); + + descriptorsSet.addAll( + Collections2.filter(JetScopeUtils.getAllExtensions(externalScope), + new Predicate() { + @Override + public boolean apply(CallableDescriptor callableDescriptor) { + return ExpressionTypingUtils.checkIsExtensionCallable(receiverValue, callableDescriptor); + } + })); return descriptorsSet; }