cache.useCache(() -> workingDirCache.put(constraintCacheKey(repository, constraint), selectedVersion));
    }

    private String constraintCacheKey(VersionControlRepositoryConnection repository, VersionConstraint constraint) {
        if (constraint.getBranch() != null) {
            return repository.getUniqueId() + ":b:" + constraint.getBranch();
        }

// than one type will result in a panic.
//
// The constraint argument can be nil, and set later via SetConstraint. If the
// constraint is non-nil, it must be fully defined.
func NewTypeParam(obj *TypeName, constraint Type) *TypeParam {
	return (*Checker)(nil).newTypeParam(obj, constraint)
}

// check may be nil
func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam {

import org.apache.maven.api.annotations.Nullable;

/**
 * Version constraint for dependency. Constraint is either a range ("[1,2)") or recommended version ("1.0").
 *
 * @since 4.0.0
 */
@Experimental
public interface VersionConstraint {
    /**
     * Returns the range of this constraint, or {@code null} if none.
     * <p>

                        constraint("org.springframework:spring-core:${springVersion}")
                        constraint("org.springframework:spring-aop:${springVersion}")
                        constraint("org.springframework:spring-beans:${springVersion}")
                        constraint("org.springframework:spring-context:${springVersion}")
                        constraint("org.springframework:spring-expression:${springVersion}")

        List<ExcludeMetadata> excludes,
        boolean force, boolean changing, boolean transitive, boolean constraint, boolean endorsing,
        @Nullable String reason
    ) {
        this(selector, dependencyConfiguration, artifactNames, excludes, force, changing, transitive, constraint, endorsing, false, reason);
    }

    public LocalComponentDependencyMetadata(
        ComponentSelector selector,

    if (auto result_constraint = results.GetConstraint(op->getResult(0))) {
      // `test.OpA` converts shape constraint to rank constraint.
      if (is_op_a && *result_constraint == ValueConstraint::kShape)
        operands.Insert(op->getOperand(0), ValueConstraint::kRank);

      // `test.OpB` converts value constraint to shape constraint.
      if (*result_constraint == ValueConstraint::kValue)

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