[mlir][NFC] Use explicit `mlir` namespace in generated code

[vinograd47]

Summary

This makes the generated code independent from actual namespace of its users.

[rriddle]

mlir/include/mlir/Interfaces/CopyOpInterface.td

27

::mlir here and below.

[vinograd47]

Used full namespaces name (::mlir) and rebased to latest main branch.

[vinograd47]

@rriddle I've fixed your remark.

[vinograd47]

@rriddle I don't have commit access to the repo. Could you please land the change by yourself?

mlir/include/mlir/IR/OpAsmInterface.td

InterfaceMethod<[{
         ```
 
         This would print the operation as follows:
 
         ```mlir
           %first_result, %middle_results:2, %0 = "my.op" ...
         ```
       }],
-      "void", "getAsmResultNames", (ins "OpAsmSetValueNameFn":$setNameFn)
+      "void", "getAsmResultNames", (ins "::mlir::OpAsmSetValueNameFn":$setNameFn)
     >,
   ];
 }
 
 #endif // MLIR_OPASMINTERFACE

mlir/include/mlir/IR/SymbolInterfaces.td

let description = [{
     interface allows for users of symbols to hook into verification and other
     symbol related utilities that are either costly or otherwise disallowed
     within a traditional operation.
   }];
   let cppNamespace = "::mlir";
 
   let methods = [
     InterfaceMethod<"Verify the symbol uses held by this operation.",
-      "LogicalResult", "verifySymbolUses",
+      "::mlir::LogicalResult", "verifySymbolUses",
       (ins "::mlir::SymbolTableCollection &":$symbolTable)
     >,
   ];
 }
 
 //===----------------------------------------------------------------------===//
 // Symbol Traits
 //===----------------------------------------------------------------------===//
 
 // Op defines a symbol table.
 def SymbolTable : NativeOpTrait<"SymbolTable">;
 
 #endif // MLIR_IR_SYMBOLINTERFACES

mlir/include/mlir/Interfaces/CopyOpInterface.td

def CopyOpInterface : OpInterface<"CopyOpInterface"> {
   let description = [{
     A copy-like operation is one that copies from source value to target value.
   }];
   let cppNamespace = "::mlir";
 
   let methods = [
     InterfaceMethod<
       /*desc=*/"Returns the source value for this copy operation",
-      /*retTy=*/"Value",
+      /*retTy=*/"::mlir::Value",
       /*methodName=*/"getSource"
     >,
     InterfaceMethod<
       /*desc=*/"Returns the target value for this copy operation",
-      /*retTy=*/"Value",
+      /*retTy=*/"::mlir::Value",
       /*methodName=*/"getTarget"
     >
   ];
 }
 
 #endif // MLIR_INTERFACES_COPYOPINTERFACE

mlir/include/mlir/Interfaces/InferTypeOpInterface.td

StaticInterfaceMethod<
       report errors on. The operands and attributes correspond to those with
       which an Operation would be created (e.g., as used in Operation::create)
       and the regions of the op.
 
       Unknown (e.g., unranked) shape and nullptrs for element type and attribute
       may be returned by this function while returning success. E.g., partial
       population of components is not error condition.
       }],
-      /*retTy=*/"LogicalResult",
+      /*retTy=*/"::mlir::LogicalResult",
       /*methodName=*/"inferReturnTypeComponents",
-      /*args=*/(ins "MLIRContext*":$context,
-                    "Optional<Location>":$location,
-                    "ValueRange":$operands,
-                    "DictionaryAttr":$attributes,
-                    "RegionRange":$regions,
-                    "SmallVectorImpl<ShapedTypeComponents>&":
+      /*args=*/(ins "::mlir::MLIRContext*":$context,
+                    "::mlir::Optional<::mlir::Location>":$location,
+                    "::mlir::ValueRange":$operands,
+                    "::mlir::DictionaryAttr":$attributes,
+                    "::mlir::RegionRange":$regions,
+                    "::mlir::SmallVectorImpl<::mlir::ShapedTypeComponents>&":
                       $inferredReturnShapes)
     >,
     InterfaceMethod<
       /*desc=*/[{Reify the shape computation for the operation.
 
       Insert operations using the given OpBuilder that computes the result
       shape.
       }],
-      /*retTy=*/"LogicalResult",
+      /*retTy=*/"::mlir::LogicalResult",
       /*methodName=*/"reifyReturnTypeShapes",
-      /*args=*/(ins "OpBuilder&":$builder,
-                    "SmallVectorImpl<Value>&":$reifiedReturnShapes),
+      /*args=*/(ins "::mlir::OpBuilder&":$builder,
+                    "::mlir::SmallVectorImpl<::mlir::Value>&":$reifiedReturnShapes),
       /*methodBody=*/[{}],
-      /*defaultImplementation=*/[{ return failure(); }]
+      /*defaultImplementation=*/[{ return ::mlir::failure(); }]
     >,
   ];
 }
 
 #endif // MLIR_INFERTYPEOPINTERFACE

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

static void generateNamedOperandGetters(const Operator &op, Class &opClass,
   // method.
   for (int i = 0; i != numOperands; ++i) {
     const auto &operand = op.getOperand(i);
     if (operand.name.empty())
       continue;
 
     if (operand.isOptional()) {
       m = opClass.addMethodAndPrune("::mlir::Value", operand.name);
-      m->body() << "  auto operands = getODSOperands(" << i << ");\n"
-                << "  return operands.empty() ? Value() : *operands.begin();";
+      m->body()
+          << "  auto operands = getODSOperands(" << i << ");\n"
+          << "  return operands.empty() ? ::mlir::Value() : *operands.begin();";
     } else if (operand.isVariadic()) {
       m = opClass.addMethodAndPrune(rangeType, operand.name);
       m->body() << "  return getODSOperands(" << i << ");";
     } else {
       m = opClass.addMethodAndPrune("::mlir::Value", operand.name);
       m->body() << "  return *getODSOperands(" << i << ").begin();";
     }
   }

mlir/tools/mlir-tblgen/RewriterGen.cpp

void PatternEmitter::emitNativeCodeMatch(DagNode tree, StringRef opName,
   if (tree.getNumArgs() > 8) {
     PrintFatalError(loc,
                     "unsupported NativeCodeCall matcher argument numbers: " +
                         Twine(tree.getNumArgs()));
   }
 
   raw_indented_ostream::DelimitedScope scope(os);
 
-  os << "if(!" << opName << ") return failure();\n";
+  os << "if(!" << opName << ") return ::mlir::failure();\n";
   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)) {
       os << "Value " << argName << ";\n";
     } else {
       auto leaf = tree.getArgAsLeaf(i);
       if (leaf.isAttrMatcher() || leaf.isConstantAttr()) {
         os << "Attribute " << argName << ";\n";
void PatternEmitter::emitNativeCodeMatch(DagNode tree, StringRef opName,
   std::string locToUse;
   std::tie(hasLocationDirective, locToUse) = getLocation(tree);
 
   auto fmt = tree.getNativeCodeTemplate();
   auto nativeCodeCall = std::string(tgfmt(
       fmt, &fmtCtx.addSubst("_loc", locToUse), opName, capture[0], capture[1],
       capture[2], capture[3], capture[4], capture[5], capture[6], capture[7]));
 
-  os << "if (failed(" << nativeCodeCall << ")) return failure();\n";
+  os << "if (failed(" << nativeCodeCall << ")) return ::mlir::failure();\n";
 
   for (int i = 0, e = tree.getNumArgs(); i != e; ++i) {
     auto name = tree.getArgName(i);
     if (!name.empty() && name != "_") {
       os << formatv("{0} = {1};\n", name, capture[i]);
     }
   }
 
void PatternEmitter::emitOpMatch(DagNode tree, StringRef opName, int depth) {
 
   std::string castedName = formatv("castedOp{0}", depth);
   os << formatv("auto {0} = ::llvm::dyn_cast_or_null<{2}>({1}); "
                 "(void){0};\n",
                 castedName, opName, op.getQualCppClassName());
   // Skip the operand matching at depth 0 as the pattern rewriter already does.
   if (depth != 0) {
     // Skip if there is no defining operation (e.g., arguments to function).
-    os << formatv("if (!{0}) return failure();\n", castedName);
+    os << formatv("if (!{0}) return ::mlir::failure();\n", castedName);
   }
   if (tree.getNumArgs() != op.getNumArgs()) {
     PrintFatalError(loc, formatv("op '{0}' argument number mismatch: {1} in "
                                  "pattern vs. {2} in definition",
                                  op.getOperationName(), tree.getNumArgs(),
                                  op.getNumArgs()));
   }