files = ImmutableList.of();
                isExternalVariant = false;
            } else {
                attributes = baseVariant.getAttributes();
                capabilities = baseVariant.getCapabilities();
                dependencies = baseVariant.getDependencies();
                dependencyConstraints = baseVariant.getDependencyConstraints();
                files = baseVariant.getFiles();

            copiedVariants.add(new LocalVariantMetadata(
                oldVariant.getName(), oldVariant.getIdentifier(), oldVariant.asDescribable(), oldVariant.getAttributes(),
                oldVariant.getCapabilities(), newArtifacts
            ));
        }

        CalculatedValue<ImmutableList<LocalComponentArtifactMetadata>> transformedArtifacts =

    @Nullable
    VariantResolveMetadata.Identifier getIdentifier();

    @Override
    AttributeContainerInternal getAttributes();

    ResolvedArtifactSet getArtifacts();

    ImmutableCapabilities getCapabilities();

    DisplayName asDescribable();

    @Override
    ImmutableAttributes getAttributes();

    ImmutableList<? extends ComponentArtifactMetadata> getArtifacts();

    @Override
    ImmutableCapabilities getCapabilities();

    boolean isExternalVariant();

    /**
     * Is this variant eligible for caching?
     *
     * Only variants from a project component are eligible for caching.
     *

            throw new UnsupportedOperationException("NameOnlyVariantResolveMetadata cannot be used that way");
        }

        @Override
        public ImmutableCapabilities getCapabilities() {
            throw new UnsupportedOperationException("NameOnlyVariantResolveMetadata cannot be used that way");
        }

        @Override
        public boolean isExternalVariant() {

        if (identifier == null || !variant.isEligibleForCaching()) {
            DisplayName displayName = variant.asDescribable();
            ImmutableCapabilities capabilities = withImplicitCapability(variant.getCapabilities(), component);
            return new ArtifactBackedResolvedVariant(identifier, displayName, attributes, capabilities, artifacts, new DefaultComponentArtifactResolver(component, artifactResolver));
        } else {

    public static Set<Capability> collectCapabilities(Configuration configuration, Set<Capability> out, Set<Configuration> visited) {
        if (visited.add(configuration)) {
            out.addAll(configuration.getOutgoing().getCapabilities());
            for (Configuration parent : configuration.getExtendsFrom()) {
                collectCapabilities(parent, out, visited);
            }
        }
        return out;
    }

     *
     * @since 4.6
     */
    String getDisplayName();

    /**
     * The capabilities provided by this variant
     *
     * @since 5.3
     */
    List<Capability> getCapabilities();

    /**
     * If present, this means that this variant is a bridge to another variant
     * found in another module. This corresponds to variants which are marked
     * as "available-at" in Gradle Module Metadata.

    private int capabilities;
    private byte[] serverGuid = new byte[16];
    private int securityMode;
    private int dialect;


    /**
     * @return the capabilities
     */
    public int getCapabilities () {
        return this.capabilities;
    }


    /**
     * @return the serverGuid
     */
    public byte[] getServerGuid () {
        return this.serverGuid;
    }


    /**

    @Override
    public CapabilitiesMetadata asImmutable() {
        return new DefaultCapabilitiesMetadata(asImmutableCapabilities());
    }

    @Override
    public ImmutableList<? extends Capability> getCapabilities() {
        return ImmutableList.copyOf(descriptors);
    }

    public ImmutableCapabilities asImmutableCapabilities() {
        return new ImmutableCapabilities(ImmutableSet.copyOf(descriptors));
    }