}

    @Override
    public List<? extends VariantGraphResolveMetadata> getVariantsForGraphTraversal() {
        if (graphVariants == null) {
            graphVariants = buildVariantsForGraphTraversal(getVariants());
        }
        return graphVariants.orElse(Collections.emptyList());
    }

        // Visit explicit sub-variants
        NamedDomainObjectContainer<ConfigurationVariant> subvariants = outgoingConfiguration.getOutgoing().getVariants();
        for (ConfigurationVariant subvariant : subvariants) {
            String publishedVariantName = outgoingConfigurationName + StringUtils.capitalize(subvariant.getName());

        this.missing = metadata.isMissing();
        this.statusScheme = metadata.getStatusScheme();
        this.moduleSources = MutableModuleSources.of(metadata.getSources());
        this.variants = metadata.getVariants();
        this.attributesFactory = metadata.getAttributesFactory();
        this.schema = metadata.getAttributesSchema();
        this.componentLevelAttributes = attributesFactory.mutable(metadata.getAttributes());

                ComponentWithVariants parent = (ComponentWithVariants) component;
                // Child components are not top-level entry points.
                children.addAll(parent.getVariants());
            }
        }
        return children;
    }

    /**
     * Resolves the coordinates of variants of a single component
     */
    private interface VariantCoordinateResolver<T> {

                ))
            );
        }
        if (softwareComponent instanceof ComponentWithVariants) {
            for (SoftwareComponent childComponent : ((ComponentWithVariants) softwareComponent).getVariants()) {
                checker.checkComponent(childComponent);
                ModuleVersionIdentifier childCoordinates = coordinatesOf(childComponent);
                assert childCoordinates != null;

        return configurationDefinitions;
    }

    private Optional<List<? extends VariantGraphResolveMetadata>> buildVariantsForGraphTraversal() {
        ImmutableList<? extends ComponentVariant> variants = getVariants();
        if (variants.isEmpty()) {
            return addVariantsByRule(maybeDeriveVariants());
        }
        ImmutableList.Builder<VariantGraphResolveMetadata> configurations = new ImmutableList.Builder<>();

            ]
        }

        when:
        services.configureClassesDirectoryVariant(apiElements, sourceSet)

        then:
        1 * apiElements.getOutgoing() >> outgoing
        1 * outgoing.getVariants() >> variants
        1 * variants.maybeCreate('classes') >> variant
        1 * variant.getAttributes() >> attrs
        1 * variant.artifactsProvider(_) >> {
            def artifacts = it[0].create()

        ComponentDependencyResolver componentResolver =
            new ResolutionBackedComponentDependencyResolver(root, moduleIdentifierFactory, projectDependencyResolver);

        ResolvedVariantResult rootVariant = root.getVariants().stream()
            .filter(x -> x.getDisplayName().equals(rootVariantName))
            .findFirst().orElse(null);

        VariantDependencyResolver variantResolver;
        if (rootVariant == null) {

        ImmutableAttributes componentRequested = attributesFactory.concat(requestAttributes, producer.getOverriddenAttributes());
        final List<ResolvedVariant> variants = ImmutableList.copyOf(producer.getVariants());

        List<? extends ResolvedVariant> matches = matcher.matches(variants, componentRequested, explanationBuilder);
        if (matches.size() == 1) {
            return matches.get(0).getArtifacts();

        ImmutableList<? extends ComponentVariant> variants = LazyToRealisedModuleComponentResolveMetadataHelper.realiseVariants(metadata, variantMetadataRules, metadata.getVariants());
        Map<String, ModuleConfigurationMetadata> configurations = Maps.newHashMapWithExpectedSize(metadata.getConfigurationNames().size());
        ImmutableList<ModuleConfigurationMetadata> derivedVariants = ImmutableList.of();