} else if (dependency instanceof Closure) {
                Closure closure = (Closure) dependency;
                Object closureResult = closure.call(context.getTask());
                if (closureResult != null) {
                    queue.addFirst(closureResult);
                }
            } else if (dependency instanceof List) {

            while (retries < maxTentativesCount) {
                retries++;
                E failure;
                Throwable unexpectedFailure = null;
                try {
                    failure = operation.call();
                    if (failure == null) {
                        if (retries > 1) {
                            LOGGER.debug("Successfully fetched external resource after {} retries", retries - 1);

    /**
     * If value has to be created, the original value is returned without (de)serialization
     *
     * This is delicate API, because the original value is returned only for the first call of this function.
     * As such, the call should probably be guarded with additional synchronization and memoization.
     *
     * Prefer [loadOrCreateValue] unless there is a special reason.
     */

 * <p>
 * The Lock Owner will inform this contention handler that it holds the lock via {@link #start(long, Consumer)}.
 * There it provides an action that this handler can call to release the lock, in case a release is requested.
 * <p>
 * A Lock Requester will notice that a lock is held by a Lock Holder by failing to lock the lock file.

        @Override
        public <T> T readFile(Callable<? extends T> action) throws LockTimeoutException, FileIntegrityViolationException, InsufficientLockModeException {
            try {
                return action.call();
            } catch (Exception e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }

        @Override

 * - a `writeObject` method with no corresponding `readObject`; `writeObject` must eventually call [ObjectOutputStream.defaultWriteObject];
 * - a `readObject` method with no corresponding `writeObject`; `readObject` must eventually call [ObjectInputStream.defaultReadObject];
 * - a `writeReplace` method to allow the class to nominate a replacement to be written;

        then: 1 * processor.completed(9, { it.resultType == null })
        then: 1 * processor.completed(6, { it.resultType == null })

        0 * processor._
    }

    def "stopNow should fail on call"() {
        when: classProcessor.stopNow()

        then:
        UnsupportedOperationException uoe = thrown()
    }

 * A problem is identified using a key object.
 * The implementation should be thread-safe and should support tracking problems in multiple threads, each with its own call stack.
 */
interface DynamicCallProblemReporting {
    /**
     * Begin tracking a new dynamic call on the call stack, with no problems reported in it initially.

        when:
        property.finalizeValue()

        then:
        1 * function.call() >> {
            // Emulate concurrent get() in other thread
            EvaluationContext.current().evaluateNested(property::get)
        }
        1 * function.call() >> someValue()
        0 * function._

        when:
        def result = property.get()

        then:

                    error("expected a configuring lambda in the call of ${function.schemaFunction}, but it was not provided")
            }
        } else if (lambda != null) {
            error("a lambda is not expected in the call of ${function.schemaFunction}, but it was provided")
        }
    }

    private
    fun AnalysisContext.doRecordSemanticsSideEffects(
        call: FunctionCall,
        semantics: FunctionSemantics,