// Writing build operation traces is broken with Gradle 6.
            buildRunner.withoutBuildOperationTracing()
        }

        buildRunner.build()

        and: 'a build consuming it'
        settingsFile << """
            pluginManagement {
                repositories {
                    maven { url = uri('${pluginRepo.uri}') }
                }
            }
        """

 * of the published library.
 * The following disambiguation rule encodes this assumption for the case where a java library is published
 * with variants using Gradle module metadata. This will allow us to migrate to consuming the new module
 * metadata format by default without breaking a bunch of consumers that depend on this assumption,
 * declaring no preference for a particular variant.
 */
@ServiceScope(Scope.Global.class)

The standalone plugin project and the consuming project can be combined into a single unit, making it straightforward to try out or debug changes without re-publishing the binary file:

----
.
├── include-plugin-build   // <1>
│   ├── build.gradle
│   └── settings.gradle
└── url-verifier-plugin    // <2>
    ├── build.gradle
    ├── settings.gradle
    └── src
----
<1> Consuming project that includes the plugin project

    }

    /**
     * @param platformId The consuming platform.
     */
    public VariantGraphResolveState getDefaultVariant(NodeState from, @Nullable ComponentIdentifier platformId) {

        if (isProjectArtifact()) {
            // Use a node to eagerly calculate the file if this artifact will be used as a dependency of some other node
            // This is to avoid having to lock the producing project when a consuming task in another project runs
            this.resolvedArtifactDependency = new ResolveAction(this);
        } else {
            this.resolvedArtifactDependency = null;
        }

This is where a *build cache* is helpful.

The build cache stores previous build results and restores them when needed.
It prevents the redundant work and cost of executing time-consuming and expensive processes.

When the build cache has been used to repopulate the local directory, the tasks are marked as `FROM-CACHE`:

[source,text]
----
$ ./gradlew compileJava --build-cache

    if (!input_type.hasRank() || !output_type.hasRank()) return failure();

    // The pattern attempts to reduce the rank of the input to BroadcastTo.
    // Thus, we fail to match if the consuming reshape rank is larger.
    ArrayRef<int64_t> input_shape = input_type.getShape();
    if (reshape_shape.size() > input_shape.size()) return failure();

    // Extend the input shape with leading 1s to match the broadcast shape.

include::component_metadata_rules.adoc[leveloffset=+2]
include::resolution_rules.adoc[leveloffset=+2]
include::resolution_strategy_tuning.adoc[leveloffset=+2]

== PRODUCING AND CONSUMING VARIANTS OF LIBRARIES

include::component_capabilities.adoc[leveloffset=+2]
include::feature_variants.adoc[leveloffset=+2]
include::variant_model.adoc[leveloffset=+2]
include::variant_attributes.adoc[leveloffset=+2]

      }
    } else {
      LLVM_DEBUG(llvm::dbgs()
                 << "No supported special parent found, using "
                    "tf_device.cluster_func outputs directly to search for "
                    "consuming AssignVariableOp.\n");
    }
  }
  return llvm::dyn_cast_or_null<TF::AssignVariableOp>(device_return);
}

// TODO(b/184420848): Explore relaxing these constraints.
LogicalResult BuildAliasingInfo(

                    + "reset() called multiple times, or subclass does not call super.reset(). "
                    + "Please see Javadocs of TokenStream class for more information about the correct consuming workflow.");
        }

        @Override
        public void close() {
        }
    };

    protected final Field inputPendingField;

    protected final Field userDictionaryField;