[mlir][index] Mark certain ops as Commutative

[Mogball]

Summary

Mark the relevant index dialect operations as Commutative. Specifically,
this allows the folder to move constant operands to the RHS.

mlir/include/mlir/Dialect/Index/IR/IndexOps.td

class IndexBinaryOp<string mnemonic, list<Trait> traits = []>
   let assemblyFormat = "$lhs `,` $rhs attr-dict";
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AddOp
 //===----------------------------------------------------------------------===//
 
-def Index_AddOp : IndexBinaryOp<"add"> {
+def Index_AddOp : IndexBinaryOp<"add", [Commutative]> {
   let summary = "index addition";
   let description = [{
     The `index.add` operation takes two index values and computes their sum.
 
     Example:
 
     ```mlir
     // c = a + b
let description = [{
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // MulOp
 //===----------------------------------------------------------------------===//
 
-def Index_MulOp : IndexBinaryOp<"mul"> {
+def Index_MulOp : IndexBinaryOp<"mul", [Commutative]> {
   let summary = "index multiplication";
   let description = [{
     The `index.mul` operation takes two index values and computes their product.
 
     Example:
 
     ```mlir
     // c = a * b
let description = [{
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // MaxSOp
 //===----------------------------------------------------------------------===//
 
-def Index_MaxSOp : IndexBinaryOp<"maxs"> {
+def Index_MaxSOp : IndexBinaryOp<"maxs", [Commutative]> {
   let summary = "index signed maximum";
   let description = [{
     The `index.maxs` operation takes two index values and computes their signed
     maximum value. Treats the leading bit as the sign, i.e. `max(-2, 6) = 6`.
 
     Example:
 
     ```mlir
     // c = max(a, b)
     %c = index.maxs %a, %b
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // MaxUOp
 //===----------------------------------------------------------------------===//
 
-def Index_MaxUOp : IndexBinaryOp<"maxu"> {
+def Index_MaxUOp : IndexBinaryOp<"maxu", [Commutative]> {
   let summary = "index unsigned maximum";
   let description = [{
     The `index.maxu` operation takes two index values and computes their
     unsigned maximum value. Treats the leading bit as the most significant, i.e.
     `max(15, 6) = 15` or `max(-2, 6) = -2`.
 
     Example:
 
     ```mlir
     // c = max(a, b)
     %c = index.maxu %a, %b
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // MinSOp
 //===----------------------------------------------------------------------===//
 
-def Index_MinSOp : IndexBinaryOp<"mins"> {
+def Index_MinSOp : IndexBinaryOp<"mins", [Commutative]> {
   let summary = "index signed minimum";
   let description = [{
     The `index.mins` operation takes two index values and computes their signed
     minimum value. Treats the leading bit as the sign, i.e. `min(-2, 6) = -2`.
 
     Example:
 
     ```mlir
     // c = min(a, b)
     %c = index.mins %a, %b
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // MinUOp
 //===----------------------------------------------------------------------===//
 
-def Index_MinUOp : IndexBinaryOp<"minu"> {
+def Index_MinUOp : IndexBinaryOp<"minu", [Commutative]> {
   let summary = "index unsigned minimum";
   let description = [{
     The `index.minu` operation takes two index values and computes their
     unsigned minimum value. Treats the leading bit as the most significant, i.e.
     `min(15, 6) = 6` or `min(-2, 6) = 6`.
 
     Example:
 
let description = [{
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // AndOp
 //===----------------------------------------------------------------------===//
 
-def Index_AndOp : IndexBinaryOp<"and"> {
+def Index_AndOp : IndexBinaryOp<"and", [Commutative]> {
   let summary = "index bitwise and";
   let description = [{
     The `index.and` operation takes two index values and computes their bitwise
     and.
 
     Example:
 
     ```mlir
     // c = a & b
     %c = index.and %a, %b
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // OrOp
 //===----------------------------------------------------------------------===//
 
-def Index_OrOp : IndexBinaryOp<"or"> {
+def Index_OrOp : IndexBinaryOp<"or", [Commutative]> {
   let summary = "index bitwise or";
   let description = [{
     The `index.or` operation takes two index values and computes their bitwise
     or.
 
     Example:
 
     ```mlir
     // c = a | b
     %c = index.or %a, %b
     ```
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // XorOp
 //===----------------------------------------------------------------------===//
 
-def Index_XOrOp : IndexBinaryOp<"xor"> {
+def Index_XOrOp : IndexBinaryOp<"xor", [Commutative]> {
   let summary = "index bitwise xor";
   let description = [{
     The `index.xor` operation takes two index values and computes their bitwise
     xor.
 
     Example:
 
     ```mlir