"cmd/compile/internal/ir"
	"cmd/compile/internal/types"
	"cmd/internal/obj"
	"cmd/internal/src"
	"internal/buildcfg"
)

// A Config holds readonly compilation information.
// It is created once, early during compilation,
// and shared across all compilations.
type Config struct {
	arch           string // "amd64", etc.
	PtrSize        int64  // 4 or 8; copy of cmd/internal/sys.Arch.PtrSize

====
<1> Makes compilation depend on the `prepare` task
<2> Detaches `package` from the `ant_build` task and makes it depend on `compileJava`
<3> Detaches `assemble` from the standard Gradle `jar` task and makes it depend on `package` instead

These four steps will successfully replace the old Ant compilation with the Gradle implementation.

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

/**
 * Stores the incremental class dependency analysis after compilation has finished.
 */
class IncrementalResultStoringCompiler<T extends JavaCompileSpec> implements Compiler<T> {

    private final Compiler<T> delegate;
    private final CurrentCompilationAccess classpathSnapshotter;

		if err != nil {
			t.Fatal("dr.Next:", err)
		} else if ent == nil {
			break
		}

		if ent.Tag != TagCompileUnit {
			dr.SkipChildren()
			continue
		}

		// Ignore system compilation units (this happens in
		// the Windows binary). We'll still decode the line
		// table, but won't check it.
		name := ent.Val(AttrName).(string)

            )
        }
        build("noop")
    }

    @Test
    fun `script compilation warnings are output on the console`() {
        val script = withBuildScript("""
            @Deprecated("BECAUSE")
            fun deprecatedFunction() {}
            deprecatedFunction()
        """)

Gradle's dependency management engine is _variant aware_.

In addition to a component, Gradle has the concept of _variants_ of a component.
Variants correspond to the different ways a component can be used, such as for Java compilation or native linking or documentation.
Artifacts are attached to a _variant_ and each variant can have a different set of dependencies.

How does Gradle know which variant to choose when there's more than one?

                    "consumer.plugin.gradle.kts",
                    """
                        plugins { id("producer.plugin") }
                        println(before) // ok
                        println(after) // compilation error
                    """
                )
            }
        }
        withDefaultSettings().appendText(
            """
                include("producer", "consumer")
            """
        )

                throw problemReporter.throwing(problemSpec -> problemSpec
                    .id("groovy-daemon-compiler", "Missing tools.jar", GradleCoreProblemGroup.compilation().groovy())
                    .contextualLabel(contextualMessage)
                    .solution("Check if the installation is not a JRE but a JDK.")
                    .severity(Severity.ERROR)

                       num_tpus_per_host, ", got ", host_tpu_devices.size()));

    tpu_devices.push_back(std::move(host_tpu_devices));
  }

  return tpu_devices;
}

// Find the compilation device from system device with `DEVICE_CPU` as its
// type.
std::string GetTPUCompilationDevice(ParsedDevice system_device) {
  // TODO(b/110910013) GetTPUSystemDevices parses the spec and returns the

                                &compilation_result, custom_legalization_passes)
                .status();
  if (!compilation_status.ok()) {
    LOG(ERROR) << "TF/XLA compilation failed: " << compilation_status;
    return mlir::failure();
  }

  return PrintHloModuleText(compilation_result, output);
}

static mlir::LogicalResult MlirTfGraphToHloTextTranslateFunction(