ImmutableAttributes target = variantDefinition.getTargetAttributes();
        TransformChain transformChain = variantDefinition.getTransformChain();
        VariantResolveMetadata.Identifier identifier = sourceVariant.getIdentifier();
        if (identifier == null) {

 */
public interface VariantDefinition {
    /**
     * @return This variant's attributes after all chain transforms are applied.
     */
    ImmutableAttributes getTargetAttributes();

    /**
     * @return The transform chain which transforms the root variant to this variant.
     */
    TransformChain getTransformChain();

    /**

        this.transformChain = new TransformChain(previous == null ? null : previous.getTransformChain(), transformStep);
        this.transformStep = transformStep;
    }

    @Override
    public ImmutableAttributes getTargetAttributes() {
        return attributes;
    }

    @Override
    public TransformChain getTransformChain() {
        return transformChain;
    }

    @Override
    public TransformStep getTransformStep() {

     */
    public ResolvedVariant getRoot() {
        return root;
    }

    @Override
    public ImmutableAttributes getAttributes() {
        return chain.getTargetAttributes();
    }

    @Override
    public String toString() {
        return root.asDescribable().getDisplayName() + " <- " + chain + " = " + getAttributes();
    }

     * <p>
     * The attributes include all source attributes of the artifact before the transform,
     * values for some of which have been changed by the transform.
     */
    Map<String, String> getTargetAttributes();

    /**
     * Capabilities of the variant of the transformed artifact.
     * <p>
     * Artifact transforms can only change attributes, so the capabilities remain unchanged throughout the transform chain.

        return componentId;
    }

    @Override
    public Map<String, String> getSourceAttributes() {
        return sourceAttributes;
    }

    @Override
    public Map<String, String> getTargetAttributes() {
        return targetAttributes;
    }

    @Override
    public List<? extends Capability> getCapabilities() {
        return capabilities;
    }

    @Override

            getDisplayName() >> ""
        }
        VariantDefinition definition = Mock(VariantDefinition) {
            getTransformChain() >> new TransformChain(null, step)
            getTargetAttributes() >> attrs
        }
        return new TransformedVariant(root, definition)
    }

        DefaultVariantDefinition last = root;
        while (node != null) {
            last = new DefaultVariantDefinition(
                last,
                attributesFactory.concat(last.getTargetAttributes(), node.transform.getTo()),
                node.transform.getTransformStep()
            );
            node = node.next;
        }
        return last;
    }

    /**

        return new TransformedLocalFileArtifactSet((SingletonFileResolvedVariant) sourceVariant, variantDefinition.getTargetAttributes(), variantDefinition.getTransformChain(), dependenciesResolverFactory, calculatedValueContainerFactory);
    }

    @Override
    public void visitTransformSources(TransformSourceVisitor visitor) {

private
sealed class MappingSpec


private
class TransformMapping(private val targetAttributes: ImmutableAttributes, private val transformChain: TransformChain) : MappingSpec(), VariantDefinition {
    override fun getTargetAttributes(): ImmutableAttributes {
        return targetAttributes
    }

    override fun getTransformChain(): TransformChain {
        return transformChain
    }