Minor: reformat ReferenceVariantsHelper.kt

2019-05-29 14:00:23 +03:00
parent 00f8f09274
commit eda975d317
1 changed files with 144 additions and 112 deletions
@@ -51,36 +51,37 @@ import org.jetbrains.kotlin.types.typeUtil.isUnit
 import java.util.*

 class ReferenceVariantsHelper(
-        private val bindingContext: BindingContext,
-        private val resolutionFacade: ResolutionFacade,
-        private val moduleDescriptor: ModuleDescriptor,
-        private val visibilityFilter: (DeclarationDescriptor) -> Boolean,
-        private val notProperties: Set<FqNameUnsafe> = setOf()
+    private val bindingContext: BindingContext,
+    private val resolutionFacade: ResolutionFacade,
+    private val moduleDescriptor: ModuleDescriptor,
+    private val visibilityFilter: (DeclarationDescriptor) -> Boolean,
+    private val notProperties: Set<FqNameUnsafe> = setOf()
 ) {
    fun getReferenceVariants(
-            expression: KtSimpleNameExpression,
-            kindFilter: DescriptorKindFilter,
-            nameFilter: (Name) -> Boolean,
-            filterOutJavaGettersAndSetters: Boolean = true,
-            filterOutShadowed: Boolean = true,
-            excludeNonInitializedVariable: Boolean = true,
-            useReceiverType: KotlinType? = null
-    ): Collection<DeclarationDescriptor>
-            = getReferenceVariants(expression, CallTypeAndReceiver.detect(expression),
-                                   kindFilter, nameFilter, filterOutJavaGettersAndSetters, filterOutShadowed, excludeNonInitializedVariable, useReceiverType)
+        expression: KtSimpleNameExpression,
+        kindFilter: DescriptorKindFilter,
+        nameFilter: (Name) -> Boolean,
+        filterOutJavaGettersAndSetters: Boolean = true,
+        filterOutShadowed: Boolean = true,
+        excludeNonInitializedVariable: Boolean = true,
+        useReceiverType: KotlinType? = null
+    ): Collection<DeclarationDescriptor> = getReferenceVariants(
+        expression, CallTypeAndReceiver.detect(expression),
+        kindFilter, nameFilter, filterOutJavaGettersAndSetters, filterOutShadowed, excludeNonInitializedVariable, useReceiverType
+    )

    fun getReferenceVariants(
-            contextElement: PsiElement,
-            callTypeAndReceiver: CallTypeAndReceiver<*, *>,
-            kindFilter: DescriptorKindFilter,
-            nameFilter: (Name) -> Boolean,
-            filterOutJavaGettersAndSetters: Boolean = true,
-            filterOutShadowed: Boolean = true,
-            excludeNonInitializedVariable: Boolean = true,
-            useReceiverType: KotlinType? = null
+        contextElement: PsiElement,
+        callTypeAndReceiver: CallTypeAndReceiver<*, *>,
+        kindFilter: DescriptorKindFilter,
+        nameFilter: (Name) -> Boolean,
+        filterOutJavaGettersAndSetters: Boolean = true,
+        filterOutShadowed: Boolean = true,
+        excludeNonInitializedVariable: Boolean = true,
+        useReceiverType: KotlinType? = null
    ): Collection<DeclarationDescriptor> {
-        var variants: Collection<DeclarationDescriptor>
-                = getReferenceVariantsNoVisibilityFilter(contextElement, kindFilter, nameFilter, callTypeAndReceiver, useReceiverType)
+        var variants: Collection<DeclarationDescriptor> =
+            getReferenceVariantsNoVisibilityFilter(contextElement, kindFilter, nameFilter, callTypeAndReceiver, useReceiverType)
                .filter { !resolutionFacade.frontendService<DeprecationResolver>().isHiddenInResolution(it) && visibilityFilter(it) }

        if (filterOutShadowed) {
@@ -100,7 +101,7 @@ class ReferenceVariantsHelper(
        return variants
    }

-    fun <TDescriptor: DeclarationDescriptor> filterOutJavaGettersAndSetters(variants: Collection<TDescriptor>): Collection<TDescriptor> {
+    fun <TDescriptor : DeclarationDescriptor> filterOutJavaGettersAndSetters(variants: Collection<TDescriptor>): Collection<TDescriptor> {
        val accessorMethodsToRemove = HashSet<FunctionDescriptor>()
        val filteredVariants = variants.filter { it !is SyntheticJavaPropertyDescriptor || !it.suppressedByNotPropertyList(notProperties) }

@@ -119,7 +120,10 @@ class ReferenceVariantsHelper(
    }

    // filters out variable inside its initializer
-    fun excludeNonInitializedVariable(variants: Collection<DeclarationDescriptor>, contextElement: PsiElement): Collection<DeclarationDescriptor> {
+    fun excludeNonInitializedVariable(
+        variants: Collection<DeclarationDescriptor>,
+        contextElement: PsiElement
+    ): Collection<DeclarationDescriptor> {
        for (element in contextElement.parentsWithSelf) {
            val parent = element.parent
            if (parent is KtVariableDeclaration && element == parent.initializer) {
@@ -131,11 +135,11 @@ class ReferenceVariantsHelper(
    }

    private fun getReferenceVariantsNoVisibilityFilter(
-            contextElement: PsiElement,
-            kindFilter: DescriptorKindFilter,
-            nameFilter: (Name) -> Boolean,
-            callTypeAndReceiver: CallTypeAndReceiver<*, *>,
-            useReceiverType: KotlinType?
+        contextElement: PsiElement,
+        kindFilter: DescriptorKindFilter,
+        nameFilter: (Name) -> Boolean,
+        callTypeAndReceiver: CallTypeAndReceiver<*, *>,
+        useReceiverType: KotlinType?
    ): Collection<DeclarationDescriptor> {
        val callType = callTypeAndReceiver.callType

@@ -205,20 +209,30 @@ class ReferenceVariantsHelper(

            val explicitReceiverTypes = if (useReceiverType != null) {
                listOf(useReceiverType)
-            }
-            else {
-                callTypeAndReceiver.receiverTypes(bindingContext, contextElement, moduleDescriptor, resolutionFacade, stableSmartCastsOnly = false)!!
+            } else {
+                callTypeAndReceiver.receiverTypes(
+                    bindingContext,
+                    contextElement,
+                    moduleDescriptor,
+                    resolutionFacade,
+                    stableSmartCastsOnly = false
+                )!!
            }

            descriptors.processAll(implicitReceiverTypes, explicitReceiverTypes, resolutionScope, callType, kindFilter, nameFilter)
-        }
-        else {
+        } else {
            assert(useReceiverType == null) { "'useReceiverType' parameter is not supported for implicit receiver" }

            descriptors.processAll(implicitReceiverTypes, implicitReceiverTypes, resolutionScope, callType, kindFilter, nameFilter)

            // add non-instance members
-            descriptors.addAll(resolutionScope.collectDescriptorsFiltered(filterWithoutExtensions, nameFilter, changeNamesForAliased = true))
+            descriptors.addAll(
+                resolutionScope.collectDescriptorsFiltered(
+                    filterWithoutExtensions,
+                    nameFilter,
+                    changeNamesForAliased = true
+                )
+            )
            descriptors.addAll(resolutionScope.collectAllFromMeAndParent { scope ->
                scope.collectSyntheticStaticMembersAndConstructors(resolutionFacade, kindFilter, nameFilter)
            })
@@ -226,7 +240,9 @@ class ReferenceVariantsHelper(

        if (callType == CallType.SUPER_MEMBERS) { // we need to unwrap fake overrides in case of "super." because ShadowedDeclarationsFilter does not work correctly
            return descriptors.flatMapTo(LinkedHashSet<DeclarationDescriptor>()) {
-                if (it is CallableMemberDescriptor && it.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) it.overriddenDescriptors else listOf(it)
+                if (it is CallableMemberDescriptor && it.kind == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) it.overriddenDescriptors else listOf(
+                    it
+                )
            }
        }

@@ -234,27 +250,26 @@ class ReferenceVariantsHelper(
    }

    private fun getVariantsForUserType(
-            receiverExpression: KtExpression?,
-            contextElement: PsiElement,
-            kindFilter: DescriptorKindFilter,
-            nameFilter: (Name) -> Boolean
+        receiverExpression: KtExpression?,
+        contextElement: PsiElement,
+        kindFilter: DescriptorKindFilter,
+        nameFilter: (Name) -> Boolean
    ): Collection<DeclarationDescriptor> {
        if (receiverExpression != null) {
            val qualifier = bindingContext[BindingContext.QUALIFIER, receiverExpression] ?: return emptyList()
            return qualifier.staticScope.collectStaticMembers(resolutionFacade, kindFilter, nameFilter)
-        }
-        else {
+        } else {
            val scope = contextElement.getResolutionScope(bindingContext, resolutionFacade)
            return scope.collectDescriptorsFiltered(kindFilter, nameFilter, changeNamesForAliased = true)
        }
    }

    private fun getVariantsForCallableReference(
-            callTypeAndReceiver: CallTypeAndReceiver.CALLABLE_REFERENCE,
-            contextElement: PsiElement,
-            useReceiverType: KotlinType?,
-            kindFilter: DescriptorKindFilter,
-            nameFilter: (Name) -> Boolean
+        callTypeAndReceiver: CallTypeAndReceiver.CALLABLE_REFERENCE,
+        contextElement: PsiElement,
+        useReceiverType: KotlinType?,
+        kindFilter: DescriptorKindFilter,
+        nameFilter: (Name) -> Boolean
    ): Collection<DeclarationDescriptor> {
        val descriptors = LinkedHashSet<DeclarationDescriptor>()

@@ -266,59 +281,69 @@ class ReferenceVariantsHelper(

            val explicitReceiverTypes = if (useReceiverType != null) {
                listOf(useReceiverType)
-            }
-            else {
-                callTypeAndReceiver.receiverTypes(bindingContext, contextElement, moduleDescriptor, resolutionFacade, stableSmartCastsOnly = false)!!
+            } else {
+                callTypeAndReceiver.receiverTypes(
+                    bindingContext,
+                    contextElement,
+                    moduleDescriptor,
+                    resolutionFacade,
+                    stableSmartCastsOnly = false
+                )!!
            }

            val constructorFilter = { descriptor: ClassDescriptor -> if (isStatic) true else descriptor.isInner }
            descriptors.addNonExtensionMembers(explicitReceiverTypes, kindFilter, nameFilter, constructorFilter)

-            descriptors.addScopeAndSyntheticExtensions(resolutionScope, explicitReceiverTypes, CallType.CALLABLE_REFERENCE, kindFilter, nameFilter)
+            descriptors.addScopeAndSyntheticExtensions(
+                resolutionScope,
+                explicitReceiverTypes,
+                CallType.CALLABLE_REFERENCE,
+                kindFilter,
+                nameFilter
+            )

            if (isStatic) {
                explicitReceiverTypes
-                        .mapNotNull { (it.constructor.declarationDescriptor as? ClassDescriptor)?.staticScope }
-                        .flatMapTo(descriptors) { it.collectStaticMembers(resolutionFacade, kindFilter, nameFilter) }
+                    .mapNotNull { (it.constructor.declarationDescriptor as? ClassDescriptor)?.staticScope }
+                    .flatMapTo(descriptors) { it.collectStaticMembers(resolutionFacade, kindFilter, nameFilter) }
            }
-        }
-        else {
+        } else {
            // process non-instance members and class constructors
            descriptors.addNonExtensionCallablesAndConstructors(
-                    resolutionScope,
-                    kindFilter, nameFilter, constructorFilter = { !it.isInner },
-                    classesOnly = false
+                resolutionScope,
+                kindFilter, nameFilter, constructorFilter = { !it.isInner },
+                classesOnly = false
            )
        }
        return descriptors
    }

    private fun getVariantsForImportOrPackageDirective(
-            receiverExpression: KtExpression?,
-            kindFilter: DescriptorKindFilter,
-            nameFilter: (Name) -> Boolean
+        receiverExpression: KtExpression?,
+        kindFilter: DescriptorKindFilter,
+        nameFilter: (Name) -> Boolean
    ): Collection<DeclarationDescriptor> {
        if (receiverExpression != null) {
            val qualifier = bindingContext[BindingContext.QUALIFIER, receiverExpression] ?: return emptyList()
            val staticDescriptors = qualifier.staticScope.collectStaticMembers(resolutionFacade, kindFilter, nameFilter)

-            val objectDescriptor = (qualifier as? ClassQualifier)?.descriptor?.takeIf { it.kind == ClassKind.OBJECT } ?: return staticDescriptors
+            val objectDescriptor =
+                (qualifier as? ClassQualifier)?.descriptor?.takeIf { it.kind == ClassKind.OBJECT } ?: return staticDescriptors

            return staticDescriptors + objectDescriptor.defaultType.memberScope.getDescriptorsFiltered(kindFilter, nameFilter)
-        }
-        else {
+        } else {
            val rootPackage = resolutionFacade.moduleDescriptor.getPackage(FqName.ROOT)
            return rootPackage.memberScope.getDescriptorsFiltered(kindFilter, nameFilter)
        }
    }

    private fun MutableSet<DeclarationDescriptor>.processAll(
-            implicitReceiverTypes: Collection<KotlinType>,
-            receiverTypes: Collection<KotlinType>,
-            resolutionScope: LexicalScope,
-            callType: CallType<*>,
-            kindFilter: DescriptorKindFilter,
-            nameFilter: (Name) -> Boolean
+        implicitReceiverTypes: Collection<KotlinType>,
+        receiverTypes: Collection<KotlinType>,
+        resolutionScope: LexicalScope,
+        callType: CallType<*>,
+        kindFilter: DescriptorKindFilter,
+        nameFilter: (Name) -> Boolean
    ) {
        addNonExtensionMembers(receiverTypes, kindFilter, nameFilter, constructorFilter = { it.isInner })
        addMemberExtensions(implicitReceiverTypes, receiverTypes, callType, kindFilter, nameFilter)
@@ -326,11 +351,11 @@ class ReferenceVariantsHelper(
    }

    private fun MutableSet<DeclarationDescriptor>.addMemberExtensions(
-            dispatchReceiverTypes: Collection<KotlinType>,
-            extensionReceiverTypes: Collection<KotlinType>,
-            callType: CallType<*>,
-            kindFilter: DescriptorKindFilter,
-            nameFilter: (Name) -> Boolean
+        dispatchReceiverTypes: Collection<KotlinType>,
+        extensionReceiverTypes: Collection<KotlinType>,
+        callType: CallType<*>,
+        kindFilter: DescriptorKindFilter,
+        nameFilter: (Name) -> Boolean
    ) {
        val memberFilter = kindFilter exclude DescriptorKindExclude.NonExtensions
        for (dispatchReceiverType in dispatchReceiverTypes) {
@@ -341,35 +366,36 @@ class ReferenceVariantsHelper(
    }

    private fun MutableSet<DeclarationDescriptor>.addNonExtensionMembers(
-            receiverTypes: Collection<KotlinType>,
-            kindFilter: DescriptorKindFilter,
-            nameFilter: (Name) -> Boolean,
-            constructorFilter: (ClassDescriptor) -> Boolean
+        receiverTypes: Collection<KotlinType>,
+        kindFilter: DescriptorKindFilter,
+        nameFilter: (Name) -> Boolean,
+        constructorFilter: (ClassDescriptor) -> Boolean
    ) {
        for (receiverType in receiverTypes) {
            addNonExtensionCallablesAndConstructors(
-                    receiverType.memberScope.memberScopeAsImportingScope(),
-                    kindFilter, nameFilter, constructorFilter,
-                    false
+                receiverType.memberScope.memberScopeAsImportingScope(),
+                kindFilter, nameFilter, constructorFilter,
+                false
            )
            receiverType.constructor.supertypes.forEach {
                addNonExtensionCallablesAndConstructors(
-                        it.memberScope.memberScopeAsImportingScope(),
-                        kindFilter, nameFilter, constructorFilter,
-                        true
+                    it.memberScope.memberScopeAsImportingScope(),
+                    kindFilter, nameFilter, constructorFilter,
+                    true
                )
            }
        }
    }

    private fun MutableSet<DeclarationDescriptor>.addNonExtensionCallablesAndConstructors(
-            scope: HierarchicalScope,
-            kindFilter: DescriptorKindFilter,
-            nameFilter: (Name) -> Boolean,
-            constructorFilter: (ClassDescriptor) -> Boolean,
-            classesOnly: Boolean
+        scope: HierarchicalScope,
+        kindFilter: DescriptorKindFilter,
+        nameFilter: (Name) -> Boolean,
+        constructorFilter: (ClassDescriptor) -> Boolean,
+        classesOnly: Boolean
    ) {
-        var filterToUse = DescriptorKindFilter(kindFilter.kindMask and DescriptorKindFilter.CALLABLES.kindMask).exclude(DescriptorKindExclude.Extensions)
+        var filterToUse =
+            DescriptorKindFilter(kindFilter.kindMask and DescriptorKindFilter.CALLABLES.kindMask).exclude(DescriptorKindExclude.Extensions)

        // should process classes if we need constructors
        if (filterToUse.acceptsKinds(DescriptorKindFilter.FUNCTIONS_MASK)) {
@@ -381,19 +407,18 @@ class ReferenceVariantsHelper(
                if (descriptor.modality == Modality.ABSTRACT || descriptor.modality == Modality.SEALED) continue
                if (!constructorFilter(descriptor)) continue
                descriptor.constructors.filterTo(this) { kindFilter.accepts(it) }
-            }
-            else if (!classesOnly && kindFilter.accepts(descriptor)) {
+            } else if (!classesOnly && kindFilter.accepts(descriptor)) {
                this.add(descriptor)
            }
        }
    }

    private fun MutableSet<DeclarationDescriptor>.addScopeAndSyntheticExtensions(
-            scope: LexicalScope,
-            receiverTypes: Collection<KotlinType>,
-            callType: CallType<*>,
-            kindFilter: DescriptorKindFilter,
-            nameFilter: (Name) -> Boolean
+        scope: LexicalScope,
+        receiverTypes: Collection<KotlinType>,
+        callType: CallType<*>,
+        kindFilter: DescriptorKindFilter,
+        nameFilter: (Name) -> Boolean
    ) {
        if (kindFilter.excludes.contains(DescriptorKindExclude.Extensions)) return
        if (receiverTypes.isEmpty()) return
@@ -402,14 +427,17 @@ class ReferenceVariantsHelper(
            if (kindFilter.accepts(extensionOrSyntheticMember) && nameFilter(extensionOrSyntheticMember.name)) {
                if (extensionOrSyntheticMember.isExtension) {
                    addAll(extensionOrSyntheticMember.substituteExtensionIfCallable(receiverTypes, callType))
-                }
-                else {
+                } else {
                    add(extensionOrSyntheticMember)
                }
            }
        }

-        for (descriptor in scope.collectDescriptorsFiltered(kindFilter exclude DescriptorKindExclude.NonExtensions, nameFilter, changeNamesForAliased = true)) {
+        for (descriptor in scope.collectDescriptorsFiltered(
+            kindFilter exclude DescriptorKindExclude.NonExtensions,
+            nameFilter,
+            changeNamesForAliased = true
+        )) {
            // todo: sometimes resolution scope here is LazyJavaClassMemberScope. see ea.jetbrains.com/browser/ea_problems/72572
            process(descriptor as CallableDescriptor)
        }
@@ -433,19 +461,23 @@ class ReferenceVariantsHelper(
 }

 private fun MemberScope.collectStaticMembers(
-        resolutionFacade: ResolutionFacade,
-        kindFilter: DescriptorKindFilter,
-        nameFilter: (Name) -> Boolean
+    resolutionFacade: ResolutionFacade,
+    kindFilter: DescriptorKindFilter,
+    nameFilter: (Name) -> Boolean
 ): Collection<DeclarationDescriptor> {
-    return getDescriptorsFiltered(kindFilter, nameFilter) + collectSyntheticStaticMembersAndConstructors(resolutionFacade, kindFilter, nameFilter)
+    return getDescriptorsFiltered(kindFilter, nameFilter) + collectSyntheticStaticMembersAndConstructors(
+        resolutionFacade,
+        kindFilter,
+        nameFilter
+    )
 }

 fun ResolutionScope.collectSyntheticStaticMembersAndConstructors(
-        resolutionFacade: ResolutionFacade,
-        kindFilter: DescriptorKindFilter,
-        nameFilter: (Name) -> Boolean
+    resolutionFacade: ResolutionFacade,
+    kindFilter: DescriptorKindFilter,
+    nameFilter: (Name) -> Boolean
 ): List<FunctionDescriptor> {
    val syntheticScopes = resolutionFacade.getFrontendService(SyntheticScopes::class.java)
    return (syntheticScopes.collectSyntheticStaticFunctions(this) + syntheticScopes.collectSyntheticConstructors(this))
-            .filter { kindFilter.accepts(it) && nameFilter(it.name) }
+        .filter { kindFilter.accepts(it) && nameFilter(it.name) }
 }