source(
            api: ["class Base {}"],
            // Dependant relies on specifics that only exist in the Base within impl
            impl: ["class Base { String reference; }", "class Dependant { String downstream = new Base().reference;}"]
        )

        when:
        run("${language.compileTaskName}")
        impl.recompiledClasses("Base", "Dependant")

        impl.snapshot()

Before Gradle 3.4, projects declared dependencies using the `compile` configuration.
This exposed all of those dependencies to downstream projects. In Gradle 3.4 and above,
you can separate downstream-facing `api` dependencies from internal-only `implementation` details.
Implementation dependencies don't leak into the compile classpath of downstream projects.
When implementation details change, Gradle only recompiles `api` dependencies.

====

        if (getContext().isInScope(owner)) {
            return fallbackValue;
        }
        // It is possible that the downstream chain itself forms a cycle.
        // However, it should be its responsibility to be defined in terms of safe evaluation rather than us intercepting the failure here.
        return evaluate(owner, evaluation);
    }

// Tool which lowers TensorFlow Graphs to StableHLO graphs.
//
// This tool is used by the ODML Programmability effort to consume input TF
// graphs, and lower them to StableHLO graphs for use by downstream tools.
//
// Input: TF Saved Model or TF MLIR files.
// Output: StableHLO MLIR or TFLite Flatbuffer.
//
// Usage:
// 1) convert the input model to StableHLO MLIR
// odml_to_stablehlo /path/to/model -o=model.mlir

	// PreFilter is called at the beginning of the scheduling cycle. All PreFilter
	// plugins must return success or the pod will be rejected. PreFilter could optionally
	// return a PreFilterResult to influence which nodes to evaluate downstream. This is useful
	// for cases where it is possible to determine the subset of nodes to process in O(1) time.

	if !b.proxyView.IsVisible(ep) {
		// Endpoint's network doesn't match the set of networks that the proxy wants to see.
		return false
	}
	// If the downstream service is configured as cluster-local, only include endpoints that
	// reside in the same cluster.
	if b.clusterLocal && (b.clusterID != ep.Locality.ClusterID) {
		return false
	}

	// call from salvaging an invalid IDN, when possible. As a result it may be
	// possible to have two IDNs that appear identical to the user where the
	// ASCII-only version causes an error downstream whereas the non-ASCII
	// version does not.
	// Note that for correct ASCII IDNs ToASCII will only do considerably more
	// work, but it will not cause an allocation.
	if isASCII(v) {
		return v, nil
	}

        lock.lock();
        try {
            previous.assertCanWait();
            if (notReceived.isEmpty()) {
                // Have received all requests so downstream can wait.
                return;
            }
            if (!isAutoRelease()) {

		return
	}
	c.handleServiceCIDREvent(nil, nil)
}

// handleServiceCIDREvent is a helper function to handle Add, Update and Delete
// events on ServiceCIDR objects and call downstream event handlers.
func (c *ServiceCIDRConfig) handleServiceCIDREvent(oldObj, newObj interface{}) {
	var oldServiceCIDR, newServiceCIDR *networkingv1alpha1.ServiceCIDR
	var ok bool

	if oldObj != nil {

                              description: Specifies which protocol to use for tunneling
                                the downstream connection.
                              type: string
                            targetHost:
                              description: Specifies a host to which the downstream
                                connection is tunneled.
                              type: string