/**
     * Creates a derived session using the given local repository.
     *
     * @param localRepository the new local repository
     * @return the derived session
     * @throws NullPointerException if {@code localRepository} is null
     */
    @Nonnull
    Session withLocalRepository(@Nonnull LocalRepository localRepository);

    /**
     * Creates a derived session using the given remote repositories.
     *

            }
        }
    }

    private fun checkUntouchedSessionValidity(
        sessions: Set<SESSION>,
        testServices: TestServices,
    ) {
        sessions.forEach { session ->
            testServices.assertions.assertTrue(isSessionValid(session)) {

                .build()) {
            MavenSession mSession = new MavenSession(repoSession, request, new DefaultMavenExecutionResult());
            InternalSession iSession = new SimpleSession(mSession, repoSystem, null);
            InternalSession.associate(repoSession, iSession);

            List<RemoteRepository> repositories = RepositoryUtils.toRepos(request.getPluginArtifactRepositories());

            // by design to avoid iterating through the whole analysis session cache and to simplify the global session invalidation event.
            // Nevertheless, a `KaFirSession`'s validity is based on the underlying `LLFirSession`, so removed analysis sessions for
            // library modules might still be valid. This is not a problem, though, because analysis session caching is not required for

    }

    override fun afterLeavingAnalysis(session: KtAnalysisSession, useSiteModule: KtModule) {
        afterLeavingAnalysis(session)
    }

    private fun afterLeavingAnalysis(session: KtAnalysisSession) {
        writeActionStartedChecker.afterLeavingAnalysis()
        lifetimeTracker.afterLeavingAnalysis(session)
    }
}

        DefaultRepositorySystemSession rsession = new DefaultRepositorySystemSession(h -> false);
        rsession.setSystemProperties(properties);
        rsession.setConfigProperties(properties);

        DefaultSession session = new DefaultSession(
                rsession,
                system,
                List.of(lookup.lookup(RepositoryFactory.class)

                    return model;
                }
            }

            try {
                InternalSession iSession = InternalSession.from(session);
                Session iSessionWithRepos = iSession.withRemoteRepositories(request.getRepositories().stream()
                        .map(iSession::getRemoteRepository)
                        .toList());
                String gav =

    override fun getSessionKtModule(session: KaSession): KtModule = session.useSiteModule
    override fun isSessionValid(session: KaSession): Boolean = session.isValid()

    /**
     * The analysis session cache disregards whether libraries were invalidated during global invalidation, so some valid library analysis
     * sessions may have been evicted from the cache and should not be checked for validity.
     */

  </extensions>

  <projectListeners>
    <listener
        class="org.jetbrains.kotlin.analysis.api.fir.KaFirSessionProvider$SessionInvalidationListener"
        topic="org.jetbrains.kotlin.analysis.low.level.api.fir.sessions.LLFirSessionInvalidationListener"
    />
  </projectListeners>

        return isSubClassOf(candidateFirClass, baseFirClass, candidateFirClass.moduleData.session, allowIndirectSubtyping = false)
    }

    private fun KtClassOrObject.toFirSymbol(classId: ClassId, ktModule: KtModule): FirClassLikeSymbol<*>? {
        // Using a resolve session/source-preferred session will cause class stubs from binary libraries to be AST-loaded in IDE mode tests,