diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt index f9261f489fa..d29ecfd0b7e 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt @@ -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> = CachedValuesManager.getManager(project).createCachedValue( + private val fullResolveCache: CachedValue> = + CachedValuesManager.getManager(project).createCachedValue( CachedValueProvider> { - CachedValueProvider.Result.create(ContainerUtil.createConcurrentSoftValueMap(), - PsiModificationTracker.OUT_OF_CODE_BLOCK_MODIFICATION_COUNT, - resolveSession.exceptionTracker) + CachedValueProvider.Result.create( + ContainerUtil.createConcurrentSoftValueMap(), + 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> = - CachedValuesManager.getManager(project).createCachedValue( - CachedValueProvider> { - CachedValueProvider.Result.create(ContainerUtil.createConcurrentSoftValueMap(), - PsiModificationTracker.MODIFICATION_COUNT, - resolveSession.exceptionTracker) - }, - false) + CachedValuesManager.getManager(project).createCachedValue( + CachedValueProvider> { + CachedValueProvider.Result.create( + ContainerUtil.createConcurrentSoftValueMap(), + 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?, bodyResolveMode: BodyResolveMode): BindingContext { + fun getElementsAdditionalResolve( + resolveElement: KtElement, + contextElements: Collection?, + 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()) addResolveSessionBindingContext = true } - } - else { + } else { contextElements - .mapNotNull { it.getNonStrictParentOfType() } - .filterTo(declarationsToResolve) { - it !is KtAnonymousInitializer && it !is KtDestructuringDeclaration && it !is KtDestructuringDeclarationEntry - } + .mapNotNull { it.getNonStrictParentOfType() } + .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?, - bodyResolveMode: BodyResolveMode + resolveElement: KtElement, + contextElements: Collection?, + bodyResolveMode: BodyResolveMode ): Pair { 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(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(true) if (declaration != null) { doResolveAnnotations(getAnnotationsByDeclaration(resolveSession, modifierList, declaration)) - } - else { + } else { val fileAnnotationList = ktAnnotationEntry.getParentOfType(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() } // 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 + private val topDownAnalysisMode: TopDownAnalysisMode, + private val declaringScopes: Function1 ) : BodiesResolveContext { override fun getFiles(): Collection = setOf()