OutputInputFreeScale,
  CustomScale,
};

// Each kernel signature has its own specification for scales.
struct KernelSpec {
  // Scale constraint
  ScaleConstraintType type;

  // Custom function to derive the scales. Only available when the scale
  // constraint is `CustomScale`.
  ScaleFn scale_fn;
};

class KernelSpecs {
 public:
  using Signature = llvm::SmallVector<quant::AnyQuantizedType, 4>;

import (
	"fmt"
	"reflect"
	"strconv"
)

// Simple constraint
type Stringer interface {
	String() string
}

func stringify[T Stringer](s []T) (ret []string) {
	for _, v := range s {
		ret = append(ret, v.String())
	}
	return ret
}

type myint int

func (i myint) String() string {
	return strconv.Itoa(int(i))
}

// Constraint with an embedded interface, but still only requires String()

        file('platform/build.gradle') << """
            plugins {
                id 'java-platform'
            }

            dependencies {
                constraints {
                    // Deliberately unsatisfiable constraint with version range
                    api 'org.apache.commons:commons-lang3:[99,)'
                }
            }
        """

        this.output = output;
    }

    public void printLegend() {
        if (hasConstraints) {
            output.println();
            output.withStyle(Info).text("(c) - A dependency constraint, not a dependency. The dependency affected by the constraint occurs elsewhere in the tree.");
        }
        if (hasCyclicDependencies) {
            output.println();

include "tensorflow/compiler/mlir/tensorflow/ir/tf_generated_ops.td"

// Only handles the case where precision config is default.
def IsPrecisionEmpty :
  Constraint<CPred<"IsPrecisionEmpty($0)">>;

// Creates Einsum Op from XlaDotV2 Op by generating equation.
def CreateEinsumOpFromXlaDotV2Op : NativeCodeCall<
  "CreateEinsumOpFromXlaDotV2Op($_builder, $_loc, $0...)">;

package a

// Type I is the first basic test for the issue, which relates to a type that is recursive
// via a type constraint.  (In this test, I -> IConstraint -> MyStruct -> I.)
type JsonRaw []byte

type MyStruct struct {
	x *I[JsonRaw]
}

type IConstraint interface {
	JsonRaw | MyStruct
}

type I[T IConstraint] struct {

    }

    void constraint(String group, String module, String version, String reason = null, Map<String, ?> attributes = [:]) {
        dependencyConstraints << new DependencyConstraintSpec(group, module, version, null, null, null, reason, attributes)
    }

    void constraint(String notation) {
        def gav = notation.split(':')
        constraint(gav[0], gav[1], gav[2])
    }

type sourceBridge interface {
	listVersions() ([]Version, error)
}

type Constraint interface {
	copyTo(*ConstraintMsg)
}

type ConstraintMsg struct{}

func (m *ConstraintMsg) asUnpairedVersion() UnpairedVersion {
	return nil
}

type Version interface {
	Constraint
}

type UnpairedVersion interface {
	Version
}

var _ Constraint = UnpairedVersion(nil)


// derived test case from issue #21804

        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);
    }