assignments.forEach { (lhs, rhs, callId, method) ->
                add(
                    when (val additionResult = assignmentResolver.addAssignment(lhs, rhs, method, callId.generationId)) {
                        is AssignmentResolver.AssignmentAdditionResult.AssignmentAdded -> AssignmentTraceElement.RecordedAssignment(additionResult.resolvedLhs, rhs, additionResult.assignmentMethod)

        def lhs = Stub(ClassGenerator.GeneratedConstructor)
        lhs.parameterTypes >> [String]
        def rhs = Stub(ClassGenerator.GeneratedConstructor)
        rhs.parameterTypes >> [String, Number]

        expect:
        comparator.compare(lhs, rhs) == -1
        comparator.compare(rhs, lhs) == 1
    }

    def "constructors with equal parameters are sorted by type names"() {

// A type alias may have fewer type parameters than its RHS.
type RHS[P any, Q ~int] struct {
	p P
	q Q
}

type _[P any] = RHS[P, int]

// Or it may have more type parameters than its RHS.
type _[P any, Q ~int, R comparable] = RHS[P, Q]

// The type parameters of a type alias must implement the
// corresponding type constraints of the type parameters
// on the RHS (if any)
type _[P any, Q ~int] = RHS[P, Q]

	"go/types"
)

// Alias is an alias of types.Alias.
type Alias = types.Alias

// Rhs returns the type on the right-hand side of the alias declaration.
func Rhs(alias *Alias) types.Type {
	if alias, ok := any(alias).(interface{ Rhs() types.Type }); ok {
		return alias.Rhs() // go1.23+
	}

	// go1.22's Alias didn't have the Rhs method,
	// so Unalias is the best we can do.
	return Unalias(alias)
}

	targs   *TypeList      // type arguments, or nil
	fromRHS Type           // RHS of type alias declaration; may be an alias
	actual  Type           // actual (aliased) type; never an alias
}

// NewAlias creates a new Alias type with the given type name and rhs.
// rhs must not be nil.
func NewAlias(obj *TypeName, rhs Type) *Alias {
	alias := (*Checker)(nil).newAlias(obj, rhs)
	// Ensure that alias.actual is set (#65455).
	alias.cleanup()

	targs   *TypeList      // type arguments, or nil
	fromRHS Type           // RHS of type alias declaration; may be an alias
	actual  Type           // actual (aliased) type; never an alias
}

// NewAlias creates a new Alias type with the given type name and rhs.
// rhs must not be nil.
func NewAlias(obj *TypeName, rhs Type) *Alias {
	alias := (*Checker)(nil).newAlias(obj, rhs)
	// Ensure that alias.actual is set (#65455).
	alias.cleanup()

// Fuses TFL_FullyConnectedOp and TFL_TransposeOp Rhs to TFL_BatchMatMulOp
def FuseTransposeFCRhsToBatchMatmul : Pat<
  (TFL_FullyConnectedOp
    2DTensorOf<[F32]>:$lhs,
    (TFL_TransposeOp TensorOf<[F32]>:$rhs, (Arith_ConstantOp:$perm_value $p0)),
    $bias, $TFL_AF_None, $TFL_FCWO_Default,
    $keep_num_dims, $asymmetric_quantize_inputs
    ),
  (TFL_BatchMatMulOp $lhs, $rhs, ConstBoolAttrFalse, ConstBoolAttrFalse,

		if stmt.Tok != token.ASSIGN {
			return // ignore :=
		}
		if len(stmt.Lhs) != len(stmt.Rhs) {
			// If LHS and RHS have different cardinality, they can't be the same.
			return
		}
		for i, lhs := range stmt.Lhs {
			rhs := stmt.Rhs[i]
			if analysisutil.HasSideEffects(pass.TypesInfo, lhs) ||
				analysisutil.HasSideEffects(pass.TypesInfo, rhs) ||
				isMapIndex(pass.TypesInfo, lhs) {
				continue // expressions may not be equal
			}

	if id.Obj == nil {
		return nil
	}
	var rhs ast.Expr
	switch d := id.Obj.Decl.(type) {
	case *ast.AssignStmt:
		for i, x := range d.Lhs {
			if ident, isIdent := x.(*ast.Ident); isIdent && ident.Name == id.Name && i < len(d.Rhs) {
				rhs = d.Rhs[i]
			}
		}
	case *ast.ValueSpec:
		for i, n := range d.Names {
			if n.Name == id.Name && i < len(d.Values) {
				rhs = d.Values[i]
			}
		}
	}

def LiftConv : Pat<
  (StableHLO_ConvolutionOp:$res $lhs, $rhs, $window_strides, $padding,
      $lhs_dilation, $rhs_dilation, $window_reversal, $dimension_numbers,
      $feature_group_count, $batch_group_count, $precision_config),
  (LiftAsTFXlaCallModule<"composite_conv_fn">
    (ArgumentList $lhs, $rhs),
    (ResultList $res),
    (NamedAttributeList