public String getGroup() {
                    return moduleComponentIdentifier.getGroup();
                }

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

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

                return PendingState.NOT_PENDING;
            }
        }

        // Adding an optional dependency: see if we already have a hard dependency on the same module
        ModuleResolveState module = resolveState.getModule(key);
        boolean pending = module.isPending();

        // Already have a hard dependency, this optional dependency is not pending.
        if (!pending) {
            return PendingState.NOT_PENDING;
        }

            if (byGroup != 0) {
                return byGroup;
            }

            int byModule = leftRequested.getModule().compareTo(rightRequested.getModule());
            if (byModule != 0) {
                return byModule;
            }

            // Prefer a selector that strictly matches the selected version

        HashMap<String, String> attributes = new HashMap<>();
        attributes.put(PatternHelper.ORGANISATION_KEY, componentIdentifier.getGroup());
        attributes.put(PatternHelper.MODULE_KEY, componentIdentifier.getModule());
        attributes.put(PatternHelper.REVISION_KEY, componentIdentifier.getVersion());
        return attributes;
    }

    @Override
    public boolean isComplete(ModuleIdentifier moduleIdentifier) {

                caretTag = "restoreAt"
            ).single().first

        val project = declaration.project
        val declarationModule = ProjectStructureProvider.getModule(project, declaration, contextualModule = null)
        val restoreAtModule = ProjectStructureProvider.getModule(project, restoreAt, contextualModule = null)

        val (debugRendered, prettyRendered, pointer) = analyseForTest(declaration) {

        ImmutableMap<String, String> attributes = ImmutableMap.of(
            "organisation", componentIdentifier.getGroup(),
            "module", componentIdentifier.getModule(),
            "artifact", componentIdentifier.getModule(),
            "revision", componentIdentifier.getVersion()
        );
        ExternalResourceName resolve = getBase().getRoot().resolve(substituteTokens(getPathWithoutArtifactPart(), attributes));

import static org.junit.jupiter.api.Assertions.assertEquals;

public class ModuleBInternalTest {
    @Test
    public void testSomething() {
        assertEquals("org.gradle.sample", ModuleBInternal.class.getModule().getName());
        assertEquals("internal text", new ModuleBInternal().print());
    }

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

        project.getExtensions().add(SwiftApplication.class, "application", application);
        project.getComponents().add(application);

        // Setup component
        application.getModule().convention(GUtil.toCamelCase(project.getName()));

        application.getTargetMachines().convention(Dimensions.useHostAsDefaultTargetMachine(targetMachineFactory));

        if (overrideMetadata.getArtifact() != null) {
            return overrideMetadata.getArtifact();
        }
        return new DefaultIvyArtifactName(moduleComponentIdentifier.getModule(), "jar", "jar");
    }

    @Override