}

    /**
     * @return The last step of this chain.
     */
    public TransformStep getLast() {
        return last;
    }

    public boolean requiresDependencies() {
        return (init != null && init.requiresDependencies()) || last.requiresDependencies();
    }

    public String getDisplayName() {
        String lastDisplayName = last.getDisplayName();
        return init == null
            ? lastDisplayName

    }

    public void isolateParametersIfNotAlready() {
        transform.isolateParametersIfNotAlready();
    }

    public boolean requiresDependencies() {
        return transform.requiresDependencies();
    }

    @Override
    public String getDisplayName() {
        return transform.getDisplayName();
    }

    public ImmutableAttributes getFromAttributes() {

    }

    @Override
    public TransformUpstreamDependenciesResolver create(ComponentIdentifier componentIdentifier, TransformChain transformChain) {
        if (!transformChain.requiresDependencies()) {
            return NO_DEPENDENCIES_RESOLVER;
        }

    }

    @Override
    public boolean isIsolated() {
        return isolatedParameters.isFinalized();
    }

    @Override
    public boolean requiresDependencies() {
        return requiresDependencies;
    }

    @Override
    public boolean requiresInputChanges() {
        return requiresInputChanges;
    }

    @Override
    public boolean isCacheable() {

    ImmutableAttributes getToAttributes();

    /**
     * Whether the transformer requires dependencies of the transformed artifact to be injected.
     */
    boolean requiresDependencies();

    /**
     * Whether the transformer requires {@link InputChanges} to be injected.
     */
    boolean requiresInputChanges();

    /**
     * Whether the transformer is cacheable.
     */

}


fun unpackTransformStep(transformStep: TransformStep, upstreamDependencies: TransformUpstreamDependencies): TransformStepSpec {
    return if (transformStep.requiresDependencies()) {
        TransformStepSpec.FileDependencies(transformStep, upstreamDependencies.selectedArtifacts(), upstreamDependencies.configurationIdentity!!)
    } else {
        TransformStepSpec.NoDependencies(transformStep)

            return factory.create(componentIdentifier, sourceVariant, variantDefinition, dependenciesResolverFactory);
        }
        VariantKey variantKey;
        if (transformChain.requiresDependencies()) {
            variantKey = new VariantWithUpstreamDependenciesKey(identifier, target, dependenciesResolverFactory);
        } else {
            variantKey = new VariantKey(identifier, target);
        }

    }

    @Override
    public TransformUpstreamDependencies dependenciesFor(TransformStep transformStep) {
        if (!transformStep.requiresDependencies()) {
            return NO_DEPENDENCIES;
        }
        return new TransformUpstreamDependenciesImpl(configurationIdentity, transformStep, calculatedValueContainerFactory);
    }