}

        @Override
        public ExcludeSpec doIntersect(ModuleExclude left, ModuleExclude right, ExcludeFactory factory) {
            String module = left.getModule();
            if (right.getModule().equals(module)) {
                return left;
            } else {
                return factory.nothing();
            }
        }
    }

    @NonNullApi

package org.jetbrains.kotlin.analysis.api.fir.symbols

import org.jetbrains.kotlin.analysis.api.fir.KaFirSession
import org.jetbrains.kotlin.analysis.api.fir.components.KaFirSessionComponent
import org.jetbrains.kotlin.analysis.api.getModule
import org.jetbrains.kotlin.analysis.api.symbols.*
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFirFile
import org.jetbrains.kotlin.analysis.low.level.api.fir.api.resolveToFirSymbol

        ModuleVersionSelector moduleSelector = autoAppliedPlugin.getModule();
        if (moduleSelector != null) {
            predicate = predicate.or(dependency -> hasMatchingCoordinates(dependency, moduleSelector.getModule()));
        }

        Configuration classpathConfiguration = scriptHandler.getConfigurations().getByName(ScriptHandler.CLASSPATH_CONFIGURATION);

            for (NodeState ns : nodes) {
                if (ns.isSelected()) {
                    candidatesForConflict.add(ns);
                    if (ns.isRoot()) {
                        rootId = ns.getComponent().getId().getModule();
                    }
                }
            }
            if (rootId != null && candidatesForConflict.size() > 1) {
                // This is a special case for backwards compatibility: it is possible to have

            return;
        }

        if (isConstraint) {
            // Need to double check that the target still has hard edges to it
            ModuleResolveState module = targetComponent.getModule();
            if (module.isPending()) {
                selector.getTargetModule().removeUnattachedDependency(this);
                from.makePending(this);
                module.registerConstraintProvider(from);

            classpath = registry.getModule("gradle-daemon-server").getAllRequiredModulesClasspath();
            classpath = classpath.plus(registry.getModule("gradle-daemon-main").getImplementationClasspath());
            searchClassPath = registry.getAdditionalClassPath().getAsFiles();
        } else {

        analyseForTest(mainFile) {
            val fileSymbol = mainFile.getFileSymbol()
            val module = fileSymbol.getContainingModule()

            val providerModule = ProjectStructureProvider.getModule(mainFile.project, mainFile, contextualModule = null)
            assert(module == providerModule)
            assert(module == mainModule.ktModule)

            val actualString = buildString {

    Module publishWithChangedContent()
    Module withModuleMetadata()
    Module withSignature(@DelegatesTo(value = File, strategy = Closure.DELEGATE_FIRST) Closure<?> signer)

    String getGroup()
    String getModule()
    String getVersion()

    /**
     * Returns the Gradle module metadata file of this module
     */
    ModuleArtifact getModuleMetadata()
    GradleModuleMetadata getParsedModuleMetadata()

        // or removed only in the dangling file.
        val baseKtModule = when (val ktModule = ProjectStructureProvider.getModule(project, ktClass, contextualModule = null)) {
            is KtDanglingFileModule -> ktModule.contextModule
            else -> ktModule
        }

    }

    @Override
    public String getOrganisation() {
        return backingModule.getOrganisation();
    }

    @Override
    public String getModule() {
        return backingModule.getModule();
    }

    @Override
    public String getVersion() {
        return backingModule.getVersion();
    }

    @Override
    public String getRevision() {