[mlir] Fully qualify generated C++ code in RewriterGen.cpp

[zero9178]

Summary

By fully qualifying the use of any types and functions from the mlir namespace, users are not required to add using namespace mlir; into the C++ file including the Tablegen output.

mlir/include/mlir/IR/OpBase.td

 
 class NativeCodeCall<string expr, int returns = 1> {
   string expression = expr;
   int numReturns = returns;
 }
 
 class NativeCodeCallVoid<string expr> : NativeCodeCall<expr, 0>;
 
-def ConstantLikeMatcher : NativeCodeCall<"success(matchPattern($_self->getResult(0), m_Constant(&$0)))">;
+def ConstantLikeMatcher : NativeCodeCall<"::mlir::success("
+    "::mlir::matchPattern($_self->getResult(0), ::mlir::m_Constant(&$0)))">;
 
 //===----------------------------------------------------------------------===//
 // Rewrite directives
 //===----------------------------------------------------------------------===//
 
 // Directive used in result pattern to indicate that no new op are generated,
 // so to replace the matched DAG with an existing SSA value.
 def replaceWithValue;

mlir/test/mlir-tblgen/rewriter-static-matcher.td

 // Test static matcher for duplicate DagNode
 // ---
 
 // CHECK: static ::mlir::LogicalResult [[$TYPE_CONSTRAINT:__mlir_ods_local_type_constraint.*]](
 // CHECK-NEXT: {{.*::mlir::Type type}}
 // CHECK: static ::mlir::LogicalResult [[$ATTR_CONSTRAINT:__mlir_ods_local_attr_constraint.*]](
 // CHECK-NEXT: {{.*::mlir::Attribute attr}}
 // CHECK: static ::mlir::LogicalResult [[$DAG_MATCHER:static_dag_matcher.*]](
-// CHECK: if(failed([[$ATTR_CONSTRAINT]]
-// CHECK: if(failed([[$TYPE_CONSTRAINT]]
+// CHECK: if(::mlir::failed([[$ATTR_CONSTRAINT]]
+// CHECK: if(::mlir::failed([[$TYPE_CONSTRAINT]]
 
-// CHECK: if(failed([[$DAG_MATCHER]](rewriter, op1, tblgen_ops
+// CHECK: if(::mlir::failed([[$DAG_MATCHER]](rewriter, op1, tblgen_ops
 def : Pat<(AOp (BOp I32Attr:$attr, I32:$int)),
           (AOp $int)>;
 
-// CHECK: if(failed([[$DAG_MATCHER]](rewriter, op1, tblgen_ops
+// CHECK: if(::mlir::failed([[$DAG_MATCHER]](rewriter, op1, tblgen_ops
 def : Pat<(COp $_, (BOp I32Attr:$attr, I32:$int)),
           (COp $attr, $int)>;

mlir/tools/mlir-tblgen/RewriterGen.cpp

