For example, a project applying the <<java_plugin.adoc#java_plugin,Java plugin>> will automatically compile the code in the directory `src/main/java`.
Other language plugins follow the same pattern.
The last portion of the directory path usually indicates the expected language of the source files.

Some compilers are capable of cross-compiling multiple languages in the same source directory.

        when:
        withInstallations(currentJdk, otherJdk).run(":compileScala", "--info")

        then:
        executedAndNotSkipped(":compileScala")
        outputContains("Compiling with Zinc Scala compiler")

        JavaVersion.forClass(scalaClassFile("JavaThing.class").bytes) == targetJdk.javaVersion
        JavaVersion.forClass(scalaClassFile("ScalaHall.class").bytes) == JavaVersion.VERSION_1_8

        when:
        withInstallations(currentJdk, otherJdk).run(":compileGroovy", "--info")

        then:
        executedAndNotSkipped(":compileGroovy")
        outputContains("Compiling with JDK Java compiler API")
        JavaVersion.forClass(groovyClassFile("JavaThing.class").bytes) == targetJdk.javaVersion
        JavaVersion.forClass(groovyClassFile("GroovyBar.class").bytes) == groovyTarget

                genericArgs.add(String.valueOf(spec.getSourceCompatibility().getVersion()));

                CommandLineToolInvocation perFileInvocation =
                    newInvocation("compiling swift file(s)", objectDir, Iterables.concat(genericArgs, outputArgs, importRootArgs), spec.getOperationLogger());
                perFileInvocation.getEnvironment().put("TMPDIR", spec.getTempDir().getAbsolutePath());

    } else {
      VLOG(2) << "Instantly compiling for signature: " << human_signature;
      TF_ASSIGN_OR_RETURN(
          cache_value,
          CompileStrict(signature, compile_options, options, args, function,
                        cache_value, scope, ctx, profiler, cluster_mutex));
    }
  } else if (state == DeviceCompileState::kCompiling) {
    VLOG(2) << "Ongoing asynchronous compilation for signature: "

====

[[sec:scala_incremental_compilation]]
== Incremental compilation

By compiling only classes whose source code has changed since the previous compilation, and classes affected by these changes, incremental compilation can significantly reduce Scala compilation time. It is particularly effective when frequently compiling small code increments, as is often done at development time.

       Flag("tf_xla_use_device_api_for_compile_on_demand",
            &ops_flags->tf_xla_use_device_api.enabled_for_compile_on_demand_,
            "If true, uses Device API (PjRt) for compiling and executing ops "
            "one by one in 'on-demand' mode. Defaults to false."),
       Flag("tf_xla_use_device_api_for_auto_jit",
            &ops_flags->tf_xla_use_device_api.enabled_for_compile_and_run_,

import javax.inject.Inject;

import java.util.function.Supplier;

import static org.gradle.api.internal.lambdas.SerializableLambdas.spec;

/**
 * Extends {@link org.gradle.api.plugins.JavaBasePlugin} to provide support for compiling and documenting Groovy
 * source files.
 *
 * @see <a href="https://docs.gradle.org/current/userguide/groovy_plugin.html">Groovy plugin reference</a>
 */
public abstract class GroovyBasePlugin implements Plugin<Project> {

            }
        '''

        when:
        run 'checkConfigurations'

        then:
        noExceptionThrown()
    }

    @ToBeFixedForConfigurationCache
    def "compiling project variant doesn't imply execution of other variants build tasks"() {
        testDirectory.mkdirs()
        def projectDir = new FileTreeBuilder(testDirectory)
        given:
        projectDir {

The following configurations are used by consumers:

`__variant__SwiftApiElements` (e.g. `debugSwiftApiElements` and `releaseSwiftApiElements`) extends `main__Variant__Implementation`::
Used for compiling against the library.
This configuration is meant to be used by consumers, to retrieve all the elements necessary to compile against the library.