// Those cases should be improved so that the parameters are always isolated, for example by always using work nodes to do this work
            for (BoundTransformStep step : transformSteps) {
                step.getTransformStep().isolateParametersIfNotAlready();
            }
        }

        @Override
        public void startFinalization(BuildOperationQueue<RunnableBuildOperation> actions, boolean requireFiles) {

    /**
     * Attributes that match the variant that is produced.
     */
    ImmutableAttributes getTo();

    /**
     * Transform step for artifacts of the variant.
     */
    TransformStep getTransformStep();

        this.transformStep = transformStep;
        this.upstreamDependencies = upstreamDependencies;
    }

    public TransformStep getTransformStep() {
        return transformStep;
    }

    public TransformUpstreamDependencies getUpstreamDependencies() {
        return upstreamDependencies;
    }

        return attributes;
    }

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

    @Override
    public TransformStep getTransformStep() {
        return transformStep;
    }

    @Nullable
    @Override
    public VariantDefinition getPrevious() {
        return previous;
    }

    private int getDepth() {

        return transformStepNode.getNodeIdentity();
    }

    @Override
    public Class<?> getTransformActionClass() {
        return transformStepNode.getTransformStep().getTransform().getImplementationClass();
    }

    @Override
    public String getTransformerName() {
        return transformerName;
    }

    @Override
    public String getSubjectName() {

     */
    TransformChain getTransformChain();

    /**
     * The single transform step which transforms the previous variant to this variant.
     */
    TransformStep getTransformStep();

    /**
     * @return The previous variant in the transform chain. If null, this variant uses the producer variant as its root.
     */
    @Nullable
    VariantDefinition getPrevious();

                            if (matcher.isMatching(rootAttrs, state.requested)) {
                                DefaultVariantDefinition rootTransformedVariant = new DefaultVariantDefinition(null, rootAttrs, candidate.getTransformStep());
                                VariantDefinition variantChain = createVariantChain(state.chain, rootTransformedVariant);
                                results.add(new CachedVariant(i, variantChain));

            // Isolate the transform parameters, if not already done
            for (BoundTransformStep step : steps) {
                step.getTransformStep().isolateParametersIfNotAlready();
                step.getUpstreamDependencies().finalizeIfNotAlready();
            }

            ImmutableList.Builder<Artifacts> builder = ImmutableList.builderWithExpectedSize(1);

        TransformStep transformStep = variantDefinition.getTransformStep();

        ImmutableList.Builder<TransformStepNode> builder = ImmutableList.builder();
        sourceArtifacts.visitTransformSources(new ResolvedArtifactSet.TransformSourceVisitor() {
            @Override

            return from;
        }

        @Override
        public ImmutableAttributes getTo() {
            return to;
        }

        @Override
        public TransformStep getTransformStep() {
            return transformStep;
        }

        @Override
        public String toString() {
            return transformStep + " transform from " + from + " to " + to;
        }
    }