/**
     * The [KtModule]'s properties or references to other modules are being changed.
     *
     * #### Examples
     *
     *  - The name of the module is being changed.
     *  - The module's content roots are being changed, such as adding another source folder to a source module.
     *  - If module A depends on module B and module B is being removed, in addition to the removal event for module B, module A also

# If 'go get -u' finds an upgrade candidate that isn't viable,
# but some other upgraded module's requirement moves past it
# (for example, to a higher prerelease), then we should accept
# the transitive upgrade instead of trying lower roots.

go get -v -u . example.net/b@v0.1.0
cmp go.mod go.mod.want

-- go.mod --
module example

go 1.17

require (
	example.net/a v0.1.0
	example.net/b v0.1.0
	example.net/c v0.1.0
)

    /**
     * The underlying fingerprints indexed by absolute path.
     */
    Map<String, FileSystemLocationFingerprint> getFingerprints();

    /**
     * The Merkle hashes of the roots which make up this file collection fingerprint.
     */
    ImmutableMultimap<String, HashCode> getRootHashes();

    boolean wasCreatedWithStrategy(FingerprintingStrategy strategy);

        if (isExplodedModularRuntime(jdkHome)) {
            try {
                try (DirectoryStream<Path> roots = Files.newDirectoryStream(jdkHome.resolve("modules"))) {
                    for (Path root : roots) {
                        result.add(getUrlForLibraryRoot(root));
                    }
                }
            }
            catch (IOException ignore) {
            }
        }

    variantImplementation[style=dashed, label=<main<i>Variant</i>Implementation<br/>(configuration)>]
  }

  subgraph secondLine {
    includeRoot[style="rounded,filled", fillcolor="#bfffbf", label="Compilation include roots"]
  }

  subgraph thirdLine {
    {rank=same sourceFiles compileVariantCpp outputDirectory}
    includeRoot -> compileVariantCpp
    sourceFiles -> compileVariantCpp
    compileVariantCpp -> outputDirectory

        def textFile = file('text-file.txt')
        textFile.text = "text file as root"

        expect:
        fails language.compileTaskName
        failure.assertHasCause(
            'Unable to infer source roots. ' +
                'Incremental Groovy compilation requires the source roots. ' +
                'Change the configuration of your sources or disable incremental Groovy compilation.')
    }

        textFile.text = "text file as root"

        outputs.snapshot { run language.compileTaskName }

        when:
        file("extra/B.${language.name}").text = "class B { String change; }"
        executer.withArgument "--info"
        run language.compileTaskName

        then:
        outputs.recompiledClasses("A", "B", "C")

# a reproducible build list.
go list -m all
stdout '^golang.org/issue/46078$'

# 'go mod tidy' should fix this (and not crash).
go mod tidy


# We prune out redundant roots very early on in module loading, and at that
# point the indirect requirement on example.net/x v0.1.0 appears to be
# irrelevant. It should be pruned out; when the import of "example.net/x" is

     *
     * {@link Optional#empty()} if no information is available.
     */
    Optional<MetadataSnapshot> getSnapshot();

    boolean hasDescendants();

    /**
     * Returns all the snapshot roots accessible from the node.
     */
    Stream<FileSystemLocationSnapshot> rootSnapshots();

    /*
     * Gets a snapshot from the current node with relative path filePath.substring(offset).
     *

    /**
     * @return the source file and it's source root
     */
    fun sourceFileAndSourceRootFor(sourceFilePath: String): Pair<File, File> =
        sourceRoots.asSequence()
            .map { it.resolve(sourceFilePath) to it }
            .firstOrNull { it.first.isFile }
            ?: throw IllegalStateException("Source file '$sourceFilePath' not found, searched in source roots:\n  - ${sourceRoots.joinToString("\n  - ")}")