this.compilationDetails = compilationDetails;
        this.linkageDetails = linkageDetails;
    }

    public String getName() {
        return name;
    }

    public String getVariantName() {
        return variantName;
    }

    public String getBaseName() {
        return baseName;
    }

    public DefaultCompilationDetails getCompilationDetails() {
        return compilationDetails;

        if (cand.getId().equals(resolutionDetails.selected.getId())) {
            if (cand.getVariantName().equals(resolutionDetails.selected.getVariantName())) {
                cand.select();
                String reason = resolutionDetails.reason;
                if (reason != null) {

     * @return property holding name of the variant to report
     */
    @Input
    @Optional
    @Option(option = "variant", description = "The name of the single variant to report")
    public abstract Property<String> getVariantName();

    /**
     * Shows all variants, including legacy and deprecated configurations.
     *
     * @return property holding the flag to show all variants
     */
    @Input
    @Optional

        resolutionStrategy.capabilitiesResolution {
          withCapability("com.google.guava:guava") {
            candidates
              .find {
                val variantName = it.javaClass.getDeclaredMethod("getVariantName")
                (variantName.invoke(it) as String).contains("android")
              }
              ?.apply { select(this) }
          }
        }
      }
    }

     */
    String getVariantName();

    /**
     * Returns the base name of this binary. This is used to calculate output file names.
     */
    String getBaseName();

    /**
     * Returns the compilation details.
     */

        Collection<? extends CandidateDetails> getCandidates(Capability capability);
        boolean hasResult();
    }

    interface CandidateDetails {
        ComponentIdentifier getId();
        String getVariantName();
        void evict();
        void select();
        void reject();
        void byReason(Describable description);
    }

    interface Resolver {
        void resolve(ResolutionDetails details);
    }

public interface ComponentVariantIdentifier {

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

    /**
     * Returns the variant name.
     */
    String getVariantName();

        this.id = id;
        this.variantName = variantName;
    }

    @Override
    public ComponentIdentifier getId() {
        return id;
    }

    @Override
    public String getVariantName() {
        return variantName;
    }

    @Override
    public String toString() {
        return id + "(" + variantName + ")";
    }

 * the generated names to avoid recreating multiple times.
 */
public class VariantNameBuilder {
    private final Map<List<String>, DisplayName> names = new HashMap<>();

    @Nullable
    public DisplayName getVariantName(@Nullable List<String> parts) {
        if (parts == null) {
            return null;
        }

        DisplayName displayName = names.get(parts);
        if (displayName == null) {

            this.artifact = artifact;
            this.target = target;
            this.capabilities = capabilities;
            this.transformSteps = transformSteps;
        }

        public DisplayName getVariantName() {
            return variantName;
        }

        public ResolvableArtifact getArtifact() {
            return artifact;
        }

        public ImmutableAttributes getTarget() {