[FIR] Get rid of FirSession.moduleInfo

2021-04-30 11:11:03 +03:00
parent 57a8642f5a
commit f16194e60d
19 changed files with 65 additions and 77 deletions
@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.FirModuleVisibilityChecker
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
 import org.jetbrains.kotlin.fir.declarations.containerSource
+import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.load.kotlin.JvmPackagePartSource
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinarySourceElement
 import org.jetbrains.kotlin.load.kotlin.VirtualFileKotlinClass
@@ -18,7 +19,7 @@ import java.nio.file.Paths

 class FirJvmModuleVisibilityChecker(private val session: FirSession) : FirModuleVisibilityChecker {
    override fun isInFriendModule(declaration: FirMemberDeclaration): Boolean {
-        val moduleInfo = session.moduleInfo as? FirJvmModuleInfo ?: return false
+        val moduleInfo = (session.moduleData as? FirModuleInfoBasedModuleData)?.moduleInfo as? FirJvmModuleInfo ?: return false
        val binaryClass = when (val source = declaration.containerSource) {
            is KotlinJvmBinarySourceElement -> source.binaryClass
            is JvmPackagePartSource -> source.knownJvmBinaryClass
@@ -41,7 +41,7 @@ import org.jetbrains.kotlin.load.kotlin.VirtualFileFinderFactory
@OptIn(PrivateSessionConstructor::class, SessionConfiguration::class)
 object FirSessionFactory {
    class FirSessionConfigurator(private val session: FirSession) {
-        private val registeredExtensions = mutableListOf<BunchOfRegisteredExtensions>(BunchOfRegisteredExtensions.empty())
+        private val registeredExtensions: MutableList<BunchOfRegisteredExtensions> = mutableListOf(BunchOfRegisteredExtensions.empty())

        fun registerExtensions(extensions: BunchOfRegisteredExtensions) {
            registeredExtensions += extensions
@@ -78,7 +78,7 @@ object FirSessionFactory {
        lookupTracker: LookupTracker? = null,
        init: FirSessionConfigurator.() -> Unit = {}
    ): FirJavaModuleBasedSession {
-        return FirJavaModuleBasedSession(moduleInfo, sessionProvider).apply session@{
+        return FirJavaModuleBasedSession(sessionProvider).apply session@{
            val moduleData = FirModuleInfoBasedModuleData(moduleInfo).apply { bindSession(this@session) }
            registerModuleData(moduleData)
            registerCliCompilerOnlyComponents()
@@ -137,8 +137,9 @@ object FirSessionFactory {
        packagePartProvider: PackagePartProvider,
        languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT,
    ): FirLibrarySession {
-        return FirLibrarySession(moduleInfo, sessionProvider).apply session@{
+        return FirLibrarySession(sessionProvider).apply session@{
            val moduleData = FirModuleInfoBasedModuleData(moduleInfo).apply { bindSession(this@session) }
+            sessionProvider.registerSession(moduleData, this)
            registerCliCompilerOnlyComponents()
            registerCommonComponents(languageVersionSettings)

@@ -5,38 +5,26 @@

 package org.jetbrains.kotlin.fir.java

-import com.intellij.openapi.project.Project
-import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.fir.*

@OptIn(PrivateSessionConstructor::class)
 class FirJavaModuleBasedSession @PrivateSessionConstructor constructor(
-    moduleInfo: ModuleInfo,
    sessionProvider: FirProjectSessionProvider,
-) : FirModuleBasedSession(moduleInfo, sessionProvider) {
-    init {
-        sessionProvider.registerSession(moduleInfo, this)
-    }
-}
+) : FirModuleBasedSession(sessionProvider)

@OptIn(PrivateSessionConstructor::class)
 class FirLibrarySession @PrivateSessionConstructor constructor(
-    override val moduleInfo: ModuleInfo,
-    sessionProvider: FirProjectSessionProvider,
-) : FirSession(sessionProvider) {
-    init {
-        sessionProvider.registerSession(moduleInfo, this)
+    sessionProvider: FirProjectSessionProvider
+) : FirSession(sessionProvider)
+
+open class FirProjectSessionProvider : FirSessionProvider() {
+    override fun getSession(moduleData: FirModuleData): FirSession? {
+        return sessionCache[moduleData]
    }
-}
-
-open class FirProjectSessionProvider : FirSessionProvider {
-    override fun getSession(moduleInfo: ModuleInfo): FirSession? {
-        return sessionCache[moduleInfo]
-    }
-
-    fun registerSession(moduleInfo: ModuleInfo, session: FirSession) {
-        sessionCache[moduleInfo] = session
-    }
-
-    protected open val sessionCache: MutableMap<ModuleInfo, FirSession> = mutableMapOf()
+
+    fun registerSession(moduleData: FirModuleData, session: FirSession) {
+        sessionCache[moduleData] = session
+    }
+
+    protected open val sessionCache: MutableMap<FirModuleData, FirSession> = mutableMapOf()
 }
@@ -18,8 +18,6 @@ class FirJavaEnhancementContext private constructor(
            this(session, lazy(LazyThreadSafetyMode.NONE, typeQualifiersComputation))

    val defaultTypeQualifiers: JavaTypeQualifiersByElementType? by delegateForDefaultTypeQualifiers
-
-    val moduleInfo get() = session.moduleInfo
 }

 fun extractDefaultNullabilityQualifier(
@@ -5,10 +5,7 @@

 package org.jetbrains.kotlin.fir

-import org.jetbrains.kotlin.analyzer.ModuleInfo
-
@OptIn(PrivateSessionConstructor::class)
 abstract class FirModuleBasedSession @PrivateSessionConstructor constructor(
-    override val moduleInfo: ModuleInfo,
    sessionProvider: FirSessionProvider?
 ) : FirSession(sessionProvider)
@@ -5,10 +5,8 @@

 package org.jetbrains.kotlin.fir.resolve.providers.impl

-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.ThreadSafeMutableState
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.caches.*
-import org.jetbrains.kotlin.fir.dependenciesWithoutSelf
 import org.jetbrains.kotlin.fir.resolve.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProviderInternals
@@ -31,10 +29,10 @@ open class FirDependenciesSymbolProviderImpl(session: FirSession) : FirSymbolPro


    protected open val dependencyProviders by lazy {
-        val moduleInfo = session.moduleInfo ?: return@lazy emptyList()
-        moduleInfo.dependenciesWithoutSelf().mapNotNull {
+        val moduleData = session.nullableModuleData ?: return@lazy emptyList()
+        moduleData.dependencies.mapNotNull {
            session.sessionProvider?.getSession(it)?.symbolProvider
-        }.toList()
+        }
    }

    @OptIn(FirSymbolProviderInternals::class, ExperimentalStdlibApi::class)
@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirImport
 import org.jetbrains.kotlin.fir.declarations.FirResolvedImport
 import org.jetbrains.kotlin.fir.declarations.builder.buildImport
+import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.transformers.FirImportResolveTransformer

@@ -24,7 +25,7 @@ class FirDefaultSimpleImportingScope(

    override val simpleImports = run {
        val importResolveTransformer = FirImportResolveTransformer(session)
-        val analyzerServices = session.moduleInfo?.analyzerServices
+        val analyzerServices = session.moduleData.analyzerServices
        val allDefaultImports = priority.getAllDefaultImports(analyzerServices, LanguageVersionSettingsImpl.DEFAULT)
        allDefaultImports
            ?.filter { !it.isAllUnder }
@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.builder.buildImport
 import org.jetbrains.kotlin.fir.declarations.builder.buildResolvedImport
+import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
@@ -20,10 +21,9 @@ class FirDefaultStarImportingScope(
    filter: FirImportingScopeFilter,
    priority: DefaultImportPriority
 ) : FirAbstractStarImportingScope(session, scopeSession, filter, lookupInFir = false) {
-
    // TODO: put languageVersionSettings into FirSession?
    override val starImports = run {
-        val analyzerServices = session.moduleInfo?.analyzerServices
+        val analyzerServices = session.moduleData.analyzerServices
        val allDefaultImports = priority.getAllDefaultImports(analyzerServices, LanguageVersionSettingsImpl.DEFAULT)
        allDefaultImports
            ?.filter { it.isAllUnder }
@@ -41,4 +41,7 @@ class FirModuleDataImpl(
    override val analyzerServices: PlatformDependentAnalyzerServices
 ) : FirModuleData()

-val FirSession.moduleData: FirModuleData by FirSession.sessionComponentAccessor()
+val FirSession.nullableModuleData: FirModuleData? by FirSession.nullableSessionComponentAccessor()
+val FirSession.moduleData: FirModuleData
+    get() = nullableModuleData ?: error("Module data is not registered in $this")
+
@@ -5,7 +5,6 @@

 package org.jetbrains.kotlin.fir

-import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.fir.types.impl.*
 import org.jetbrains.kotlin.fir.utils.ArrayMapAccessor
 import org.jetbrains.kotlin.fir.utils.ComponentArrayOwner
@@ -27,8 +26,6 @@ abstract class FirSession @PrivateSessionConstructor constructor(val sessionProv
        }
    }

-    open val moduleInfo: ModuleInfo? get() = null
-
    val javaTypeEnhancementState: JavaTypeEnhancementState? get() = null

    open val builtinTypes: BuiltinTypes = BuiltinTypes()
@@ -41,8 +38,8 @@ abstract class FirSession @PrivateSessionConstructor constructor(val sessionProv
    }
 }

-interface FirSessionProvider {
-    fun getSession(moduleInfo: ModuleInfo): FirSession?
+abstract class FirSessionProvider {
+    abstract fun getSession(moduleData: FirModuleData): FirSession?
 }

 class BuiltinTypes {
@@ -15,7 +15,8 @@ import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollector
 import org.jetbrains.kotlin.fir.analysis.collectors.components.*
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.checkers.*
-import org.jetbrains.kotlin.idea.caches.project.ModuleSourceInfo
+import org.jetbrains.kotlin.fir.moduleData
+import org.jetbrains.kotlin.idea.fir.low.level.api.sessions.moduleSourceInfo
 import org.jetbrains.kotlin.platform.SimplePlatform
 import org.jetbrains.kotlin.platform.jvm.JvmPlatform

@@ -36,7 +37,7 @@ private object CheckersFactory {
        reporter: DiagnosticReporter,
        useExtendedCheckers: Boolean
    ): List<AbstractDiagnosticCollectorComponent> {
-        val moduleInfo = session.moduleInfo as ModuleSourceInfo
+        val moduleInfo = session.moduleData.moduleSourceInfo
        val platform = moduleInfo.platform.componentPlatforms.single()
        val declarationCheckers = createDeclarationCheckers(useExtendedCheckers, platform)
        val expressionCheckers = createExpressionCheckers(useExtendedCheckers)
@@ -16,7 +16,6 @@ import org.jetbrains.kotlin.fir.PrivateSessionConstructor
 */
@OptIn(PrivateSessionConstructor::class)
 internal class FirIdeLibrariesSession @PrivateSessionConstructor constructor(
-    override val moduleInfo: ModuleInfo,
    override val project: Project,
    override val scope: GlobalSearchScope,
    builtinTypes: BuiltinTypes,
@@ -7,9 +7,7 @@ package org.jetbrains.kotlin.idea.fir.low.level.api.sessions

 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.fir.BuiltinTypes
-import org.jetbrains.kotlin.fir.FirModuleBasedSession
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.PrivateSessionConstructor

@@ -20,6 +18,5 @@ abstract class FirIdeSession(override val builtinTypes: BuiltinTypes) : FirSessi

@OptIn(PrivateSessionConstructor::class)
 abstract class FirIdeModuleSession(builtinTypes: BuiltinTypes) : FirIdeSession(builtinTypes) {
-    abstract override val moduleInfo: ModuleInfo
    abstract val scope: GlobalSearchScope
 }
@@ -71,7 +71,7 @@ internal object FirIdeSessionFactory {
        val searchScope = ModuleProductionSourceScope(moduleInfo.module)
        val dependentModules = moduleInfo.dependenciesWithoutSelf()
            .filterIsInstanceTo<ModuleSourceInfo, MutableList<ModuleSourceInfo>>(mutableListOf())
-        val session = FirIdeSourcesSession(moduleInfo, dependentModules, project, searchScope, firBuilder, builtinTypes)
+        val session = FirIdeSourcesSession(dependentModules, project, searchScope, firBuilder, builtinTypes)
        sessionsCache[moduleInfo] = session


@@ -172,7 +172,7 @@ internal object FirIdeSessionFactory {
        val packagePartProvider = IDEPackagePartProvider(searchScope)

        val kotlinClassFinder = VirtualFileFinderFactory.getInstance(project).create(searchScope)
-        FirIdeLibrariesSession(moduleInfo, project, searchScope, builtinTypes).apply session@{
+        FirIdeLibrariesSession(project, searchScope, builtinTypes).apply session@{
            val moduleData = FirModuleInfoBasedModuleData(moduleInfo).apply { bindSession(this@session) }

            registerIdeComponents()
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.idea.fir.low.level.api.sessions

 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.FirSessionProvider
 import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
@@ -21,8 +22,11 @@ class FirIdeSessionProvider internal constructor(
    val project: Project,
    internal val rootModuleSession: FirIdeSourcesSession,
    val sessions: Map<ModuleSourceInfo, FirIdeSession>
-) : FirSessionProvider {
-    override fun getSession(moduleInfo: ModuleInfo): FirSession? =
+) : FirSessionProvider() {
+    override fun getSession(moduleData: FirModuleData): FirSession? =
+        sessions[moduleData.moduleSourceInfo]
+
+    fun getSession(moduleInfo: IdeaModuleInfo): FirSession? =
        sessions[moduleInfo]

    internal fun getModuleCache(moduleSourceInfo: ModuleSourceInfo): ModuleFileCache =
@@ -9,12 +9,14 @@ import com.intellij.openapi.project.Project
 import kotlinx.collections.immutable.PersistentMap
 import kotlinx.collections.immutable.persistentMapOf
 import kotlinx.collections.immutable.toPersistentMap
-import org.jetbrains.kotlin.analyzer.LibraryModuleInfo
+import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.fir.BuiltinTypes
+import org.jetbrains.kotlin.fir.FirModuleData
+import org.jetbrains.kotlin.fir.moduleData
+import org.jetbrains.kotlin.fir.session.FirModuleInfoBasedModuleData
 import org.jetbrains.kotlin.idea.caches.project.LibraryModificationTracker
 import org.jetbrains.kotlin.idea.caches.project.ModuleSourceInfo
 import org.jetbrains.kotlin.idea.fir.low.level.api.FirPhaseRunner
-import org.jetbrains.kotlin.idea.fir.low.level.api.trackers.KotlinFirOutOfBlockModificationTrackerFactory
 import org.jetbrains.kotlin.idea.fir.low.level.api.util.addValueFor
 import org.jetbrains.kotlin.idea.fir.low.level.api.util.executeWithoutPCE
 import org.jetbrains.kotlin.idea.util.*
@@ -65,7 +67,7 @@ private class FromModuleViewSessionCache(
    private var mappings: PersistentMap<ModuleSourceInfo, FirSessionWithModificationTracker> = persistentMapOf()

    val sessionInvalidator: FirSessionInvalidator = FirSessionInvalidator { session ->
-        mappings[session.moduleInfo]?.invalidate()
+        mappings[session.moduleData.moduleSourceInfo]?.invalidate()
    }


@@ -104,7 +106,7 @@ private class FromModuleViewSessionCache(
        }
        return wasSessionInvalidated.entries
            .mapNotNull { (session, wasInvalidated) -> session.takeUnless { wasInvalidated } }
-            .associate { session -> session.firSession.moduleInfo to session.firSession }
+            .associate { session -> session.firSession.moduleData.moduleSourceInfo to session.firSession }
    }

    private fun <T> Collection<T>.reversedDependencies(getDependencies: (T) -> List<T>): Map<T, List<T>> {
@@ -121,7 +123,8 @@ private class FromModuleViewSessionCache(
 private class FirSessionWithModificationTracker(
    val firSession: FirIdeSourcesSession,
 ) {
-    private val modificationTracker = firSession.moduleInfo.module.createModuleWithoutDependenciesOutOfBlockModificationTracker()
+    private val modificationTracker =
+        firSession.moduleData.moduleSourceInfo.module.createModuleWithoutDependenciesOutOfBlockModificationTracker()

    private val timeStamp = modificationTracker.modificationCount

@@ -133,4 +136,10 @@ private class FirSessionWithModificationTracker(
    }

    val isValid: Boolean get() = !isInvalidated && modificationTracker.modificationCount == timeStamp
-}
+}
+
+val FirModuleData.moduleSourceInfo: ModuleSourceInfo
+    get() = moduleInfoUnsafe()
+
+inline fun <reified T : ModuleInfo> FirModuleData.moduleInfoUnsafe(): T = (this as FirModuleInfoBasedModuleData).moduleInfo as T
+inline fun <reified T : ModuleInfo> FirModuleData.moduleInfoSafe(): T? = (this as FirModuleInfoBasedModuleData).moduleInfo as? T
@@ -7,17 +7,14 @@ package org.jetbrains.kotlin.idea.fir.low.level.api.sessions

 import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.fir.BuiltinTypes
 import org.jetbrains.kotlin.fir.PrivateSessionConstructor
-import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
 import org.jetbrains.kotlin.idea.caches.project.ModuleSourceInfo
 import org.jetbrains.kotlin.idea.fir.low.level.api.file.builder.FirFileBuilder
 import org.jetbrains.kotlin.idea.fir.low.level.api.providers.firIdeProvider

@OptIn(PrivateSessionConstructor::class)
 internal class FirIdeSourcesSession @PrivateSessionConstructor constructor(
-    override val moduleInfo: ModuleSourceInfo,
    val dependencies: List<ModuleSourceInfo>,
    override val project: Project,
    override val scope: GlobalSearchScope,
@@ -10,14 +10,11 @@ import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiManager
 import com.intellij.psi.search.FileTypeIndex
-import org.jetbrains.kotlin.fir.FirRenderer
-import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
-import org.jetbrains.kotlin.fir.dependenciesWithoutSelf
 import org.jetbrains.kotlin.fir.java.*
-import org.jetbrains.kotlin.fir.psi
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirProviderImpl
@@ -28,6 +25,8 @@ import org.jetbrains.kotlin.idea.caches.project.IdeaModuleInfo
 import org.jetbrains.kotlin.idea.caches.project.isLibraryClasses
 import org.jetbrains.kotlin.idea.caches.project.productionSourceInfo
 import org.jetbrains.kotlin.idea.caches.resolve.IDEPackagePartProvider
+import org.jetbrains.kotlin.idea.fir.low.level.api.sessions.moduleInfoUnsafe
+import org.jetbrains.kotlin.idea.fir.low.level.api.sessions.moduleSourceInfo
 import org.jetbrains.kotlin.idea.multiplatform.setupMppProjectFromDirStructure
 import org.jetbrains.kotlin.idea.stubs.AbstractMultiModuleTest
 import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil
@@ -79,7 +78,7 @@ abstract class AbstractFirMultiModuleResolveTest : AbstractMultiModuleTest() {
            val builder = RawFirBuilder(session, firProvider.kotlinScopeProvider)
            val psiManager = PsiManager.getInstance(project)

-            val ideaModuleInfo = session.moduleInfo.cast<IdeaModuleInfo>()
+            val ideaModuleInfo = session.moduleData.moduleInfoUnsafe<IdeaModuleInfo>()

            ideaModuleInfo.dependenciesWithoutSelf().forEach {
                if (it is IdeaModuleInfo && it.isLibraryClasses()) {
@@ -11,6 +11,7 @@ import com.intellij.openapi.module.Module
 import com.intellij.openapi.vfs.LocalFileSystem
 import com.intellij.testFramework.PsiTestUtil
 import junit.framework.Assert
+import org.jetbrains.kotlin.fir.moduleData
 import org.jetbrains.kotlin.idea.caches.project.ModuleSourceInfo
 import org.jetbrains.kotlin.idea.caches.project.productionSourceInfo
 import org.jetbrains.kotlin.idea.fir.low.level.api.TestProjectModule
@@ -19,11 +20,8 @@ import org.jetbrains.kotlin.idea.fir.low.level.api.TestProjectStructureReader
 import org.jetbrains.kotlin.idea.fir.low.level.api.incModificationTracker
 import org.jetbrains.kotlin.idea.jsonUtils.getString
 import org.jetbrains.kotlin.idea.stubs.AbstractMultiModuleTest
-import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.jetbrains.kotlin.test.util.KtTestUtil
-import java.nio.file.Files
 import java.nio.file.Paths
-import kotlin.io.path.writeText

 abstract class AbstractSessionsInvalidationTest : AbstractMultiModuleTest() {
    override fun getTestDataPath(): String =
@@ -60,7 +58,7 @@ abstract class AbstractSessionsInvalidationTest : AbstractMultiModuleTest() {
        val sessionsAfterOOBM = storage.getFirSessions(rootModuleSourceInfo)

        val changedSessions = Sets.symmetricDifference(initialSessions, sessionsAfterOOBM)
-        val changedSessionsModulesNamesSorted = changedSessions.map { (it.moduleInfo as ModuleSourceInfo).module.name }.distinct().sorted()
+        val changedSessionsModulesNamesSorted = changedSessions.map { it.moduleData.moduleSourceInfo.module.name }.distinct().sorted()

        Assert.assertEquals(testStructure.expectedInvalidatedModules, changedSessionsModulesNamesSorted)
    }