// A better solution for output files would be to record the type of the output file and then using this type here instead of looking at the disk.
        // Though that is more involved and as soon as the file has been produced, the right file type will be detected here as well.
        boolean elementIsFile = !element.isDirectory();
        RelativePath relativePath = RelativePath.parse(elementIsFile, relativePathString);

    swiftCompileVariant[label=<swiftCompile<i>Variant</i> (R)>]
    nativeLinkVariant[label=<nativeLink<i>Variant</i> (R)>]
    nativeRuntimeVariant[label=<nativeRuntime<i>Variant</i> (R)>]
  }

  subgraph right {
    node[style=filled, fillcolor="#ea9999"]
    variantRuntimeElements [weight=1000]

    variantRuntimeElements[label=<<i>variant</i>RuntimeElements (C)>]
  }

  // Ensure the order is preserved

import org.gradle.internal.service.scopes.ServiceScope;

import java.util.Set;

/**
 * Allows registration of software types implemented by plugins.
 */
@ServiceScope(Scope.Build.class) // TODO: Might be too specific a scope, but needed something there
public interface SoftwareTypeRegistry {
    /**
     * Registers a plugin as providing a software type.  Cannot be called again once the list of software types has been

        // are the shebang line and file annotations.
        //
        // If neither of them is there, then we know that the package statement is
        // right at the beginning of the script, if present at all, so we can do a
        // very simple and cheap search for it.
        //
        // Otherwise, we must do a bit more involved searching.

 * <a href="https://docs.gradle.org/current/userguide/configuration_cache.html" target="_top">the configuration cache</a>
 * as values obtained from those sources change.
 * For example, a build might run a different set of tasks depending on whether the {@code CI}
 * environment variable is set or not.
 * </p>
 *
 * <p>
 * To integrate a new type of value source, create an abstract subclass of this interface

        then:
        succeeds("build")
        executedAndNotSkipped ":compileJava", ":build"

        when:
        if (TestPrecondition.satisfied(UnitTestPreconditions.Windows)) {
            //the main src dir might be locked, only delete children
            file("src/main/java").listFiles().each {
                assert !it.deleteDir().exists()
            }
        } else {
            assert !file("src/main/java").deleteDir().exists()

This is called _task configuration avoidance_ and prevents unnecessary work.

Task configuration avoidance is when Gradle avoids configuring `task2` when `task1` was called and `task1` does NOT depend. on `task2`.

[.text-right]

    }

    private static String fileContents(File file) {
        try {
            // TODO this should not be using the default charset because it's not an input and might introduce flakiness
            return FileUtils.readFileToString(file, Charset.defaultCharset());
        } catch (IOException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

            "This behavior has been deprecated. This will fail with an error in Gradle 9.0. " +
            "Resolving relative file paths might yield unexpected results, there is no single clear location it would make sense to resolve against. " +
            "Configure an absolute path to a Java executable instead. " +

<9> Each subproject has its own Gradle build script.

Consult the <<directory_layout.adoc#dir:project_root,Gradle Directories reference>> to learn more.

[.text-right]