From 5036fdca14c6d4075e4ce4cc6203f52ed2c9819d Mon Sep 17 00:00:00 2001 From: Valentin Kipyatkov Date: Wed, 19 Nov 2014 13:40:54 +0300 Subject: [PATCH] Made ReferenceVariantsHelper class instead of object making method signatures shorter --- .../codeInsight/ReferenceVariantsHelper.kt | 28 +++++++++---------- .../plugin/completion/CompletionSession.kt | 16 +++++------ .../completion/PackageDirectiveCompletion.kt | 2 +- .../JetFunctionParameterInfoHandler.java | 4 +-- 4 files changed, 24 insertions(+), 26 deletions(-) diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/ReferenceVariantsHelper.kt b/idea/src/org/jetbrains/jet/plugin/codeInsight/ReferenceVariantsHelper.kt index 3398227ccb5..ff2141b9587 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/ReferenceVariantsHelper.kt +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/ReferenceVariantsHelper.kt @@ -34,21 +34,21 @@ import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindFilter import org.jetbrains.jet.lang.resolve.scopes.DescriptorKindExclude import org.jetbrains.jet.plugin.util.extensionsUtils.isExtensionCallable -public object ReferenceVariantsHelper { +public class ReferenceVariantsHelper( + private val context: BindingContext, + private val visibilityFilter: (DeclarationDescriptor) -> Boolean +) { public fun getReferenceVariants( expression: JetSimpleNameExpression, - context: BindingContext, kindFilter: DescriptorKindFilter, - nameFilter: (Name) -> Boolean, - visibilityFilter: (DeclarationDescriptor) -> Boolean + nameFilter: (Name) -> Boolean ): Collection { - return getReferenceVariants(expression, context, kindFilter, nameFilter).filter(visibilityFilter) + return getReferenceVariantsNoVisibilityFilter(expression, kindFilter, nameFilter).filter(visibilityFilter) } - private fun getReferenceVariants( + private fun getReferenceVariantsNoVisibilityFilter( expression: JetSimpleNameExpression, - context: BindingContext, kindFilter: DescriptorKindFilter, nameFilter: (Name) -> Boolean ): Collection { @@ -85,7 +85,7 @@ public object ReferenceVariantsHelper { variant.getMemberScope().getDescriptorsFiltered(mask, nameFilter).filterTo(descriptors, ::filterIfInfix) } - descriptors.addCallableExtensions(resolutionScope, receiverValue, context, dataFlowInfo, isInfixCall, kindFilter, nameFilter) + descriptors.addCallableExtensions(resolutionScope, receiverValue, dataFlowInfo, isInfixCall, kindFilter, nameFilter) } return descriptors @@ -112,7 +112,7 @@ public object ReferenceVariantsHelper { } } - public fun getReferenceVariantsReceivers(expression: JetSimpleNameExpression, context: BindingContext): Collection { + public fun getReferenceVariantsReceivers(expression: JetSimpleNameExpression): Collection { val receiverExpression = getReferenceVariantsReceiver(expression) if (receiverExpression != null) { val expressionType = context[BindingContext.EXPRESSION_TYPE, receiverExpression] ?: return listOf() @@ -138,7 +138,6 @@ public object ReferenceVariantsHelper { private fun MutableCollection.addCallableExtensions( resolutionScope: JetScope, receiver: ReceiverValue, - context: BindingContext, dataFlowInfo: DataFlowInfo, isInfixCall: Boolean, kindFilter: DescriptorKindFilter, @@ -152,10 +151,11 @@ public object ReferenceVariantsHelper { } } - public fun getPackageReferenceVariants(expression: JetSimpleNameExpression, - context: BindingContext, - nameFilter: (Name) -> Boolean): Collection { + public fun getPackageReferenceVariants( + expression: JetSimpleNameExpression, + nameFilter: (Name) -> Boolean + ): Collection { val resolutionScope = context[BindingContext.RESOLUTION_SCOPE, expression] ?: return listOf() - return resolutionScope.getDescriptorsFiltered(DescriptorKindFilter.PACKAGES, nameFilter) + return resolutionScope.getDescriptorsFiltered(DescriptorKindFilter.PACKAGES, nameFilter).filter(visibilityFilter) } } diff --git a/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt b/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt index aaf165908ff..b45e02941b7 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt +++ b/idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt @@ -63,11 +63,14 @@ abstract class CompletionSessionBase(protected val configuration: CompletionSess protected val prefixMatcher: PrefixMatcher = this.resultSet.getPrefixMatcher() + protected val referenceVariantsHelper: ReferenceVariantsHelper? + = if (bindingContext != null) ReferenceVariantsHelper(bindingContext) { isVisibleDescriptor(it) } else null + protected val boldImmediateLookupElementFactory: LookupElementFactory = run { if (jetReference != null) { val expression = jetReference.expression - val receivers = ReferenceVariantsHelper.getReferenceVariantsReceivers(expression, bindingContext!!) - val dataFlowInfo = bindingContext.getDataFlowInfo(expression) + val receivers = referenceVariantsHelper!!.getReferenceVariantsReceivers(expression) + val dataFlowInfo = bindingContext!!.getDataFlowInfo(expression) val receiverTypes = receivers.flatMap { SmartCastUtils.getSmartCastVariantsWithLessSpecificExcluded(it, bindingContext, dataFlowInfo) } @@ -111,13 +114,8 @@ abstract class CompletionSessionBase(protected val configuration: CompletionSess protected abstract fun doComplete() - protected fun getReferenceVariants(kindFilter: DescriptorKindFilter): Collection { - return ReferenceVariantsHelper.getReferenceVariants(jetReference!!.expression, - bindingContext!!, - kindFilter, - prefixMatcher.asNameFilter(), - { isVisibleDescriptor(it) }) - } + protected fun getReferenceVariants(kindFilter: DescriptorKindFilter): Collection + = referenceVariantsHelper!!.getReferenceVariants(jetReference!!.expression, kindFilter, prefixMatcher.asNameFilter()) protected fun shouldRunTopLevelCompletion(): Boolean = configuration.completeNonImportedDeclarations && isNoQualifierContext() diff --git a/idea/src/org/jetbrains/jet/plugin/completion/PackageDirectiveCompletion.kt b/idea/src/org/jetbrains/jet/plugin/completion/PackageDirectiveCompletion.kt index 333d76bf291..a70ef51e1ae 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/PackageDirectiveCompletion.kt +++ b/idea/src/org/jetbrains/jet/plugin/completion/PackageDirectiveCompletion.kt @@ -53,7 +53,7 @@ object PackageDirectiveCompletion { val resolveSession = ref.expression.getLazyResolveSession() val bindingContext = resolveSession.resolveToElement(ref.expression) - val variants = ReferenceVariantsHelper.getPackageReferenceVariants(ref.expression, bindingContext, prefixMatcher.asNameFilter()) + val variants = ReferenceVariantsHelper(bindingContext, { true }).getPackageReferenceVariants(ref.expression, prefixMatcher.asNameFilter()) for (variant in variants) { val lookupElement = LookupElementFactory.DEFAULT.createLookupElement(resolveSession, variant) if (!lookupElement.getLookupString().contains(DUMMY_IDENTIFIER)) { diff --git a/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java b/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java index 09f7cfda4b8..a8074466db0 100644 --- a/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java @@ -409,8 +409,8 @@ public class JetFunctionParameterInfoHandler implements ParameterInfoHandlerWith return name.equals(refName); } }; - Collection variants = ReferenceVariantsHelper.INSTANCE$.getReferenceVariants( - callNameExpression, bindingContext, new DescriptorKindFilter(DescriptorKindFilter.FUNCTIONS_MASK | DescriptorKindFilter.CLASSIFIERS_MASK, Collections.emptyList()), nameFilter, visibilityFilter); + Collection variants = new ReferenceVariantsHelper(bindingContext, visibilityFilter).getReferenceVariants( + callNameExpression, new DescriptorKindFilter(DescriptorKindFilter.FUNCTIONS_MASK | DescriptorKindFilter.CLASSIFIERS_MASK, Collections.emptyList()), nameFilter); Collection> itemsToShow = new ArrayList>(); for (DeclarationDescriptor variant : variants) {