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

        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:

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

        public VirtualFileSystemStatistics(Multiset<FileType> retained) {
            this.retained = retained;
        }

        public int getRetained(FileType fileType) {
            return retained.count(fileType);
        }
    }

}


internal
data class StandardEditorPosition(
    private val line: Int,
    private val column: Int = 0
) : EditorPosition, Serializable {

    override fun getLine() = line

    override fun getColumn() = column
}


internal
abstract class AbstractKotlinDslScriptsModelBuilder : ToolingModelBuilder {

    companion object {
        private

    /**
     * The line number within the file.
     * <p>
     * The line is <b>one-indexed</b>, i.e. the first line in the file is line number 1.
     *
     * @return the line number
     */
    int getLine();

    /**
     * The starting column on the selected line.
     * <p>
     * The column is <b>one-indexed</b>, i.e. the first column in the file is line number 1.

with a non-zero code if the diff is not empty.

The -go flag causes tidy to update the 'go' directive in the go.mod
file to the given version, which may change which module dependencies
are retained as explicit requirements in the go.mod file.
(Go versions 1.17 and higher retain more requirements in order to
support lazy module loading.)

The -compat flag preserves any additional checksums needed for the