include "mlir/Dialect/Func/IR/FuncOps.td"
include "tensorflow/compiler/mlir/lite/ir/tfl_ops.td"
include "tensorflow/compiler/mlir/lite/utils/utils.td"
include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.td"

def NotFromDequant : Constraint<CPred<"NotFromDequant($0)">>;

// Fuses TFL_FullyConnectedOp and TFL_TransposeOp Rhs to TFL_BatchMatMulOp when
// it's used by TFL_BatchMatMulOp and "transpose_lhs" is true.
def FuseTransposeFCLhsToBatchMatmul : Pat<

            val selector = readNonNull<ComponentSelector>()
            val constraint = readBoolean()
            LocalComponentDependencyMetadata(
                selector,
                null,
                emptyList(),
                emptyList(),
                false,
                false,
                true,
                constraint,
                false,
                null
            )
        }

    /**
     * Runs the given action and disallows the current thread from attempting to acquire or release any project locks.
     * Applying this constraint means that the thread will not block waiting for a project lock and cause a deadlock.
     * This constraint also means that it does not need to release its project locks when it needs to block while waiting for some operation to complete.
     *

    }
    fontsize="32"
    label = "Application Cluster";
    style=filled
    color=deepskyblue

  }
  
  edge[weight=5]
  appfiles[label="application/*"]
  app -> appfiles [constraint=false]
  appfiles -> appcontents
  appfiles -> appwp
  appfiles -> ig
  appfiles -> nwc
  ztunchart[label="ztunnel",class="helm"]
  ztunnel -> ztunchart -> ztunnelds
  istiodchart[label="istiod",class="helm"]

import static org.gradle.api.internal.artifacts.ivyservice.resolveengine.result.ComponentSelectionReasons.BY_ANCESTOR;
import static org.gradle.api.internal.artifacts.ivyservice.resolveengine.result.ComponentSelectionReasons.CONSTRAINT;
import static org.gradle.api.internal.artifacts.ivyservice.resolveengine.result.ComponentSelectionReasons.FORCED;
import static org.gradle.api.internal.artifacts.ivyservice.resolveengine.result.ComponentSelectionReasons.REQUESTED;

     * Creates a new, empty work graph for this build.
     *
     * Note: Only one thread can be using worker graphs from a build, and this method blocks if some other thread is using a graph for this build.
     * Eventually, this constraint should be removed, so that it is possible to populate and run multiple work graphs concurrently.
     */
    BuildWorkGraph newWorkGraph();

    /**

     *
     * @return the extra info for the module
     */
    ImmutableMap<NamespaceId, String> getExtraAttributes();

    /**
     * Returns this metadata with all dependencies transformed to use the dynamic constraint version.
     */
    IvyModuleResolveMetadata withDynamicConstraintVersions();

    ImmutableList<IvyDependencyDescriptor> getDependencies();

	DropColumn(dst interface{}, field string) error
	AlterColumn(dst interface{}, field string) error
	MigrateColumn(dst interface{}, field *schema.Field, columnType ColumnType) error
	// MigrateColumnUnique migrate column's UNIQUE constraint, it's part of MigrateColumn.
	MigrateColumnUnique(dst interface{}, field *schema.Field, columnType ColumnType) error
	HasColumn(dst interface{}, field string) bool
	RenameColumn(dst interface{}, oldName, field string) error

        then:
        noExceptionThrown()

        when:
        runAndFail("missingPath")

        then:
        failureHasCause("Required keys [path] are missing from map")
    }

    def "can add constraint on root project"() {
        given:
        mavenRepo.module("org", "foo").publish()
        buildFile << """
            configurations {
                dependencyScope("deps")

    /**
     * I think the test above: {@link JavaPlatformEcosystemIntegrationTest#"Configuration.copy() should when configuration contains project dependency constraints"}
     * should be sufficient to cover this case, which seems to apply to any configurations that has a project dependency constraint
     * and is independent of the involvement of the Java Platform plugin.  But I'll leave this test here just in case for now.
     *