if (tree.isOperation()) {
     return;
   }
 
   PrintFatalError(loc, "encountered non-op, non-NativeCodeCall match.");
 }
 
 void PatternEmitter::emitStaticMatchCall(DagNode tree, StringRef opName) {
   std::string funcName = staticMatcherHelper.getMatcherName(tree);
-  os << formatv("if(failed({0}(rewriter, {1}, tblgen_ops", funcName, opName);
+  os << formatv("if(::mlir::failed({0}(rewriter, {1}, tblgen_ops", funcName,
+                opName);
 
   // TODO(chiahungduan): Add a lookupBoundSymbols() to do the subtree lookup in
   // one pass.
 
   // In general, bound symbol should have the unique name in the pattern but
   // for the operand, binding same symbol to multiple operands imply a
   // constraint at the same time. In this case, we will rename those operands
   // with different names. As a result, we need to collect all the symbolInfos
void PatternEmitter::emitStaticMatchCall(DagNode tree, StringRef opName) {
   os << "))) {\n";
   os.scope().os << "return ::mlir::failure();\n";
   os << "}\n";
 }
 
 void PatternEmitter::emitStaticVerifierCall(StringRef funcName,
                                             StringRef opName, StringRef arg,
                                             StringRef failureStr) {
-  os << formatv("if(failed({0}(rewriter, {1}, {2}, {3}))) {{\n", funcName,
-                opName, arg, failureStr);
+  os << formatv("if(::mlir::failed({0}(rewriter, {1}, {2}, {3}))) {{\n",
+                funcName, opName, arg, failureStr);
   os.scope().os << "return ::mlir::failure();\n";
   os << "}\n";
 }
 
 // Helper function to match patterns.
 void PatternEmitter::emitNativeCodeMatch(DagNode tree, StringRef opName,
                                          int depth) {
   LLVM_DEBUG(llvm::dbgs() << "handle NativeCodeCall matcher pattern: ");
void PatternEmitter::emitNativeCodeMatch(DagNode tree, StringRef opName,
   raw_indented_ostream::DelimitedScope scope(os);
 
   for (int i = 0, e = tree.getNumArgs(); i != e; ++i) {
     std::string argName = formatv("arg{0}_{1}", depth, i);
     if (DagNode argTree = tree.getArgAsNestedDag(i)) {
       if (argTree.isEither())
         PrintFatalError(loc, "NativeCodeCall cannot have `either` operands");
 
-      os << "Value " << argName << ";\n";
+      os << "::mlir::Value " << argName << ";\n";
     } else {
       auto leaf = tree.getArgAsLeaf(i);
       if (leaf.isAttrMatcher() || leaf.isConstantAttr()) {
-        os << "Attribute " << argName << ";\n";
+        os << "::mlir::Attribute " << argName << ";\n";
       } else {
-        os << "Value " << argName << ";\n";
+        os << "::mlir::Value " << argName << ";\n";
       }
     }
 
     capture.push_back(std::move(argName));
   }
 
   auto tail = getTrailingDirectives(tree);
   if (tail.returnType)
     PrintFatalError(loc, "`NativeCodeCall` cannot have return type specifier");
   auto locToUse = getLocation(tail);
 
   auto fmt = tree.getNativeCodeTemplate();
   if (fmt.count("$_self") != 1)
     PrintFatalError(loc, "NativeCodeCall must have $_self as argument for "
                          "passing the defining Operation");
 
   auto nativeCodeCall = std::string(
       tgfmt(fmt, &fmtCtx.addSubst("_loc", locToUse).withSelf(opName.str()),
             static_cast<ArrayRef<std::string>>(capture)));
 
-  emitMatchCheck(opName, formatv("!failed({0})", nativeCodeCall),
-                 formatv("\"{0} return failure\"", nativeCodeCall));
+  emitMatchCheck(opName, formatv("!::mlir::failed({0})", nativeCodeCall),
+                 formatv("\"{0} return ::mlir::failure\"", nativeCodeCall));
 
   for (int i = 0, e = tree.getNumArgs() - tail.numDirectives; i != e; ++i) {
     auto name = tree.getArgName(i);
     if (!name.empty() && name != "_") {
       os << formatv("{0} = {1};\n", name, capture[i]);
     }
   }
 
if (eitherArgTree.getNumArgs() != numEitherArgs)
     PrintFatalError(loc, "`either` only supports grouping two operands");
 
   Operator &op = tree.getDialectOp(opMap);
 
   std::string codeBuffer;
   llvm::raw_string_ostream tblgenOps(codeBuffer);
 
   std::string lambda = formatv("eitherLambda{0}", depth);
-  os << formatv("auto {0} = [&](OperandRange v0, OperandRange v1) {{\n",
-                lambda);
+  os << formatv(
+      "auto {0} = [&](::mlir::OperandRange v0, ::mlir::OperandRange v1) {{\n",
 
   os.indent();
 
   for (int i = 0; i < numEitherArgs; ++i, ++argIndex) {
     if (DagNode argTree = eitherArgTree.getArgAsNestedDag(i)) {
       if (argTree.isEither())
         PrintFatalError(loc, "either cannot be nested");
 
void PatternEmitter::emitEitherOperandMatch(DagNode tree, DagNode eitherArgTree,
   os << "{\n";
   os.indent();
 
   os << formatv("auto eitherOperand0 = {0}.getODSOperands({1});\n", opName,
                 operandIndex - 2);
   os << formatv("auto eitherOperand1 = {0}.getODSOperands({1});\n", opName,
                 operandIndex - 1);
 
-  os << formatv("if(failed({0}(eitherOperand0, eitherOperand1)) && "
-                "failed({0}(eitherOperand1, "
+  os << formatv("if(::mlir::failed({0}(eitherOperand0, eitherOperand1)) && "
+                "::mlir::failed({0}(eitherOperand1, "
                 "eitherOperand0)))\n",
                 lambda);
-  os.indent() << "return failure();\n";
+  os.indent() << "return ::mlir::failure();\n";
 
   os.unindent().unindent() << "}\n";
 }
 
 void PatternEmitter::emitAttributeMatch(DagNode tree, StringRef opName,
                                         int argIndex, int depth) {
   Operator &op = tree.getDialectOp(opMap);
   auto *namedAttr = op.getArg(argIndex).get<NamedAttribute *>();
if (attr.isOptional()) {
       // Avoid dereferencing null attribute. This is using a simple heuristic to
       // avoid common cases of attempting to dereference null attribute. This
       // will return where there is no check if attribute is null unless the
       // attribute's value is not used.
       // FIXME: This could be improved as some null dereferences could slip
       // through.
       if (!StringRef(matcher.getConditionTemplate()).contains("!$_self") &&
           StringRef(matcher.getConditionTemplate()).contains("$_self")) {
-        os << "if (!tblgen_attr) return failure();\n";
+        os << "if (!tblgen_attr) return ::mlir::failure();\n";
       }
     }
     emitStaticVerifierCall(
         verifier, opName, "tblgen_attr",
         formatv("\"op '{0}' attribute '{1}' failed to satisfy constraint: "
                 "'{2}'\"",
                 op.getOperationName(), namedAttr->name,
                 escapeString(matcher.getAsConstraint().getSummary()))