public class ProjectOrderingUtil {
    public static int compare(Project left, Project right) {
        return compare(owner(left), owner(right));
    }

    public static int compare(ProjectState left, ProjectState right) {
        int depthCompare = depthCompare(left, right);
        if (depthCompare == 0) {
            return left.getProjectPath().compareTo(right.getProjectPath());
        } else {
            return depthCompare;
        }

!define Rel_Left(e_from,e_to, e_label, e_techn) Rel_L(e_from,e_to, e_label, e_techn)

!define Rel_R(e_from,e_to, e_label) Rel_(e_from,e_to, e_label, "-RIGHT->")
!define Rel_R(e_from,e_to, e_label, e_techn) Rel_(e_from,e_to, e_label, e_techn, "-RIGHT->")
!define Rel_Right(e_from,e_to, e_label) Rel_R(e_from,e_to, e_label)
!define Rel_Right(e_from,e_to, e_label, e_techn) Rel_R(e_from,e_to, e_label, e_techn)

' Layout Helpers

        this(context, left, right, right.getProducer());
    }

    private OrElseValueProducer(EvaluationContext.ScopeContext context, ProviderInternal<?> left, @Nullable ProviderInternal<?> right, ValueSupplier.ValueProducer rightProducer) {
        this.owner = Objects.requireNonNull(context.getOwner());
        this.left = left;
        this.right = right;

        return (leftType.isInstance(left) && rightType.isInstance(right))
                || (leftType.isInstance(right) && rightType.isInstance(left));
    }

    @Override
    @Nullable
    public ExcludeSpec intersect(ExcludeSpec left, ExcludeSpec right, ExcludeFactory factory) {
        if (leftType.isInstance(left) && rightType.isInstance(right)) {

    private final ProviderInternal<? extends T> right;

    public OrElseProvider(ProviderInternal<T> left, ProviderInternal<? extends T> right) {
        this.left = left;
        this.right = right;
    }

    @Override
    protected String toStringNoReentrance() {
        return String.format("or(%s, %s)", left, right);
    }

    @Nullable
    @Override
    public Class<T> getType() {

        }

        private ExcludePair(ExcludeSpec left, ExcludeSpec right) {
            this.left = left;
            this.right = right;
            this.hashCode = 31 * left.hashCode() + right.hashCode();
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {

        } else if (right instanceof GroupExclude) {
            return tryGroupUnion((GroupExclude) right, left);
        }
        if (left instanceof ModuleSetExclude) {
            return tryModuleSetUnion((ModuleSetExclude) left, right);
        } else if (right instanceof ModuleSetExclude) {
            return tryModuleSetUnion((ModuleSetExclude) right, left);
        }

    private final AbstractFileCollection left;
    private final FileCollection right;

    public SubtractingFileCollection(AbstractFileCollection left, FileCollection right) {
        super(left.taskDependencyFactory, left.patternSetFactory);
        this.left = left;
        this.right = right;
    }

    public AbstractFileCollection getLeft() {
        return left;
    }

        return !(left != null ? !left.equals(pair.left) : pair.left != null) && !(right != null ? !right.equals(pair.right) : pair.right != null);
    }

    @Override
    public int hashCode() {
        int result = left != null ? left.hashCode() : 0;
        result = 31 * result + (right != null ? right.hashCode() : 0);
        return result;
    }

    @Override
    public String toString() {

Currently, Gradle has no good way to defend against these changes, and will simply cache whatever is in the output directory once the task is finished.
This again can lead to corrupted results being uploaded to the shared cache.
This recommendation might change when Gradle has added the necessary safeguards against unintentional modification of task inputs and outputs.

[WARNING]
====