if rel.Field.IgnoreMigration {
							continue
						}
						if constraint := rel.ParseConstraint(); constraint != nil &&
							constraint.Schema == stmt.Schema && !queryTx.Migrator().HasConstraint(value, constraint.Name) {
							if err := execTx.Migrator().CreateConstraint(value, constraint.Name); err != nil {
								return err
							}
						}
					}
				}

        ':myPath'   | 'myLib'
        ':myPath'   | null
        ':myPath'   | 'myLib'
    }

    def "serializes version constraint"() {
        given:
        ModuleComponentSelector selection = DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId('group-one', 'name-one'), constraint('req', 'pref', 'strict', ['rej']))

        when:
        ModuleComponentSelector result = serialize(selection, serializer)

                                                                 ComponentSelectionReason reason, ModuleVersionResolveException failure) {
        List<Object> key = asList(requested, from, constraint);
        if (!unresolvedDependencies.containsKey(key)) {
            unresolvedDependencies.put(key, new DefaultUnresolvedDependencyResult(requested, constraint, reason, from, failure));
        }

	{"// +build x y \n ", nil, "not a build constraint"},
	{"// +build x y \nmore", nil, "not a build constraint"},
	{" //+build x y", nil, "not a build constraint"},

	{"//go:build x && y", and(tag("x"), tag("y")), ""},
	{"//go:build x && y\n", and(tag("x"), tag("y")), ""},
	{"//go:build x && y\n ", nil, "not a build constraint"},
	{"//go:build x && y\nmore", nil, "not a build constraint"},

    @Nonnull
    VersionRange parseVersionRange(@Nonnull String range);

    /**
     * Parses the specified version constraint specification, for example "1.0" or "[1.0,2.0)".
     *
     * @param constraint the constraint specification to parse, must not be {@code null}
     * @return the parsed version constraint, never {@code null}
     * @throws VersionParserException if the range specification violates the syntax rules of this scheme
     */

     *
     * <p>
     * Note that no classifier or extension is accepted here.
     * </p>
     *
     * @param dependencyConstraintNotation the dependency constraint notation
     * @return the new dependency constraint
     * @since 8.7
     */
    DependencyConstraint create(CharSequence dependencyConstraintNotation);

    /**
     * Create a {@link DependencyConstraint} from a series of strings.

class FloatValueEquals<string val> : Constraint<CPred<
  "FloatValueEquals($0, " # val # ")">>;

class IsBoolAttrEqual<string true_or_false> : Constraint<CPred<
  "$0.getValue() == "#true_or_false#"">>;

// Flattens a constant tensor to 1D.
def FlattenTo1D : NativeCodeCall<"FlattenTo1D($0)">;

def HasOneUse : Constraint<CPred<"$0.hasOneUse()">>;

def HasSameStaticShapes : Constraint<

    }

    def "doesn't create a copy of an already immutable version constraint"() {
        given:
        def v = new DefaultImmutableVersionConstraint('1.0')

        when:
        def c = DefaultImmutableVersionConstraint.of(v)

        then:
        v.is(c)
    }

    def "can convert mutable version constraint to immutable version constraint"() {
        given:

        <constraint name="dir" within="" contains="" />
      </replaceConfiguration>
      <searchConfiguration name="Use RecursionManager?" text="class $Class$ { &#10;  ThreadLocal&lt;$FieldType$&gt; $FieldName$ = $Init$;&#10;}" recursive="false" caseInsensitive="false" type="JAVA">
        <constraint name="Class" script="&quot;&quot;" within="" contains="" />

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

type _[a, b] /* ERROR "missing type constraint" */ struct{}
type _[a t, b t, c]  /* ERROR "missing type constraint" */ struct{}
type _ struct {
	t [n]byte
	t[a]
	t[a,]
	t[a, b]
	t[a, b,]
}
type _ struct {
	t [n, /* ERROR "unexpected comma; expecting ]" */ ]byte
}