// is called through an exported API call such as AssignableTo. If constraint
// is set, T is a type constraint.
//
// If the provided cause is non-nil, it may be set to an error string
// explaining why V does not implement (or satisfy, for constraints) T.
func (check *Checker) implements(pos syntax.Pos, V, T Type, constraint bool, cause *string) bool {
	Vu := under(V)
	Tu := under(T)

def OneElementAttr
  : ElementsAttrBase<And<[ElementsAttr.predicate, OneElementAttrPred]>,
                     "Scalar ElementsAttr">;

def HasRankedFirstOperand
  : Constraint<CPred<"(*$0.begin()).getType().isa<RankedTensorType>()">>;

def IsShapedTensor
  : Constraint<CPred<"$0.getType().isa<RankedTensorType>()">>;

// This pattern converts TensorFlow axis format to HLO axis format which

        return delegate.parseVersionRange(range);
    }

    @Override
    public VersionConstraint parseVersionConstraint(String constraint) throws InvalidVersionSpecificationException {
        return delegate.parseVersionConstraint(constraint);
    }

        return modelVersionParser.parseVersionRange(range);
    }

    @Override
    public VersionConstraint parseVersionConstraint(String constraint) {
        return modelVersionParser.parseVersionConstraint(constraint);
    }

    @Override
    public boolean isSnapshot(String version) {
        return modelVersionParser.isSnapshot(version);
    }

	}
	var constraint string
	if ttp.Constraint == nil {
		constraint = fmt.Sprintf("%*sConstraint: nil", indent+2, "")
	} else {
		constraint = ttp.Constraint.goString(indent+2, "Constraint: ")
	}
	return fmt.Sprintf("%*s%sTemplateTemplateParam:\n%s\n%s\n%s", indent, "", field,
		ttp.Name.goString(indent+2, "Name: "),
		params.String(),
		constraint)
}

public class ResolutionResultGraphBuilder implements ResolvedComponentVisitor {
    private static final DefaultComponentSelectionDescriptor DEPENDENCY_LOCKING = new DefaultComponentSelectionDescriptor(ComponentSelectionCause.CONSTRAINT, Describables.of("Dependency locking"));
    private final Long2ObjectMap<DefaultResolvedComponentResult> components = new Long2ObjectOpenHashMap<>();

// Package cmp provides types and functions related to comparing
// ordered values.
package cmp

// Ordered is a constraint that permits any ordered type: any type
// that supports the operators < <= >= >.
// If future releases of Go add new ordered types,
// this constraint will be modified to include them.
//
// Note that floating-point types may contain NaN ("not-a-number") values.

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

// Receives a composite DictionaryAttr as an argument and checks if one of the
// its attributes (with the name `attr_name`) is of type `attribute` and has
// the value `val`.
class IsCompositeAttribute<string attr_name, Attr attribute, string val>:
  Constraint<CPred<

					var cause string
					constraint := tpar.iface()
					if m, _ := check.missingMethod(tx, constraint, true, func(x, y Type) bool { return u.unify(x, y, exact) }, &cause); m != nil {
						// TODO(gri) better error message (see TODO above)
						err.addf(pos, "%s (type %s) does not satisfy %s %s", tpar, tx, tpar.Constraint(), cause)
						return nil
					}
				}
			}
		}

// satisfied by SAME or VALID tensorflow padding.
def HasCustomPadding:
  Constraint<CPred<"GetAvgPoolOpPadAttr($_builder, (*$0.begin()).getDefiningOp<mhlo::CompositeOp>()) == $_builder.getStringAttr(\"CUSTOM\")">>;

// Returns true if the provided padding in the composite op can be satisfied 
// by SAME or VALID tensorflow padding.
def HasSameOrValidPadding: Constraint<Neg<HasCustomPadding.predicate>>;

// See the function doc in the header file.