val tree = parseAsTopLevelBlock(
            """
            myFun {
                a = "x"
                a = b
                b = f(a = "x")
                b = f(a = "x") { test() }
                call(x = { }) // TODO: right now, it is reported as an unsupported language feature FunctionDeclaration, report it in a more precise way?
                multiLambda({ }, { })
                1
                a.b()

        subprojectDir.mkdirs()
        FileTreeBuilder builder = new FileTreeBuilder(subprojectDir)
        config.setDelegate(builder)
        config.resolveStrategy = Closure.DELEGATE_FIRST
        config.call()
    }

    const desktopMediaQuery = window.matchMedia("screen and (min-width: 64rem)");

    [].forEach.call(document.querySelectorAll(".docs-navigation a[href$='/" + getCurrentChapterFileName(window.location.pathname) + "']"), function (link) {
        // Add "active" to all links same as current URL
        link.classList.add("active");

        // Expand all parent navigation
        var parentListEl = link.closest("li");

 * All other timestamps are calculated as the wall clock time at last sync + elapsed time since.
 * <p>
 * This clock deals relatively well when the system wall clock shift is adjusted by small amounts.
 * It also deals relatively well when the system wall clock jumps forward by large amounts (this clock will jump with it).
 * It does not deal as well with large jumps back in time.
 * <p>

                    // even though the task was not found, the current project is coupled with the other project:
                    // if the configuration of that project changes, the result of this call might be different
                    val coupledProjects = listOfNotNull(parentPath?.let { referrerProject.findProject(it) })
                    reportCrossProjectTaskAccess(coupledProjects, path)
                }

        when:
        try {
            cache.open()
        } finally {
            cache.close()
        }

        then:
        0 * _  // Does not call initialization action.
        dir.file("cache.properties").isFile()
        dir.file("some-file").isFile()
    }

    def "will rebuild cache if not unlocked cleanly"() {
        given:

    /**
     * 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.
     */

        try {
            oos.writeObject(message);
        } finally {
            oos.flush();
        }
    }

    /**
     * Read back an object from the provided stream that has been serialized by a call to {@link #send(Object, java.io.OutputStream)}. Any {@link Throwable} that cannot be de-serialized (for whatever
     * reason) will be replaced by a {@link PlaceholderException}.
     *

 * 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.

        synchronized (instanceLock) {
            return stopActions;
        }
    }

    @Override
    public void maybeStop() {
        // We don't want to call stop actions with the lock held.
        ExecutionResult<Void> stopResult = ExecutionResult.forEach(getStopActions(), action -> action.accept(this));
        synchronized (instanceLock) {
            try {