Reformat: ResolveElementCache

2018-02-13 13:51:47 +03:00
parent ba71e732a9
commit 52166646bb
1 changed files with 225 additions and 121 deletions
@@ -49,10 +49,10 @@ import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.*

 class ResolveElementCache(
-        private val resolveSession: ResolveSession,
-        private val project: Project,
-        private val targetPlatform: TargetPlatform,
-        private val codeFragmentAnalyzer: CodeFragmentAnalyzer
+    private val resolveSession: ResolveSession,
+    private val project: Project,
+    private val targetPlatform: TargetPlatform,
+    private val codeFragmentAnalyzer: CodeFragmentAnalyzer
 ) : BodyResolveCache {
    private class CachedFullResolve(val bindingContext: BindingContext, resolveElement: KtElement) {
        private val modificationStamp: Long? = modificationStamp(resolveElement)
@@ -62,8 +62,8 @@ class ResolveElementCache(
        private fun modificationStamp(resolveElement: KtElement): Long? {
            val file = resolveElement.containingFile
            return when {
-                // for non-physical file we don't get OUT_OF_CODE_BLOCK_MODIFICATION_COUNT increased and must reset
-                // data on any modification of the file
+            // for non-physical file we don't get OUT_OF_CODE_BLOCK_MODIFICATION_COUNT increased and must reset
+            // data on any modification of the file
                !file.isPhysical -> file.modificationStamp

                resolveElement is KtDeclaration && KotlinCodeBlockModificationListener.isBlockDeclaration(resolveElement) -> resolveElement.getModificationStamp()
@@ -74,19 +74,23 @@ class ResolveElementCache(
    }

    // drop whole cache after change "out of code block"
-    private val fullResolveCache: CachedValue<MutableMap<KtElement, CachedFullResolve>> = CachedValuesManager.getManager(project).createCachedValue(
+    private val fullResolveCache: CachedValue<MutableMap<KtElement, CachedFullResolve>> =
+        CachedValuesManager.getManager(project).createCachedValue(
            CachedValueProvider<MutableMap<KtElement, ResolveElementCache.CachedFullResolve>> {
-                CachedValueProvider.Result.create(ContainerUtil.createConcurrentSoftValueMap<KtElement, CachedFullResolve>(),
-                                                  PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT,
-                                                  resolveSession.exceptionTracker)
+                CachedValueProvider.Result.create(
+                    ContainerUtil.createConcurrentSoftValueMap<KtElement, CachedFullResolve>(),
+                    PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT,
+                    resolveSession.exceptionTracker
+                )
            },
-            false)
+            false
+        )

    private class CachedPartialResolve(val bindingContext: BindingContext, file: KtFile, val mode: BodyResolveMode) {
        private val modificationStamp: Long? = modificationStamp(file)

        fun isUpToDate(file: KtFile, newMode: BodyResolveMode) =
-                modificationStamp == modificationStamp(file) && mode.doesNotLessThan(newMode)
+            modificationStamp == modificationStamp(file) && mode.doesNotLessThan(newMode)

        private fun modificationStamp(file: KtFile): Long? {
            return if (!file.isPhysical) // for non-physical file we don't get MODIFICATION_COUNT increased and must reset data on any modification of the file
@@ -97,13 +101,16 @@ class ResolveElementCache(
    }

    private val partialBodyResolveCache: CachedValue<MutableMap<KtExpression, CachedPartialResolve>> =
-            CachedValuesManager.getManager(project).createCachedValue(
-                    CachedValueProvider<MutableMap<KtExpression, ResolveElementCache.CachedPartialResolve>> {
-                        CachedValueProvider.Result.create(ContainerUtil.createConcurrentSoftValueMap<KtExpression, CachedPartialResolve>(),
-                                                          PsiModificationTracker.MODIFICATION_COUNT,
-                                                          resolveSession.exceptionTracker)
-                    },
-                    false)
+        CachedValuesManager.getManager(project).createCachedValue(
+            CachedValueProvider<MutableMap<KtExpression, ResolveElementCache.CachedPartialResolve>> {
+                CachedValueProvider.Result.create(
+                    ContainerUtil.createConcurrentSoftValueMap<KtExpression, CachedPartialResolve>(),
+                    PsiModificationTracker.MODIFICATION_COUNT,
+                    resolveSession.exceptionTracker
+                )
+            },
+            false
+        )


    private fun probablyNothingCallableNames(): ProbablyNothingCallableNames {
@@ -113,19 +120,31 @@ class ResolveElementCache(
        }
    }

-    override fun resolveFunctionBody(function: KtNamedFunction)
-            = getElementsAdditionalResolve(function, null, BodyResolveMode.FULL)
+    override fun resolveFunctionBody(function: KtNamedFunction) = getElementsAdditionalResolve(function, null, BodyResolveMode.FULL)

    fun resolvePrimaryConstructorParametersDefaultValues(ktClass: KtClass): BindingContext {
-        return constructorAdditionalResolve(resolveSession, ktClass, ktClass.containingKtFile, BindingTraceFilter.NO_DIAGNOSTICS).bindingContext
+        return constructorAdditionalResolve(
+            resolveSession,
+            ktClass,
+            ktClass.containingKtFile,
+            BindingTraceFilter.NO_DIAGNOSTICS
+        ).bindingContext
    }

    @Deprecated("Use getElementsAdditionalResolve")
-    fun getElementAdditionalResolve(resolveElement: KtElement, contextElement: KtElement, bodyResolveMode: BodyResolveMode): BindingContext {
+    fun getElementAdditionalResolve(
+        resolveElement: KtElement,
+        contextElement: KtElement,
+        bodyResolveMode: BodyResolveMode
+    ): BindingContext {
        return getElementsAdditionalResolve(resolveElement, listOf(contextElement), bodyResolveMode)
    }

-    fun getElementsAdditionalResolve(resolveElement: KtElement, contextElements: Collection<KtElement>?, bodyResolveMode: BodyResolveMode): BindingContext {
+    fun getElementsAdditionalResolve(
+        resolveElement: KtElement,
+        contextElements: Collection<KtElement>?,
+        bodyResolveMode: BodyResolveMode
+    ): BindingContext {
        if (contextElements == null) {
            assert(bodyResolveMode == BodyResolveMode.FULL)
        }
@@ -136,8 +155,7 @@ class ResolveElementCache(
        if (cachedFullResolve != null) {
            if (cachedFullResolve.isUpToDate(resolveElement)) {
                return cachedFullResolve.bindingContext
-            }
-            else {
+            } else {
                fullResolveMap.remove(resolveElement) // remove outdated cache entry
            }
        }
@@ -155,10 +173,16 @@ class ResolveElementCache(
                }

                val file = resolveElement.getContainingKtFile()
-                val statementsToResolve = contextElements!!.map { PartialBodyResolveFilter.findStatementToResolve(it, resolveElement) }.distinct()
+                val statementsToResolve =
+                    contextElements!!.map { PartialBodyResolveFilter.findStatementToResolve(it, resolveElement) }.distinct()
                val partialResolveMap = partialBodyResolveCache.value
                val cachedResults = statementsToResolve.map { partialResolveMap[it ?: resolveElement] }
-                if (cachedResults.all { it != null && it.isUpToDate(file, bodyResolveMode) }) { // partial resolve is already cached for these statements
+                if (cachedResults.all {
+                        it != null && it.isUpToDate(
+                            file,
+                            bodyResolveMode
+                        )
+                    }) { // partial resolve is already cached for these statements
                    return CompositeBindingContext.create(cachedResults.map { it!!.bindingContext }.distinct())
                }

@@ -196,19 +220,17 @@ class ResolveElementCache(
                if (elementOfAdditionalResolve !is KtParameter) {
                    val bindingContext = getElementsAdditionalResolve(elementOfAdditionalResolve, contextElements, bodyResolveMode)
                    bindingContexts.add(bindingContext)
-                }
-                else {
+                } else {
                    // Parameters for function literal could be met inside other parameters. We can't make resolveToDescriptors for internal elements.
                    declarationsToResolve.addIfNotNull(elementOfAdditionalResolve.getNonStrictParentOfType<KtDeclaration>())
                    addResolveSessionBindingContext = true
                }
-            }
-            else {
+            } else {
                contextElements
-                        .mapNotNull { it.getNonStrictParentOfType<KtDeclaration>() }
-                        .filterTo(declarationsToResolve) {
-                            it !is KtAnonymousInitializer && it !is KtDestructuringDeclaration && it !is KtDestructuringDeclarationEntry
-                        }
+                    .mapNotNull { it.getNonStrictParentOfType<KtDeclaration>() }
+                    .filterTo(declarationsToResolve) {
+                        it !is KtAnonymousInitializer && it !is KtDestructuringDeclaration && it !is KtDestructuringDeclarationEntry
+                    }
                addResolveSessionBindingContext = true
            }
        }
@@ -224,21 +246,21 @@ class ResolveElementCache(

    private fun findElementOfAdditionalResolve(element: KtElement): KtElement? {
        val elementOfAdditionalResolve = KtPsiUtil.getTopmostParentOfTypes(
-                element,
-                KtNamedFunction::class.java,
-                KtAnonymousInitializer::class.java,
-                KtPrimaryConstructor::class.java,
-                KtSecondaryConstructor::class.java,
-                KtProperty::class.java,
-                KtSuperTypeList::class.java,
-                KtInitializerList::class.java,
-                KtImportList::class.java,
-                KtAnnotationEntry::class.java,
-                KtTypeParameter::class.java,
-                KtTypeConstraint::class.java,
-                KtPackageDirective::class.java,
-                KtCodeFragment::class.java,
-                KtTypeAlias::class.java
+            element,
+            KtNamedFunction::class.java,
+            KtAnonymousInitializer::class.java,
+            KtPrimaryConstructor::class.java,
+            KtSecondaryConstructor::class.java,
+            KtProperty::class.java,
+            KtSuperTypeList::class.java,
+            KtInitializerList::class.java,
+            KtImportList::class.java,
+            KtAnnotationEntry::class.java,
+            KtTypeParameter::class.java,
+            KtTypeConstraint::class.java,
+            KtPackageDirective::class.java,
+            KtCodeFragment::class.java,
+            KtTypeAlias::class.java
        ) as KtElement?

        when (elementOfAdditionalResolve) {
@@ -271,9 +293,9 @@ class ResolveElementCache(
    }

    private fun performElementAdditionalResolve(
-            resolveElement: KtElement,
-            contextElements: Collection<KtElement>?,
-            bodyResolveMode: BodyResolveMode
+        resolveElement: KtElement,
+        contextElements: Collection<KtElement>?,
+        bodyResolveMode: BodyResolveMode
    ): Pair<BindingContext, StatementFilter> {
        if (contextElements == null) {
            assert(bodyResolveMode == BodyResolveMode.FULL)
@@ -287,28 +309,70 @@ class ResolveElementCache(
            assert(resolveElement is KtDeclaration)
            if (bodyResolveMode != BodyResolveMode.FULL) {
                statementFilterUsed = PartialBodyResolveFilter(
-                        contextElements!!,
-                        resolveElement as KtDeclaration,
-                        probablyNothingCallableNames(),
-                        bodyResolveMode == BodyResolveMode.PARTIAL_FOR_COMPLETION)
+                    contextElements!!,
+                    resolveElement as KtDeclaration,
+                    probablyNothingCallableNames(),
+                    bodyResolveMode == BodyResolveMode.PARTIAL_FOR_COMPLETION
+                )
            }
            return statementFilterUsed
        }

        val trace: BindingTrace = when (resolveElement) {
-            is KtNamedFunction -> functionAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter(), bodyResolveMode.bindingTraceFilter)
+            is KtNamedFunction -> functionAdditionalResolve(
+                resolveSession,
+                resolveElement,
+                file,
+                createStatementFilter(),
+                bodyResolveMode.bindingTraceFilter
+            )

-            is KtAnonymousInitializer -> initializerAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter(), bodyResolveMode.bindingTraceFilter)
+            is KtAnonymousInitializer -> initializerAdditionalResolve(
+                resolveSession,
+                resolveElement,
+                file,
+                createStatementFilter(),
+                bodyResolveMode.bindingTraceFilter
+            )

-            is KtPrimaryConstructor -> constructorAdditionalResolve(resolveSession, resolveElement.parent as KtClassOrObject, file, bodyResolveMode.bindingTraceFilter)
+            is KtPrimaryConstructor -> constructorAdditionalResolve(
+                resolveSession,
+                resolveElement.parent as KtClassOrObject,
+                file,
+                bodyResolveMode.bindingTraceFilter
+            )

-            is KtSecondaryConstructor -> secondaryConstructorAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter(), bodyResolveMode.bindingTraceFilter)
+            is KtSecondaryConstructor -> secondaryConstructorAdditionalResolve(
+                resolveSession,
+                resolveElement,
+                file,
+                createStatementFilter(),
+                bodyResolveMode.bindingTraceFilter
+            )

-            is KtProperty -> propertyAdditionalResolve(resolveSession, resolveElement, file, createStatementFilter(), bodyResolveMode.bindingTraceFilter)
+            is KtProperty -> propertyAdditionalResolve(
+                resolveSession,
+                resolveElement,
+                file,
+                createStatementFilter(),
+                bodyResolveMode.bindingTraceFilter
+            )

-            is KtSuperTypeList -> delegationSpecifierAdditionalResolve(resolveSession, resolveElement, resolveElement.getParent() as KtClassOrObject, file, bodyResolveMode.bindingTraceFilter)
+            is KtSuperTypeList -> delegationSpecifierAdditionalResolve(
+                resolveSession,
+                resolveElement,
+                resolveElement.getParent() as KtClassOrObject,
+                file,
+                bodyResolveMode.bindingTraceFilter
+            )

-            is KtInitializerList -> delegationSpecifierAdditionalResolve(resolveSession, resolveElement, resolveElement.getParent() as KtEnumEntry, file, bodyResolveMode.bindingTraceFilter)
+            is KtInitializerList -> delegationSpecifierAdditionalResolve(
+                resolveSession,
+                resolveElement,
+                resolveElement.getParent() as KtEnumEntry,
+                file,
+                bodyResolveMode.bindingTraceFilter
+            )

            is KtImportList -> {
                val resolver = resolveSession.fileScopeProvider.getImportResolver(resolveElement.getContainingKtFile())
@@ -320,8 +384,7 @@ class ResolveElementCache(
                val annotationEntry = resolveElement.annotationEntries.firstOrNull()
                if (annotationEntry != null) {
                    annotationAdditionalResolve(resolveSession, annotationEntry)
-                }
-                else {
+                } else {
                    resolveSession.trace
                }
            }
@@ -341,24 +404,26 @@ class ResolveElementCache(
            else -> {
                if (resolveElement.getParentOfType<KtPackageDirective>(true) != null) {
                    packageRefAdditionalResolve(resolveSession, resolveElement, bodyResolveMode.bindingTraceFilter)
-                }
-                else {
+                } else {
                    error("Invalid type of the topmost parent: $resolveElement\n${resolveElement.getElementTextWithContext()}")
                }
            }
        }

-        val controlFlowTrace = DelegatingBindingTrace(trace.bindingContext, "Element control flow resolve", resolveElement, allowSliceRewrite = true)
+        val controlFlowTrace =
+            DelegatingBindingTrace(trace.bindingContext, "Element control flow resolve", resolveElement, allowSliceRewrite = true)
        ControlFlowInformationProvider(
-                resolveElement, controlFlowTrace, resolveElement.languageVersionSettings, resolveSession.platformDiagnosticSuppressor
+            resolveElement, controlFlowTrace, resolveElement.languageVersionSettings, resolveSession.platformDiagnosticSuppressor
        ).checkDeclaration()
        controlFlowTrace.addOwnDataTo(trace, null, false)

        return Pair(trace.bindingContext, statementFilterUsed)
    }

-    private fun packageRefAdditionalResolve(resolveSession: ResolveSession, ktElement: KtElement,
-                                            bindingTraceFilter: BindingTraceFilter): BindingTrace {
+    private fun packageRefAdditionalResolve(
+        resolveSession: ResolveSession, ktElement: KtElement,
+        bindingTraceFilter: BindingTraceFilter
+    ): BindingTrace {
        val trace = createDelegatingTrace(ktElement, bindingTraceFilter)

        if (ktElement is KtSimpleNameExpression) {
@@ -404,8 +469,7 @@ class ResolveElementCache(
        val declaration = modifierList?.getParentOfType<KtDeclaration>(true)
        if (declaration != null) {
            doResolveAnnotations(getAnnotationsByDeclaration(resolveSession, modifierList, declaration))
-        }
-        else {
+        } else {
            val fileAnnotationList = ktAnnotationEntry.getParentOfType<KtFileAnnotationList>(true)
            if (fileAnnotationList != null) {
                doResolveAnnotations(resolveSession.getFileAnnotations(fileAnnotationList.containingKtFile))
@@ -422,12 +486,16 @@ class ResolveElementCache(
        ForceResolveUtil.forceResolveAllContents(annotations)
    }

-    private fun getAnnotationsByDeclaration(resolveSession: ResolveSession, modifierList: KtModifierList, declaration: KtDeclaration): Annotations {
+    private fun getAnnotationsByDeclaration(
+        resolveSession: ResolveSession,
+        modifierList: KtModifierList,
+        declaration: KtDeclaration
+    ): Annotations {
        var descriptor = resolveSession.resolveToDescriptor(declaration)
        if (declaration is KtClass) {
            if (modifierList == declaration.primaryConstructorModifierList) {
                descriptor = (descriptor as ClassDescriptor).unsubstitutedPrimaryConstructor
-                             ?: error("No constructor found: ${declaration.getText()}")
+                        ?: error("No constructor found: ${declaration.getText()}")
            }
        }

@@ -445,9 +513,11 @@ class ResolveElementCache(
        return resolveSession.trace
    }

-    private fun delegationSpecifierAdditionalResolve(resolveSession: ResolveSession, ktElement: KtElement,
-                                                     classOrObject: KtClassOrObject, file: KtFile,
-                                                     bindingTraceFilter: BindingTraceFilter): BindingTrace {
+    private fun delegationSpecifierAdditionalResolve(
+        resolveSession: ResolveSession, ktElement: KtElement,
+        classOrObject: KtClassOrObject, file: KtFile,
+        bindingTraceFilter: BindingTraceFilter
+    ): BindingTrace {
        val trace = createDelegatingTrace(ktElement, bindingTraceFilter)
        val descriptor = resolveSession.resolveToDescriptor(classOrObject) as LazyClassDescriptor

@@ -455,20 +525,24 @@ class ResolveElementCache(
        ForceResolveUtil.forceResolveAllContents(descriptor.typeConstructor.supertypes)

        val bodyResolver = createBodyResolver(resolveSession, trace, file, StatementFilter.NONE)
-        bodyResolver.resolveSuperTypeEntryList(DataFlowInfo.EMPTY,
-                                               classOrObject,
-                                               descriptor,
-                                               descriptor.unsubstitutedPrimaryConstructor,
-                                               descriptor.scopeForConstructorHeaderResolution,
-                                               descriptor.scopeForMemberDeclarationResolution)
+        bodyResolver.resolveSuperTypeEntryList(
+            DataFlowInfo.EMPTY,
+            classOrObject,
+            descriptor,
+            descriptor.unsubstitutedPrimaryConstructor,
+            descriptor.scopeForConstructorHeaderResolution,
+            descriptor.scopeForMemberDeclarationResolution
+        )

        return trace
    }

-    private fun propertyAdditionalResolve(resolveSession: ResolveSession, property: KtProperty,
-                                          file: KtFile,
-                                          statementFilter: StatementFilter,
-                                          bindingTraceFilter: BindingTraceFilter): BindingTrace {
+    private fun propertyAdditionalResolve(
+        resolveSession: ResolveSession, property: KtProperty,
+        file: KtFile,
+        statementFilter: StatementFilter,
+        bindingTraceFilter: BindingTraceFilter
+    ): BindingTrace {
        val trace = createDelegatingTrace(property, bindingTraceFilter)

        val bodyResolver = createBodyResolver(resolveSession, trace, file, statementFilter)
@@ -488,15 +562,17 @@ class ResolveElementCache(

        for (accessor in property.accessors) {
            ControlFlowInformationProvider(
-                    accessor, trace, accessor.languageVersionSettings, resolveSession.platformDiagnosticSuppressor
+                accessor, trace, accessor.languageVersionSettings, resolveSession.platformDiagnosticSuppressor
            ).checkDeclaration()
        }

        return trace
    }

-    private fun scriptAdditionalResolve(resolveSession: ResolveSession, script: KtScript,
-                                        bindingTraceFilter: BindingTraceFilter): BindingTrace {
+    private fun scriptAdditionalResolve(
+        resolveSession: ResolveSession, script: KtScript,
+        bindingTraceFilter: BindingTraceFilter
+    ): BindingTrace {
        val trace = createDelegatingTrace(script, bindingTraceFilter)
        val scriptDescriptor = resolveSession.resolveToDescriptor(script) as ScriptDescriptor
        ForceResolveUtil.forceResolveAllContents(scriptDescriptor)
@@ -504,9 +580,11 @@ class ResolveElementCache(
        return trace
    }

-    private fun functionAdditionalResolve(resolveSession: ResolveSession, namedFunction: KtNamedFunction, file: KtFile,
-                                          statementFilter: StatementFilter,
-                                          bindingTraceFilter: BindingTraceFilter): BindingTrace {
+    private fun functionAdditionalResolve(
+        resolveSession: ResolveSession, namedFunction: KtNamedFunction, file: KtFile,
+        statementFilter: StatementFilter,
+        bindingTraceFilter: BindingTraceFilter
+    ): BindingTrace {
        val trace = createDelegatingTrace(namedFunction, bindingTraceFilter)

        val scope = resolveSession.declarationScopeProvider.getResolutionScopeForDeclaration(namedFunction)
@@ -521,9 +599,11 @@ class ResolveElementCache(
        return trace
    }

-    private fun secondaryConstructorAdditionalResolve(resolveSession: ResolveSession, constructor: KtSecondaryConstructor,
-                                                      file: KtFile, statementFilter: StatementFilter,
-                                                      bindingTraceFilter: BindingTraceFilter): BindingTrace {
+    private fun secondaryConstructorAdditionalResolve(
+        resolveSession: ResolveSession, constructor: KtSecondaryConstructor,
+        file: KtFile, statementFilter: StatementFilter,
+        bindingTraceFilter: BindingTraceFilter
+    ): BindingTrace {
        val trace = createDelegatingTrace(constructor, bindingTraceFilter)

        val scope = resolveSession.declarationScopeProvider.getResolutionScopeForDeclaration(constructor)
@@ -538,20 +618,33 @@ class ResolveElementCache(
        return trace
    }

-    private fun constructorAdditionalResolve(resolveSession: ResolveSession, klass: KtClassOrObject, file: KtFile, filter : BindingTraceFilter): BindingTrace {
+    private fun constructorAdditionalResolve(
+        resolveSession: ResolveSession,
+        klass: KtClassOrObject,
+        file: KtFile,
+        filter: BindingTraceFilter
+    ): BindingTrace {
        val trace = createDelegatingTrace(klass, filter)

        val classDescriptor = resolveSession.resolveToDescriptor(klass) as ClassDescriptor
        val constructorDescriptor = classDescriptor.unsubstitutedPrimaryConstructor
-                                    ?: error("Can't get primary constructor for descriptor '$classDescriptor' " +
-                                             "in from class '${klass.getElementTextWithContext()}'")
+                ?: error(
+                    "Can't get primary constructor for descriptor '$classDescriptor' " +
+                            "in from class '${klass.getElementTextWithContext()}'"
+                )
        ForceResolveUtil.forceResolveAllContents(constructorDescriptor)

        val primaryConstructor = klass.primaryConstructor
        if (primaryConstructor != null) {
            val scope = resolveSession.declarationScopeProvider.getResolutionScopeForDeclaration(primaryConstructor)
            val bodyResolver = createBodyResolver(resolveSession, trace, file, StatementFilter.NONE)
-            bodyResolver.resolveConstructorParameterDefaultValues(DataFlowInfo.EMPTY, trace, primaryConstructor, constructorDescriptor, scope)
+            bodyResolver.resolveConstructorParameterDefaultValues(
+                DataFlowInfo.EMPTY,
+                trace,
+                primaryConstructor,
+                constructorDescriptor,
+                scope
+            )

            forceResolveAnnotationsInside(primaryConstructor)
        }
@@ -559,8 +652,10 @@ class ResolveElementCache(
        return trace
    }

-    private fun typealiasAdditionalResolve(resolveSession: ResolveSession, typeAlias: KtTypeAlias,
-                                           bindingTraceFilter: BindingTraceFilter): BindingTrace {
+    private fun typealiasAdditionalResolve(
+        resolveSession: ResolveSession, typeAlias: KtTypeAlias,
+        bindingTraceFilter: BindingTraceFilter
+    ): BindingTrace {
        val trace = createDelegatingTrace(typeAlias, bindingTraceFilter)
        val typeAliasDescriptor = resolveSession.resolveToDescriptor(typeAlias)
        ForceResolveUtil.forceResolveAllContents(typeAliasDescriptor)
@@ -568,9 +663,11 @@ class ResolveElementCache(
        return trace
    }

-    private fun initializerAdditionalResolve(resolveSession: ResolveSession, anonymousInitializer: KtAnonymousInitializer,
-                                             file: KtFile, statementFilter: StatementFilter,
-                                             bindingTraceFilter: BindingTraceFilter): BindingTrace {
+    private fun initializerAdditionalResolve(
+        resolveSession: ResolveSession, anonymousInitializer: KtAnonymousInitializer,
+        file: KtFile, statementFilter: StatementFilter,
+        bindingTraceFilter: BindingTraceFilter
+    ): BindingTrace {
        val trace = createDelegatingTrace(anonymousInitializer, bindingTraceFilter)

        val classOrObjectDescriptor = resolveSession.resolveToDescriptor(anonymousInitializer.containingDeclaration) as LazyClassDescriptor
@@ -592,32 +689,39 @@ class ResolveElementCache(
    }

    private fun createBodyResolver(
-            resolveSession: ResolveSession,
-            trace: BindingTrace,
-            file: KtFile,
-            statementFilter: StatementFilter
+        resolveSession: ResolveSession,
+        trace: BindingTrace,
+        file: KtFile,
+        statementFilter: StatementFilter
    ): BodyResolver {
        val globalContext = SimpleGlobalContext(resolveSession.storageManager, resolveSession.exceptionTracker)
        val module = resolveSession.moduleDescriptor
        return createContainerForBodyResolve(
-                globalContext.withProject(file.project).withModule(module),
-                trace,
-                targetPlatform,
-                statementFilter,
-                file.jvmTarget,
-                file.languageVersionSettings
+            globalContext.withProject(file.project).withModule(module),
+            trace,
+            targetPlatform,
+            statementFilter,
+            file.jvmTarget,
+            file.languageVersionSettings
        ).get<BodyResolver>()
    }

    // All additional resolve should be done to separate trace
    private fun createDelegatingTrace(resolveElement: KtElement, filter: BindingTraceFilter): BindingTrace {
        return resolveSession.storageManager.createSafeTrace(
-                DelegatingBindingTrace(resolveSession.bindingContext, "trace to resolve element", resolveElement, filter, allowSliceRewrite = true))
+            DelegatingBindingTrace(
+                resolveSession.bindingContext,
+                "trace to resolve element",
+                resolveElement,
+                filter,
+                allowSliceRewrite = true
+            )
+        )
    }

    private class BodyResolveContextForLazy(
-            private val topDownAnalysisMode: TopDownAnalysisMode,
-            private val declaringScopes: Function1<KtDeclaration, LexicalScope?>
+        private val topDownAnalysisMode: TopDownAnalysisMode,
+        private val declaringScopes: Function1<KtDeclaration, LexicalScope?>
    ) : BodiesResolveContext {
        override fun getFiles(): Collection<KtFile> = setOf()