[mlir] Fix DRR either local variable redefinition

[logan]

Summary

Fix either local variable redefinition when both LHS and RHS get into emitOpMatch and then both LHS and RHS are not lifted into static matcher.

[Chia-hungDuan]

Thanks for the fix!

mlir/test/lib/Dialect/Test/TestOps.td

 def : Pat<(TestEitherOpA (either (TestEitherOpB I32:$arg1, $_), I16:$arg2), $x),
           (TestEitherOpB $arg2, $x)>;
 
 def : Pat<(TestEitherOpA (either (TestEitherOpB I32:$arg1, $_),
                                  (TestEitherOpB I16:$arg2, $_)),
                           $x),
           (TestEitherOpB $arg2, $x)>;
 
+def TestEitherHelperOpA : TEST_Op<"either_helper_op_a"> {
+  let arguments = (ins I32:$arg0);
+  let results = (outs I32:$output);
+}
+
+def TestEitherHelperOpB : TEST_Op<"either_helper_op_b"> {
+  let arguments = (ins I32:$arg0);
+  let results = (outs I32:$output);
+}
+
+// This test case ensures `emitOpMatch` doesn't redefine `castedOp{0}` local
+// variables. To trigger this, we must ensure the matcher for
+// `TestEitherHelperOpA` and `TestEitherHelperOpB` are not lifted as a static
+// matcher.
+def : Pat<(TestEitherOpB (either (TestEitherHelperOpA I32:$either_helper_0),
+                                 (TestEitherHelperOpB I32:$either_helper_1))),
+          (TestEitherOpB $either_helper_0, $either_helper_1)>;
+
 //===----------------------------------------------------------------------===//
 // Test Patterns (Location)
 
 // Test that we can specify locations for generated ops.
 def : Pat<(TestLocationSrcOp:$res1
            (TestLocationSrcOp:$res2
             (TestLocationSrcOp:$res3 $input))),
           (TestLocationDstOp

mlir/tools/mlir-tblgen/RewriterGen.cpp

for (int i = 0; i < numEitherArgs; ++i, ++argIndex) {
     if (DagNode argTree = eitherArgTree.getArgAsNestedDag(i)) {
       if (argTree.isEither())
         PrintFatalError(loc, "either cannot be nested");
 
       std::string argName = formatv("local_op_{0}", i).str();
 
       os << formatv("auto {0} = (*v{1}.begin()).getDefiningOp();\n", argName,
                     i);
+
+      // Indent emitMatchCheck and emitMatch because they declare local
+      // variables.
+      os << "{\n";
+      os.indent();
+
       emitMatchCheck(
           opName, /*matchStr=*/argName,
           formatv("\"There's no operation that defines operand {0} of {1}\"",
                   operandIndex++, opName));
       emitMatch(argTree, argName, depth + 1);
+
+      os.unindent() << "}\n";
+
       // `tblgen_ops` is used to collect the matched operations. In either, we
       // need to queue the operation only if the matching success. Thus we emit
       // the code at the end.
       tblgenOps << formatv("tblgen_ops.push_back({0});\n", argName);
     } else if (op.getArg(argIndex).is<NamedTypeConstraint *>()) {
       emitOperandMatch(tree, opName, /*operandName=*/formatv("v{0}", i).str(),
                        /*operandMatcher=*/eitherArgTree.getArgAsLeaf(i),
                        /*argName=*/eitherArgTree.getArgName(i), argIndex);