reasons.add(reason);
        } else if (isNewReason(reasons, reason)) {
            reasons.add(reason);
        }
    }

    private static boolean isNewReason(List<ComponentSelectionDescriptorInternal> reasons, ComponentSelectionDescriptorInternal reason) {
        return (reasons.size() == 1 && !reason.equals(reasons.get(0)))
            || !reasons.contains(reason);
    }

    @Override

    void check(ComponentSelectionDescriptor... reasons) {
        def reason = ComponentSelectionReasons.of(reasons)
        def result = serialize(reason, serializer)
        assert result == reason
    }

    private static ComponentSelectionReason withReason(String reason) {
        ComponentSelectionReasons.of(ComponentSelectionReasons.SELECTED_BY_RULE.withDescription(Describables.of(reason)))
    }

    }

    private UpToDateResult executeBecause(UnitOfWork work, ImmutableList<String> reasons, C context) {
        logExecutionReasons(reasons, work);
        AfterExecutionResult result = delegate.execute(work, context);
        return new UpToDateResult(result, reasons);
    }

    private static void logExecutionReasons(List<String> reasons, UnitOfWork work) {
        if (LOGGER.isInfoEnabled()) {

        if (totalUnavailableDaemons > 0) {
            final List<String> reasons = new ArrayList<>();
            if (numBusy > 0) {
                reasons.add(numBusy + " busy");
            }
            if (numIncompatible > 0) {
                reasons.add(numIncompatible + " incompatible");
            }
            if (numStopped > 0) {
                reasons.add(numStopped + " stopped");
            }

                if (next.hasCustomDescription()) {
                    reasons.add(next.getDescription());
                }
            }
            if (reasons.size() == 1) {
                sb.append(": ").append(reasons.get(0));
            } else {
                sb.append("s: ");
                Joiner.on(", ").appendTo(sb, reasons);
            }
        }
    }

            ) : SuccessfulElementResolution
        }

        data class ElementNotResolved(override val reasons: List<ElementNotResolvedReason>) : ElementResolution, UnsuccessfulResolution
    }

    data object ErrorResolution : DocumentNodeResolution, UnsuccessfulResolution {
        override val reasons: Iterable<ResolutionFailureReason>
            get() = listOf(IsError)
    }

        DaemonExpirationStatus expirationStatus = DO_NOT_EXPIRE;

        List<String> reasons = new ArrayList<>();
        for (DaemonExpirationStrategy expirationStrategy : expirationStrategies) {
            // If any of the child strategies don't expire the daemon, the daemon will not expire.
            // Otherwise, the daemon will expire and aggregate the reasons together.
            expirationResult = expirationStrategy.checkExpiration();

    def "reports no execution reasons for skipped tasks"() {
        given:
        buildFile << """
            task disabledTask {
                enabled = false
            }
        """

        when:
        runBuild('disabledTask')

        then:
        taskSkippedResult(':disabledTask')
    }

    def "reports execution reason for executed task without declared outputs"() {

        def messageReasons = getReasons(e.message)
        messageReasons.size() == reasons.size()
        messageReasons.sort() == reasons.sort()

        where:
        ruleSource                                | reasons
        new RuleSourceWithNoMethod()              | [ "Must have at exactly one method annotated with @org.gradle.model.Mutate" ]

        DaemonExpirationStatus expirationStatus = DO_NOT_EXPIRE;
        List<String> reasons = new ArrayList<>();

        for (DaemonExpirationStrategy expirationStrategy : expirationStrategies) {
            expirationResult = expirationStrategy.checkExpiration();
            if (expirationResult.getStatus() != DO_NOT_EXPIRE) {
                reasons.add(expirationResult.getReason());