`app` depends on `lib`.
You can build `lib` independent of `app`.
However, to build `app`, Gradle will also build `lib`.

== Step 3. Understand Composite Builds
A composite build is simply a build that includes other builds.

Composite builds allow you to:

- Extract your build logic from your project build (and re-use it among subprojects)

  pass_manager.addPass(mlir::mhlo::createHloLegalizeToStablehloPass());

  // Translate "stablehlo.custom_call @stablehlo.composite" to
  // "stablehlo.composite"
  // TODO: b/330741524 - clean this up when "stablehlo.composite" is emitted
  // directly. Additionally remove the composite to custom once ODML long term
  // solution lands.
  pass_manager.addPass(

Consult how to declare <<sharing_build_logic_between_subprojects.adoc#sec:using_buildsrc, dependencies between subprojects>> to learn more.

=== 2. Composite Builds

Composite Builds, also referred to as _included builds_, are best for sharing logic between builds (_not subprojects_) or isolating access to shared build logic (i.e., convention plugins).

Let's take the previous example.

         */
        @Nullable
        static <T> SideEffect<T> composite(Iterable<SideEffect<T>> sideEffects) {
            return CompositeSideEffect.of(sideEffects);
        }

        /**
         * Creates a new side effect that executes given side effects sequentially.
         */
        @SafeVarargs
        @Nullable
        static <T> SideEffect<T> composite(SideEffect<? super T>... sideEffects) {

	var value int
	_ = M1{true: 1, false: 0}
	_ = M2{nil: 0, &value: 1}

	// composite literal element types may be elided
	type T [2]int
	_ = map[int]T{0: T{3, 4}, 1: {5, 6}}

	// recursively so
	_ = map[int][]T{0: {}, 1: {{}, T{1, 2}}}

	// composite literal key types may be elided
	_ = map[T]int{T{3, 4}: 0, {5, 6}: 1}

	// recursively so

import org.gradle.test.fixtures.file.TestFile
import org.gradle.util.internal.ToBeImplemented
import spock.lang.Issue

/**
 * Tests for generating IDEA metadata for projects within a composite build.
 */
class CompositeBuildIdeaProjectIntegrationTest extends AbstractIntegrationSpec {
    BuildTestFile buildA
    BuildTestFile buildB

    def setup() {
        buildTestFixture.withBuildInSubDir()

std::unique_ptr<OperationPass<func::FuncOp>>
CreateInsertCustomAggregationOpsPass(
    const ::stablehlo::quantization::CalibrationOptions& calib_opts);

// Replaces composite functions with quantized composite functions. After this
// pass runs, functions in the given graph will be replaced with their quantized
// versions. By doing so, the quantization will be applied to the given input.

                }
            }
        """

        expect:
        succeeds(":third-build:sub:doSomething")
    }

    def "handles overlapping names between composite and a subproject within the composite"() {
        setup:
        settingsFile << """
            rootProject.name = 'root-project'
            includeBuild('lib')
        """
        file('lib/settings.gradle') << """

  let summary = "Restores function name from XlaCallModule op.";
}

def QuantizeCompositeFunctionsPass : Pass<"stablehlo-quantize-composite-functions", "ModuleOp"> {
  let summary = "Quantize composite functions with QDQ input / outputs.";
  let options = [
    Option<"enable_per_channel_quantized_weight_",
        "enable-per-channel-quantized-weight",
        "bool", /*default=*/"true",

        where:
        build << GradlePropertiesIncludedBuildFixture.builds()
    }

    @Issue("https://github.com/gradle/gradle/issues/19184")
    def "system properties declared in properties of composite build"() {
        given:
        String systemProp = "fromPropertiesFile"
        def configurationCache = newConfigurationCacheFixture()
        def fixture = spec.createFixtureFor(this, systemProp)