haveRetArg         bool
			retLine            []int
		)

		flushRet := func() {
			if fn != nil && fn.vars["ret"] != nil && !haveRetArg && len(retLine) > 0 {
				v := fn.vars["ret"]
				resultStr := fmt.Sprintf("%d-byte ret+%d(FP)", v.size, v.off)
				if abi == "ABIInternal" {
					resultStr = "result register"
				}
				for _, line := range retLine {

        }

        int getRetainedFilesInCurrentBuild() {
            def retainedInformation = spec.result.getPostBuildOutputLineThatContains("Virtual file system retains information about ")
            def numberMatcher = retainedInformation =~ /Virtual file system retains information about (\d+) files, (\d+) directories and (\d+) missing files until next build/
            return numberMatcher[0][1] as int
        }

This can happen if you mount a project directory or subdirectory from a network drive.
Gradle doesn't retain information about unsupported file systems between builds when enabled by default.
If you explicitly enable file system watching, Gradle retains information about unsupported file systems between builds.

== Logging

            }
            return null;
        }
    }

    /**
     * Retains strong references to the keys and values via the key's ClassLoader. This allows the ClassLoader to be collected.
     */
    private static class DefaultClassMap<V> extends AbstractCrossBuildInMemoryCache<Class<?>, V> {
        // Currently retains strong references to types that are not loaded using a VisitableURLClassLoader

     */
    abstract val unshadedPackages: SetProperty<String>

    /**
     * Do not retain classes in the ignore packages hierarchies, unless reachable from some other retained class.
     */
    abstract val ignoredPackages: SetProperty<String>

        result.output =~ /Virtual file system retained information about \d+ files, \d+ directories and \d+ missing files since last build/
        result.output =~ /Received \d+ file system events during the current build while watching \d+ locations/
        result.output =~ /Virtual file system retains information about \d+ files, \d+ directories and \d+ missing files until next build/

        when:

// Package ledger implements a modified map with three unique characteristics:
// 1. every unique state of the map is given a unique hash
// 2. prior states of the map are retained for a fixed period of time
// 2. given a previous hash, we can retrieve a previous state from the map, if it is still retained.
package ledger

import (
	"encoding/base64"
	"time"

	"github.com/spaolacci/murmur3"
)

    @Override
    CrossBuildInMemoryCache<String, Object> newCache() {
        return factory.newCacheRetainingDataFromPreviousBuild { value -> true }
    }

    def "retains values from the previous session"() {
        def function = Mock(Function)

        when:
        def cache = newCache()
        cache.get("a", function)
        cache.get("b", function)

/**
 * A factory for {@link CrossBuildInMemoryCache} instances.
 *
 * Note that this implementation should only be used to create global scoped services.
 * Note that this implementation currently retains strong references to keys and values during the whole lifetime of a build session.
 *

 *
 * The lifecycle of details and result objects are effectively undetermined.
 * The build scan plugin will retain the objects for a short time after the operation has
 * completed, in order to "process" them on a separate thread.
 * It can be assumed that this processing happens relatively quickly,
 * after which the objects are no longer retained.
 *
 * Consideration should be given to the package space of the details and result types.