import org.gradle.api.Task;
import org.gradle.api.artifacts.component.BuildIdentifier;
import org.gradle.api.internal.TaskInternal;
import org.gradle.api.specs.Spec;
import org.gradle.composite.internal.IncludedBuildTaskResource;
import org.gradle.composite.internal.TaskIdentifier;
import org.gradle.execution.EntryTaskSelector;
import org.gradle.execution.plan.BuildWorkPlan;
import org.gradle.execution.plan.LocalTaskNode;

      return func_.emitWarning()
             << "Invalid number of arguments in the embedding "
                "matmul composite function";
    }
    if (func_.getFunctionType().getNumResults() != 1) {
      return func_.emitWarning() << "Invalid number of results in the "
                                    "embedding matmul composite function";
    }
    return success();
  }

 private:
  func::FuncOp func_;
};

}

def DecomposeResourceOpsPass : Pass<"tf-device-decompose-resource-ops", "mlir::func::FuncOp"> {
  let summary = "Decompose composite resource variable operations into primitive Read/AssignVariableOp and raw computation.";

  let description = [{
    A pass that decomposes composite resource operations into primitive ones like
    ReadVariableOp, AssignVariableOp and other computations to facilitate

        }
    }

    /**
     * Walks a composite component and its subcomponents to determine coordinates of each variant.
     */
    private static class ComponentWalker {

        interface ComponentVisitor<T> {
            void visitVariant(SoftwareComponentVariant variant, T coordinates);
        }

        /**
         * Visit every variant of a composite component
         */

import org.gradle.internal.declarativedsl.settings.SoftwareTypeFixture

class ProjectReportTaskIntegrationTest extends AbstractIntegrationSpec implements SoftwareTypeFixture {

    def "reports project structure with single composite"() {
        given:
        createDirs("p1", "p2", "p2/p22", "another")
        file("settings.gradle") << """rootProject.name = 'my-root-project'
include('p1')
include('p2')
include('p2:p22')

        // We will run just 1 task
        assertStartEventHas(progressEvents[3], "RUN_WORK", 1)
        assertFailedFinishEventHas(progressEvents[4], "RUN_WORK")
    }

    def "generates build phase events for task composite build for task #taskName and expects #expectedReportedTasksCount run tasks"() {
        setupCompositeBuildProject()

        when:
        def events = ProgressEvents.create()
        withConnection {

	if err != nil {
		t.Fatalf("failed to parse productNonAutoIncrement struct with composite primary key, got error %v", err)
	}

	if productNonAutoIncrement.PrioritizedPrimaryField != nil {
		t.Fatalf("PrioritizedPrimaryField of non autoincrement composite key should be nil")
	}

 * limitations under the License.
 */

package org.gradle.integtests.composite

import org.gradle.integtests.fixtures.build.BuildTestFile
import org.gradle.integtests.fixtures.resolve.ResolveTestFixture
import spock.lang.Issue

/**
 * Tests for resolving dependency cycles in a composite build.
 */
class CompositeBuildDependencyCycleIntegrationTest extends AbstractCompositeBuildIntegrationTest {

            public Substitution withClassifier(String classifier) {
                artifactAction = Actions.composite(artifactAction, new SetClassifier(classifier));
                return this;
            }

            @Override
            public Substitution withoutClassifier() {
                artifactAction = Actions.composite(artifactAction, NoClassifier.INSTANCE);
                return this;
            }

            sampleDirectory = samplesRoot.dir("build-organization/composite-builds/basic")
            description = "Defining and using a composite build"
            category = "Build organization"
        }

        compositeBuildsDeclaredSubstitutions {
            sampleDirectory = samplesRoot.dir("build-organization/composite-builds/declared-substitution")