// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Build toolchain using Go bootstrap version.
//
// The general strategy is to copy the source files we need into
// a new GOPATH workspace, adjust import paths appropriately,
// invoke the Go bootstrap toolchains go command to build those sources,
// and then copy the binaries back.

package main

import (
	"fmt"
	"os"

But Gradle also allows you to build a custom component (not a Java Library, not a Java Platform, not something supported natively by Gradle).

To create a custom component, you first need to create an empty _adhoc_ component.
At the moment, this is only possible via a plugin because you need to get a handle on the link:{javadocPath}/org/gradle/api/component/SoftwareComponentFactory.html[SoftwareComponentFactory] :

.Injecting the software component factory
====

+
This doesn't mean that you need to verify every artifact at every stage, although doing so can help you quickly identify the source of a problem.
You should focus on the critical output such as final reports and the artifacts that are published or deployed.
+
You will need to factor in some inherent differences in the build output that Gradle produces compared to Maven.

[[using_a_build_service_from_a_task]]
== Using a build service in a task

To use a build service from a task, you need to:

1. Add a property to the task of type `Property<MyServiceType>`.
2. Annotate the property with `@Internal` or `@ServiceReference` (since 8.0).

            throws ArtifactResolutionException {
        fireEvent(ResolutionListener.TEST_ARTIFACT, listeners, node);

        Object key = node.getKey();

        // TODO Does this check need to happen here? Had to add the same call
        // below when we iterate on child nodes -- will that suffice?
        if (managedVersions.containsKey(key)) {
            manageArtifact(node, managedVersions, listeners);

	nodeSelectorsForServices map[host.Name]labels.Instance
	// map of node name and its address+labels - this is the only thing we need from nodes
	// for vm to k8s or cross cluster. When node port services select specific nodes by labels,
	// we run through the label selectors here to pick only ones that we need.
	// Only nodes with ExternalIP addresses are included in this map !
	nodeInfoMap map[string]kubernetesNode

		if n == 0 {
			return t // type is not parameterized
		}

		// TODO(gri) do we need this for Alias types?
		if t.TypeArgs().Len() != n {
			return Typ[Invalid] // error reported elsewhere
		}

		// already instantiated
		// For each (existing) type argument determine if it needs
		// to be substituted; i.e., if it is or contains a type parameter
		// that has a type argument for it.

// loose accuracy, so we need to use this very very carefully.
LogicalResult InsertRequantForReduceMean::matchAndRewrite(
    TFL::MeanOp mean_op, PatternRewriter& rewriter) const {
  auto input = mean_op.getInput();
  auto input_type = mlir::dyn_cast_or_null<ShapedType>(input.getType());
  if (!input_type) return failure();

  // Only need to do this for quantized input.
  auto input_quantized_type =

		if n == 0 {
			return t // type is not parameterized
		}

		// TODO(gri) do we need this for Alias types?
		if t.TypeArgs().Len() != n {
			return Typ[Invalid] // error reported elsewhere
		}

		// already instantiated
		// For each (existing) type argument determine if it needs
		// to be substituted; i.e., if it is or contains a type parameter
		// that has a type argument for it.

			// We need to keep nil checks even if they have no use.
			// Also keep calls and values that have side effects.
			return
		}

		// If the address of the auto reaches a memory or control
		// operation not covered above then we probably need to keep it.
		// We also need to keep autos if they reach Phis (issue #26153).