import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Denotes that the {@link RuleSource} method rule carrying this annotation finalizes the rule subject.
 * <p>
 * Finalize rules execute after {@link Mutate} rules, but before {@link Validate} rules.
 * The first parameter of the rule is the rule subject, which is mutable for the duration of the rule.
 * <p>

        dependencyPredecessors.add(fromNode);
        return this;
    }

    @Override
    public DependentNodesSet addFinalizer(Node finalizer) {
        return new ComplexDependentNodesSet(this).addFinalizer(finalizer);
    }

    @Override
    public DependentNodesSet addMustPredecessor(Node fromNode) {
        return new ComplexDependentNodesSet(this).addMustPredecessor(fromNode);
    }

        updateDependencyNodes(getDependencyNodes().addMustSuccessor(toNode));
        toNode.addMustPredecessor(this);
    }

    public void addFinalizingSuccessor(Node finalized) {
        finalizingSuccessors.add(finalized);
        finalized.addFinalizer(this);
    }

    public void addShouldSuccessor(Node toNode) {
        deprecateLifecycleHookReferencingNonLocalTask("shouldRunAfter", toNode);

public interface HasConfigurableValueInternal extends HasConfigurableValue {
    /**
     * Same semantics as {@link org.gradle.api.provider.HasConfigurableValue#finalizeValue()}, but finalizes the value of this object lazily, when the value is queried.
     * Implementations may then fail on subsequent changes, or generate a deprecation warning and ignore changes.
     */
    void implicitFinalizeValue();

     * or when no properties are set.
     * <p>
     * A {@link #isConfigured() non-configured} spec is always valid.
     */
    boolean isValid();

    /**
     * Finalizes values of all spec properties, disallowing any further changes.
     */
    void finalizeProperties();

    QueryableExecutionPlan getContents();

    /**
     * Calculates the execution plan for the current entry tasks. May be called multiple times.
     */
    void determineExecutionPlan();

    /**
     * Finalizes this plan once all nodes have been added. Must be called after {@link #determineExecutionPlan()}.
     */
    FinalizedExecutionPlan finalizePlan();

    /**

     */
    TaskDependencyContainer getTaskDependencies();

    /**
     * Finalizes the property value, if possible. This makes the value final, so that it no longer changes, but not necessarily immutable.
     */
    void maybeFinalizeValue();

    PropertyValue ABSENT = new PropertyValue() {

     *
     * A file is owned by the build if it is registered as an output directly or within a directory registered as an output.
     */
    boolean isOutputOwnedByBuild(File file);

    /**
     * Finalizes the registered build outputs.
     *
     * After this call, it is impossible to register more outputs.
     */
    void resolveOutputs();

    /**
     * Gets the set of registered outputs as file collections.

        and:
        outputContains("Executing unzip transform...")
    }

    @Issue("https://github.com/gradle/gradle/issues/20195")
    def "producer task that finalizes a destroyer task will run after the destroyer even when ordered first (type: #type)"() {
        def foo = subproject(':foo')
        def bar = subproject(':bar')

     * point, Finalizer can stop running
     */
    if (!finalizableReferenceClass.getName().equals(FINALIZABLE_REFERENCE)) {
      throw new IllegalArgumentException("Expected " + FINALIZABLE_REFERENCE + ".");
    }

    Finalizer finalizer = new Finalizer(finalizableReferenceClass, queue, frqReference);
    String threadName = Finalizer.class.getName();
    Thread thread = null;