/**
     * Publishes an event of global modification of the module state of all [KtModule]s.
     */
    @TestOnly
    public abstract fun publishGlobalModuleStateModification()

    /**
     * Publishes an event of global modification of the module state of all source [KtModule]s.
     */
    @TestOnly
    public abstract fun publishGlobalSourceModuleStateModification()

    /**

        this.projectBuilds = projectBuilds;
    }

    public int getNumberOfBuilds() {
        return projectBuilds.size();
    }

    /**
     * Gets all the builds that have no reactor-dependencies
     *
     * @return A set of all the initial builds
     */
    public List<MavenProject> getRootSchedulableBuilds() {
        Set<MavenProject> result = new LinkedHashSet<>();

    endWithNewLine: Boolean = true
) {
    appendLine(prop.name + ":")
    withIndent {
        renderer(prop.call(), endWithNewLine)
    }
}

private fun PrettyPrinter.appendSimpleProperty(prop: KProperty<Any>, endWithNewLine: Boolean = true) {
    append(prop.name + ": ")
    append(prop.call().toString())
    if (endWithNewLine) appendLine()

import com.intellij.openapi.application.ApplicationManager

/**
 * Ensures that a [WriteActionStartedInAnalysisContextException] is thrown if a write action was started *inside* an
 * [analyze][org.jetbrains.kotlin.analysis.api.analyze] call.
 */
internal class KaBaseWriteActionStartedChecker(parentDisposable: Disposable) {
    private val currentAnalyzeCallDepth = ThreadLocal.withInitial { 0 }

    init {
        val listener = object : ApplicationListener {

        if (candidates.isEmpty()) {
            testServices.assertions.assertEquals(null, resolvedCall) {
                "Inconsistency between candidates and resolved call. " +
                        "Resolved call is not null, but no candidates found.\n" +
                        stringRepresentation(resolvedCall)
            }
        } else {
            if (resolvedCall == null) return

    /**
     * Creates a new [KaCallableSignature] by given symbol and leave all types intact
     */
    public fun <S : KaCallableSymbol> S.asSignature(): KaCallableSignature<S> =
        withValidityAssertion { analysisSession.signatureSubstitutor.asSignature(this) }

    /**
     * Creates a new [KaCallableSignature] by given symbol and leave all types intact
     */

 *
 * @since 4.0.0
 */
@Experimental
public interface PathType {
    /**
     * The type for all paths that could not be placed in any of the types requested by a caller.
     * This type can appear in the return value of a call to
     * {@link Session#resolveDependencies resolveDependencies(...)} when at least one dependency

 utilizing the local installation, the group level allows configuration management for all the projects
 that belong to the same group, the project level allows configuration management at
 the project level, and the user level allows users to override settings on
 the site level, group level and project level.

* Site configuration

    /**
     * [onModification] is invoked in a write action before or after global out-of-block modification of all sources.
     *
     * The source code of all source [KtModule]s in the project should be considered modified when this event is received. This includes
     * source files being moved or removed. Thus, all caches related to source code and source files should be invalidated.
     *

/**
 * A callable symbol partially applied with receivers and type arguments. Essentially, this is a call that misses some information. For
 * properties, the missing information is the type of access (read, write, or compound access) to this property. For functions, the missing
 * information is the value arguments for the call.
 */
public class KaPartiallyAppliedSymbol<out S : KaCallableSymbol, out C : KaCallableSignature<S>>(