modules.forEach { analysisSessionProvider.cache.remove(it) }
        }

        override fun afterGlobalInvalidation() {
            // Session invalidation events currently don't report whether library modules were included in the global invalidation. This is
            // by design to avoid iterating through the whole analysis session cache and to simplify the global session invalidation event.

) : KotlinPackagePartProviderFactory() {
    private val cache = ContainerUtil.createConcurrentSoftMap<GlobalSearchScope, PackagePartProvider>()

    override fun createPackagePartProvider(scope: GlobalSearchScope): PackagePartProvider {
        return cache.getOrPut(scope) {
            packagePartProvider(scope)
        }
    }

        }
    }

    private static <T> T cache(ModelCache cache, Source source, ModelCacheTag<T> tag, Callable<T> supplier) {
        Supplier<T> s = asSupplier(supplier);
        if (cache == null) {
            return s.get();
        } else {
            return cache.computeIfAbsent(source, tag.getName(), s);
        }
    }

            }
        }
    }
}

private class BuilderCache<From, To : KaSymbol> {
    private val cache = ContainerUtil.createConcurrentWeakKeySoftValueMap<From, To>()

    inline fun <reified S : To> cache(key: From, calculation: () -> S): S {
        val value = cache.getOrPut(key, calculation)
        return value as? S
            ?: errorWithAttachment("Cannot cast ${value::class} to ${S::class}") {

				<configuration>
					<includes>
						<include>**/**Test.java</include>
					</includes>
					<systemPropertyVariables>
						<networkaddress.cache.ttl>-1</networkaddress.cache.ttl>
						<networkaddress.cache.negative.ttl>-1</networkaddress.cache.negative.ttl>
					</systemPropertyVariables>
					<properties>
						<property>
							<name>listener</name>
							<value>jcifs.tests.PrintingRunListener</value>

                }
                result = flattenResult;
            } else {
                PathModularizationCache cache = new PathModularizationCache(); // TODO: should be project-wide cache.
                DefaultDependencyResolverResult resolverResult = new DefaultDependencyResolverResult(
                        cache, collectorResult.getExceptions(), collectorResult.getRoot(), nodes.size());

    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.
     */
    override fun shouldSkipValidityCheck(session: KaSession): Boolean =

import java.util.StringJoiner;
import java.util.function.Predicate;

import org.apache.maven.api.JavaPathType;
import org.apache.maven.api.PathType;

/**
 * Cache of {@link PathModularization} instances computed for given {@link Path} elements.
 * The cache is used for avoiding the need to reopen the same files many times when the
 * same dependency is used for different scope. For example a path used for compilation

      - name: Set up JDK
        uses: actions/setup-java@v4
        with:
          java-version: ${{ matrix.java }}
          distribution: 'temurin'
#          cache: 'maven' - don't use cache for integration tests

      - uses: actions/checkout@v4
        with:
          path: maven/
          persist-credentials: false

      - name: Set up Maven
        run:

     * The function is meant to only be used for providing auto-completion for Kotlin in IntelliJ IDEA.
     *
     * The returned checker does not cache the results for individual callable candidates.
     *
     * @param originalFile The file being edited.
     * @param nameExpression The expression under the caret in an in-memory copy of [originalFile]