*
     * @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")

     * 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();

    /**

        then:
        failure.assertHasCause("Cannot map a dependency of type ")
    }

    @ToBeFixedForConfigurationCache
    def "export fails when external dependency defines both branch and version constraint"() {
        given:
        buildFile << """
            plugins {
                id 'swiftpm-export'
                id 'swift-library'
            }
            dependencies {

    /**
     * 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.
     *

        }

        return preferResults;
    }

    /**
     * Given the result of resolving any 'prefer' constraints, see if these can be used to further refine the results
     *  of resolving the 'require' constraints.
     */

func (check *Checker) declareTypeParam(name *syntax.Name, scopePos syntax.Pos) *TypeParam {
	// Use Typ[Invalid] for the type constraint to ensure that a type
	// is present even if the actual constraint has not been assigned
	// yet.
	// TODO(gri) Need to systematically review all uses of type parameter
	//           constraints to make sure we don't rely on them if they
	//           are not properly set yet.

    "RankedTensorType::get({" # len # "}, $_builder.getIntegerType(32)), $0)";
}

// Constraint that Attr has values [1, X, Y, 1]
def IsIntList1XY1 : AttrConstraint<CPred<"TFIntListIs1XY1($_self)">>;

// Constraint that Attr has values [1, 1, X, Y]
def IsIntList11XY : AttrConstraint<CPred<"TFIntListIs11XY($_self)">>;

// Constraint that values in list attribute are all ones.

package main

import (
	"fmt"
)

// Index returns the index of x in s, or -1 if not found.
func Index[T comparable](s []T, x T) int {
	for i, v := range s {
		// v and x are type T, which has the comparable
		// constraint, so we can use == here.
		if v == x {
			return i
		}
	}
	return -1
}

type obj struct {
	x int
}

type obj2 struct {
	x int8
	y float64
}

type obj3 struct {
	x int64