Object dependencyValue = mergeError.getRightValue();
                return "Inconsistency between attributes of a constraint and a dependency, on attribute '" + attribute + "' : dependency requires '" + dependencyValue + "' while constraint required '" + constraintValue + "'";
            });
            return;
        } catch (Exception t) {

  }

  @Override
  protected Map<Class<? extends @NonNull B>, B> delegate() {
    return delegate;
  }

  /**
   * Wraps the {@code setValue} implementation of an {@code Entry} to enforce the class constraint.
   */
  private static <B extends @Nullable Object> Entry<Class<? extends @NonNull B>, B> checkedEntry(
      final Entry<Class<? extends @NonNull B>, B> entry) {

org.checkerframework.framework.util.defaults
org.checkerframework.framework.util.dependenttypes
org.checkerframework.framework.util.element
org.checkerframework.framework.util.typeinference
org.checkerframework.framework.util.typeinference.constraint
org.checkerframework.framework.util.typeinference.solver
org.checkerframework.javacutil
org.checkerframework.javacutil.dist
org.checkerframework.javacutil.trees
org.eclipse.jdt.annotation
org.eclipse.jgit.annotations

     */
    void rejectedByRule(RejectedByRuleVersion id);

    /**
     * Adds a candidate version that matched the provided selector, but was rejected by some constraint.
     */
    void rejectedBySelector(ModuleComponentIdentifier id, VersionSelector versionSelector);

    /**

            // We use component-level precision for dependency constraints since it is hard to implement correctly.
            // To publish a dependency constraint to Maven, we would need to publish a constraint for _each_ coordinate
            // that the component could be resolved to. Resolution results do not support this type of query, so this

	})
}

// Check executes the set of constraints for this selection
// and returns the first error encountered, or nil if all constraints
// have been successfully met. All constraints are removed after them
// check is performed.
func (i *Instance) Check() error {
	// After the check completes, clear out the constraints.
	defer func() {
		i.constraints = i.constraints[:0]
	}()

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

package main

import "fmt"

// Overriding the predeclare "any", so it can be used as a type constraint or a type
// argument
type any interface{}

type Function[a, b any] interface {
	Apply(x a) b
}

type incr struct{ n int }

func (this incr) Apply(x int) int {
	return x + this.n
}

        failure.hasErrorOutput("Dependencies can not be declared against the `compile` configuration.")
    }

    def "fail if a dependency constraint is declared on a configuration which can not be declared against"() {
        given:
        buildFile << """
            dependencies {
                constraints {
                    compile 'module:foo:1.0'
                }
            }
        """

        when:

  "quant::CastQuantizedTypeAttrFromExpressedType($_builder, $0, $1.getType(), " # i # ")">;

class CanUpdateShapeWithAxis<int i> : Constraint<
  CPred<"quant::CastQuantizedTypeAttrFromExpressedType($_builder, $0, $1.getType(), " # i # ")">>;

class UsedBy<string op> : Constraint<
  CPred<"llvm::isa<mlir::TFL::" # op # "Op>(*$0.getUsers().begin())">>;

// When the op is passing-through, the output types of the quantized ops need

            dependency('org:foo:1.0') {
                hasAttribute('custom', 'foo')
            }
            constraint('org:bar:2.0') {
                hasAttribute('nice', true)
            }
            noMoreDependencies()
        }
    }

    def "publishes component with strict version constraints"() {
        settingsFile << "rootProject.name = 'root'"
        buildFile << """