} else {
                        constraint('org.test:moduleB:1.0', 'org.test:moduleB:1.0')
                    }
                }
            }
        }

        where:
        thing                    | notation | declaration
        "dependency constraints" | "string" | "'org.test:moduleB:1.0'"
        "dependency constraints" | "map"    | "group: 'org.test', name: 'moduleB', version: '1.0'"

	sql = "CONSTRAINT ? FOREIGN KEY ? REFERENCES ??"
	if constraint.OnDelete != "" {
		sql += " ON DELETE " + constraint.OnDelete
	}

	if constraint.OnUpdate != "" {
		sql += " ON UPDATE " + constraint.OnUpdate
	}

	foreignKeys := make([]interface{}, 0, len(constraint.ForeignKeys))
	for _, field := range constraint.ForeignKeys {
		foreignKeys = append(foreignKeys, clause.Column{Name: field.DBName})

// constraint. When Certificate.Verify builds a chain which is rooted by cert,
// it will additionally pass the whole chain to constraint to determine its
// validity. If constraint returns a non-nil error, the chain will be discarded.
// constraint may be called concurrently from multiple goroutines.
func (s *CertPool) AddCertWithConstraint(cert *Certificate, constraint func([]*Certificate) error) {
	if cert == nil {

}

// A type parameter may not be embedded in an interface;
// so it can also not be used as a constraint.
func _[A any, B A /* ERROR "cannot use a type parameter as constraint" */]()    {}
func _[A any, B, C A /* ERROR "cannot use a type parameter as constraint" */]() {}

// Error messages refer to the type constraint as it appears in the source.
// (No implicit interface should be exposed.)
func _[T string](x T) T {

     *
     * @param dependencyConstraintNotation dependency constraint to add
     * @return the new dependency constraint
     * @see DependencyConstraintFactory#create(CharSequence) Valid dependency constraint notation for this method
     * @since 8.7
     */
    default DependencyConstraint constraint(CharSequence dependencyConstraintNotation) {

    /**
     * Add a dependency constraint.
     *
     * @param dependencyConstraint dependency constraint to add
     * @since 8.7
     */
    void addConstraint(DependencyConstraint dependencyConstraint);

    /**
     * Add a dependency constraint and configure it.
     *
     * @param dependencyConstraint dependency constraint to add

PACKAGE generics

IMPORTPATH
	testdata/generics

FILENAMES
	testdata/generics.go

FUNCTIONS
	// AnotherFunc has an implicit constraint interface.  Neither type ...
	func AnotherFunc[T ~struct{ f int }](_ struct{ f int })

	// Func has an instantiated constraint. 
	func Func[T Constraint[string, Type[int]]]()

	// Single is not a factory function. 
	func Single[T any]() *T

	// Slice is not a factory function. 

	switch x.(type) {
	case T:
	case T /* ERROR "duplicate case" */ :
	}
}

type constraint interface {
	~int
}

func _[T constraint](x interface{}){
	switch x.(type) {
	case T: // ok to use a type parameter even if type set contains int
	case int:
	}
}

func _(x constraint /* ERROR "contains type constraints" */ ) {
	switch x.(type) { // no need to report another error
	}

            // Add a constraint by String
            implementation(constraint("org:foo:1.0")) // is getImplementation().addConstraint(constraint("org:foo:1.0"))

            // Add a constraint on projects
            implementation(constraint(project(":path"))) // is getImplementation().addConstraint(constraint(project(":path")))

        if (constraints.isEmpty()) {
            return;
        }
        writeArray("dependencyConstraints", () -> {
            for (ModuleMetadataSpec.DependencyConstraint constraint : constraints) {
                writeObject(() -> {
                    write("group", constraint.coordinates.group);