import org.gradle.api.artifacts.component.ComponentIdentifier;

/**
 * A node identifier that uniquely identifies a variant within a component by the variant's name.
 *
 * Note: Generally, variants should be identified by their attributes and capabilities, as the name
 * is more of a human-readable identifier.
 */
public class ComponentVariantNodeIdentifier implements NodeIdentifier {

 */

package org.gradle.api.artifacts;

import org.gradle.api.artifacts.component.ComponentIdentifier;

/**
 * Identifies a variant of a component by component identifier and variant name.
 *
 * @since 6.0
 */
public interface ComponentVariantIdentifier {

    /**
     * Returns the component identifier.
     */
    ComponentIdentifier getId();

    /**
     * Returns the variant name.
     */

            buildFile << """
                allprojects {
                    apply plugin: 'java'
                }
            """
        }
        includedBuilds << buildB
    }

    def "includes build identifier in logging output with #display"() {
        dependency "org.test:buildB:1.0"

        buildB.file("buildSrc/settings.gradle") << settings << "\n"
        buildB.file("buildSrc/build.gradle") << """

import static org.gradle.integtests.fixtures.SuggestionsMessages.repositoryHint

class BuildSrcIdentityIntegrationTest extends AbstractIntegrationSpec {
    def "includes build identifier in logging output with #display"() {
        file("buildSrc/build.gradle") << """
            println "configuring \$project.path"
            classes.doLast { t ->
                println "classes of \$t.path"

		t.Errorf("simultaneous uses/defs = %s, want %s", got, want)
	}

	// any left-over identifiers didn't exist in the source
	for x := range uses {
		if !foundUses[x] {
			t.Errorf("%s: identifier %s not present in source", x.Pos(), x.Value)
		}
	}
	for x := range defs {
		if !foundDefs[x] {
			t.Errorf("%s: identifier %s not present in source", x.Pos(), x.Value)
		}
	}

            .open();
        this.gradleVersion = gradleVersion;
    }

    @Override
    public File get(final String identifier, final Action<File> creator) {
        final File jarFile = jarFile(identifier);
        cache.useCache(new Runnable() {
            @Override
            public void run() {
                if (!jarFile.exists()) {
                    creator.execute(jarFile);

) {
    val pluginManagementBlock = topLevelBlocks.find { it.identifier == TopLevelBlockId.pluginManagement } ?: return
    val firstTopLevelBlock = topLevelBlocks.first()
    if (firstTopLevelBlock.identifier != TopLevelBlockId.pluginManagement) {
        throw UnexpectedBlockOrder(firstTopLevelBlock.identifier, firstTopLevelBlock.range, pluginManagementBlock.identifier)
    }
}


private

import org.jetbrains.kotlin.lexer.KtTokens.IDENTIFIER
import org.junit.Test


class CombinatorsTest {

    private
    val combinator = Combinator(ignoresComments = false, ignoresNewline = false)

    @Test
    fun `can recurse`() {
        var parser by reference<String>()
        parser = combinator.paren(parser) + combinator.token(IDENTIFIER) { tokenText }

        assertSuccess(parser("ok"), "ok")

        return variant;
    }

    @Override
    public boolean matchesStrictly(ComponentIdentifier identifier) {
        assert identifier != null : "identifier cannot be null";

        if (identifier instanceof LibraryBinaryIdentifier) {
            LibraryBinaryIdentifier projectComponentIdentifier = (LibraryBinaryIdentifier) identifier;
            return Objects.equal(projectComponentIdentifier.getProjectPath(), projectPath)

import org.gradle.internal.component.external.model.VirtualComponentIdentifier;

public class VirtualComponentHelper {
    /**
     * Decorates a component identifier, marking it as virtual.
     * @param id the original component identifier
     * @return a virtual component identifier
     */
    public static VirtualComponentIdentifier makeVirtual(final ComponentIdentifier id) {