[[sec:java_library_classes_usage]]
== Using classes instead of jar for compilation

A feature of the `java-library` plugin is that projects which consume the library only require the classes folder for compilation, instead of the full JAR.
This enables lighter inter-project dependencies as resources processing (`processResources` task) and archive construction (`jar` task) are no longer executed when only Java code compilation is performed during development.

        ''                         | null            | ''                                          | null
    }

    def "Can serialize groovy compilation error"() {
        buildFile """
            tasks.register("foo) {
        """

        given:
        def listener = new ProblemProgressListener()

        when:
        withConnection {

        assertToolchainUsages(events1, jdkMetadata1, "JavaLauncher")
        assertToolchainUsages(events2, jdkMetadata2, "JavaLauncher")
    }

    def "emits toolchain usages for compilation that configures #option via fork options"() {
        JvmInstallationMetadata curJdk = AvailableJavaHomes.getJvmInstallationMetadata(Jvm.current())

            return DID_WORK
        }

        then:
        isEmptyDirectory(destinationDir)
    }

    def "files are stashed but not restored on a failure not produced by the compilation"() {
        def destinationDir = spec.getDestinationDir()
        new File(destinationDir, "file.txt").createNewFile()
        def pattern = new PatternSet().include("**/*.txt")

        when:

      BuildSerializedCacheKey(signature_hash, hlo_module);
  *serialized_entry.mutable_hlo_module() = hlo_module;

  // XLA compiler supports exporting executables as an AOT compilation result
  // to avoid running potentially expensive compilation pipeline twice.
  // Check if XLA compiler can export available executable.
  if (auto serialized_executable =
          compiler_client->SerializeExecutable(executable);

        then:
        fails("compileGroovy")
        failure.assertHasCause(
            'Enabling incremental compilation and configuring Java annotation processors for Groovy compilation is not allowed. ' +
                'Disable incremental Groovy compilation or remove the Java annotation processor configuration.')
    }

    def "compileBadCodeWithAnnotationProcessor"() {

	return ofile, output, err
}

// gcBackendConcurrency returns the backend compiler concurrency level for a package compilation.
func gcBackendConcurrency(gcflags []string) int {
	// First, check whether we can use -c at all for this compilation.
	canDashC := concurrentGCBackendCompilationEnabledByDefault

	switch e := os.Getenv("GO19CONCURRENTCOMPILATION"); e {
	case "0":
		canDashC = false

	}

	ast, issues := env.Compile(expressionAccessor.GetExpression())
	if issues != nil {
		return resultError("compilation failed: "+issues.String(), apiservercel.ErrorTypeInvalid)
	}
	found := false
	returnTypes := expressionAccessor.ReturnTypes()
	for _, returnType := range returnTypes {

						if result.Error != nil {
							t.Errorf("Unexpected error: %v", result.Error)
						}
					})
					t.Run("auditAnnotation.valueExpression", func(t *testing.T) {
						// Test audit annotation compilation by casting the result to a string
						options := OptionalVariableDeclarations{HasParams: tc.hasParams, HasAuthorizer: tc.hasAuthorizer}
						result := compiler.CompileCELExpression(&fakeAuditAnnotationCondition{

std::unique_ptr<OperationPass<func::FuncOp>>
CreateTPUColocateCompositeResourceOps();

// Creates a pass that expands outside compilation cluster at the head/tail of
// TPU computation by adding outside compilation attribute to identity/cast ops
// that are only used for host computation.
std::unique_ptr<OperationPass<func::FuncOp>>
CreateTPUHostComputationExpansionPass();