}

  @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) {

// Type() == typ. For *types.TypeParam, *types.Interface, and *types.Union, see
// below.
//
// Structural type restrictions of a type parameter are created via
// non-interface types embedded in its constraint interface (directly, or via a
// chain of interface embeddings). For example, in the declaration type
// T[P interface{~int; m()}] int the structural restriction of the type
// parameter P is ~int.
//

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

        testing {
            suites {
                test {
                    dependencies {
                        // Constrain commons-lang3 and guava
                        implementation constraint('org.apache.commons:commons-lang3:3.12.0')
                        implementation constraint('com.google.guava:guava:33.0.0-jre')
                    }
                }
                integTest(JvmTestSuite) {

     */
    boolean isTransitive();

    /**
     * Is this a strong dependency, does it is merely a constraint on the module to select if brought in
     * by another dependency? ("Optional" dependencies are "constraints")
     */
    boolean isConstraint();

    /**
     * Is this a dependency that "pulls up" strict version constraints from the target node?
     */
    boolean isEndorsingStrictVersions();

    /**

def GetSqueezedPermutation: NativeCodeCall<"GetSqueezedPermutation($0, $1)">;

// Check to see if the tensor dimensions can be Squeezed by eliminating 1s'
def CanSqueezeTensor : Constraint<CPred<
  "GetShape($0).getNumElements() > GetSqueezedShape($0).getNumElements()">>;


// Pattern to convert TFL_TransposeOp with rank>6 to rank<=6 if there are

                        // finishing an execution node. Adding this constraint here means that we can make all build operation queue workers compliant with this
                        // constraint and then gradually roll this out to other worker threads, such as task action workers.
                        //

        components.each {
            writer.println("component:${formatComponent(it)}")
        }
        dependencies.each {
            writer.println("dependency:${it.constraint ? '[constraint]' : ''}[from:${it.from.id}][${it.requested}->${it.selected.id}]")
        }
    }

    protected String formatComponent(ResolvedComponentResult result) {
        String type

	// Use Typ[Invalid] for the type constraint to ensure that a type
	// is present even if the actual constraint has not been assigned
	// yet.
	// TODO(gri) Need to systematically review all uses of type parameter
	//           constraints to make sure we don't rely on them if they
	//           are not properly set yet.
	for _, name := range names {

            }

            // Declare dependency constraints

            dependencies {
                constraints {
                    api("in-block:accessor:1.0")
                    api("in-block:accessor-with-action") {
                        version { strictly("1.0") }
                    }
                }
                (constraints) {
                    "api"("in-block:string-invoke:1.0")