private VersionRef selectVersionFromRepository(VersionControlRepositoryConnection repository, VersionConstraint constraint) {
        // TODO: match with status, order versions correctly

        if (constraint.getBranch() != null) {
            return repository.getBranch(constraint.getBranch());
        }

        String version = constraint.getRequiredVersion();
        VersionSelector versionSelector = versionSelectorScheme.parseSelector(version);

        _[~t] t
        _[~t|t] t
        _[t|~t] t
        _[~t|~t] t
)

type (
        _[_ t, t /* ERROR missing type constraint */ ] t
        _[_ ~t, t /* ERROR missing type constraint */ ] t
        _[_ t, /* ERROR missing type parameter name */ ~t] t
        _[_ ~t, /* ERROR missing type parameter name */ ~t] t

        _[_ t|t, /* ERROR missing type parameter name */ t|t] t

     * Indicates if the lock state must be strictly validated.
     *
     * If {@code true}, each locked dependency is added as a strict constraint,
     * and the resolution result must exactly match the set of locked dependencies.
     *
     * If {@code false}, each locked dependency is added a regular (lenient) constraint,
     * and the resolution result is not verified against the set of locked dependencies.
     *

                ((MutationValidator) clientConfiguration).validateMutation(MutationValidator.MutationType.DEPENDENCY_CONSTRAINT_ATTRIBUTES)
            );
        }
        return addInternalDependencyConstraint(dependencyConstraint);
    }

    // For internal use only, allows adding a dependency constraint without issuing a deprecation warning

import javax.validation.Constraint;
import javax.validation.Payload;

import org.codelibs.core.lang.StringUtil;

@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = CustomSizeValidator.class)
public @interface CustomSize {

    String message() default "{javax.validation.constraints.Size.message}";

    Class<?>[] groups() default {};

include "tensorflow/compiler/mlir/lite/ir/tfl_ops.td"
include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.td"

def HasSupportedElementType :
  Constraint<CPred<"HasSupportedElementType($0.getDefiningOp())">>;

def IsSupportedElementType :
  Constraint<CPred<"IsSupportedElementType($0.getType().cast<ShapedType>())">>;

def LegalizeVarHandle : Pat<
  (TF_VarHandleOp:$result $container, $shared_name),

                                           boolean constraint,
                                           ResolvedComponentResult selectedComponent,
                                           ResolvedVariantResult selectedVariant,
                                           ResolvedComponentResult from) {
        super(requested, from, constraint);
        this.selectedComponent = selectedComponent;

    public DefaultUnresolvedDependencyResult(ComponentSelector requested, boolean constraint, ComponentSelectionReason reason,
                                             ResolvedComponentResult from, ModuleVersionResolveException failure) {
        super(requested, from, constraint);
        this.reason = reason;
        this.failure = failure;
    }

    @Override

                into "\$buildDir/libs"
            }
        """

        when:
        succeeds 'copyLibs'

        then:
        file('build/libs').assertHasDescendants('constraint-layout-1.0.2.aar', 'constraint-layout-solver-1.0.2.jar')
    }

	// Alternatively, the 2nd type argument can be inferred
	// from the first one through constraint type inference.
	var ss []string
	_ = related2[string]
	related2[string]("foo", ss)

	// A type argument may be inferred from a value argument
	// and then help infer another type argument via constraint
	// type inference. Untyped arguments are always considered
	// last.
	related2(1.2, []float64{})
	related2(1.0, []int{})