Make namespace handling uniform across dialect backends.

[fedelebron]

Summary

Now backends spell out which namespace they want to be in, instead of relying on
clients #including them inside already-opened namespaces. This also means that
cppNamespaces should be fully qualified, and there's no implicit "::mlir::"
prepended to them anymore.

Depends On D86810

[fedelebron]

Rebasing onto head, fixing build errors.

[rriddle]

Thanks.

mlir/include/mlir/Dialect/GPU/GPUBase.td

26

nit: Move this up one line.

mlir/include/mlir/Dialect/GPU/GPUOps.td

207 ↗

(On Diff #288712)

Why this change? Seems unrelated.

273 ↗

(On Diff #288712)

I don't understand why these changes are necessary.

mlir/include/mlir/Dialect/SPIRV/SPIRVTypes.h

337–338

These comments need to be reflowed.

mlir/tools/mlir-tblgen/DialectGen.cpp

157

nit: / -> .

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

2174

This seems like something that could be refactored into a general utility that all of the backends could share.

2180

nit: Drop trivial spaces here and below.

2189

nit: Newline before here.

2191

nit: Drop the llvm::.

[fedelebron]

Resolving review comments.

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

511

Does this use of Twine look safe? I've very little experience with that type.

2174

Where do such utilities go?

2180

Sorry I don't follow. What trivial spaces?

[mehdi_amini]

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

2180

Braces maybe? (on the loop right below)

[rriddle]

Please run clang-format, seems like there are a few issues sprinkled about.

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

2180

Yep, meant braces.

(Sorry, I don't always type what I'm thinking for some reason)

[fedelebron]

Fixing some targets.

[fedelebron]

Lint fix.

[fedelebron]

I think I addressed all comments, PTAL?

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

2189

Not sure where the newline would go, but also not sure I'm reading this UI correctly as to where you wanted a newline. Marking this as tentatively resolved since I moved NamespaceEmitter away from here.

[fedelebron]

Fixing more targets.

[fedelebron]

Anything more to do here or can this be merged?

[fedelebron]

Lint fixes.

flang/include/flang/Optimizer/Dialect/FIROps.h

mlir::ParseResult parseCmpfOp(mlir::OpAsmParser &parser,
                               mlir::OperationState &result);
 mlir::ParseResult parseCmpcOp(mlir::OpAsmParser &parser,
                               mlir::OperationState &result);
 mlir::ParseResult parseSelector(mlir::OpAsmParser &parser,
                                 mlir::OperationState &result,
                                 mlir::OpAsmParser::OperandType &selector,
                                 mlir::Type &type);
 
+} // namespace fir
+
 #define GET_OP_CLASSES
 #include "flang/Optimizer/Dialect/FIROps.h.inc"
 
-} // namespace fir
 
 #endif // OPTIMIZER_DIALECT_FIROPS_H

flang/include/flang/Optimizer/Dialect/FIROps.td

 
 include "mlir/IR/SymbolInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def fir_Dialect : Dialect {
   let name = "fir";
+  let cppNamespace = "::fir";
 }
 
 // Types and predicates
 
 def fir_Type : Type<CPred<"fir::isa_fir_or_std_type($_self)">,
     "FIR dialect type">;
 
 // Fortran intrinsic types

flang/lib/Optimizer/Dialect/FIROps.cpp

fir::GlobalOp fir::createGlobalOp(mlir::Location loc, mlir::ModuleOp module,
                                   StringRef name, mlir::Type type,
                                   llvm::ArrayRef<mlir::NamedAttribute> attrs) {
   if (auto g = module.lookupSymbol<fir::GlobalOp>(name))
     return g;
   mlir::OpBuilder modBuilder(module.getBodyRegion());
   return modBuilder.create<fir::GlobalOp>(loc, name, type, attrs);
 }
 
-namespace fir {
-
 // Tablegen operators
 
 #define GET_OP_CLASSES
 #include "flang/Optimizer/Dialect/FIROps.cpp.inc"
 
-} // namespace fir

mlir/examples/toy/Ch2/include/toy/Dialect.h

 public:
   explicit ToyDialect(mlir::MLIRContext *ctx);
 
   /// Provide a utility accessor to the dialect namespace. This is used by
   /// several utilities for casting between dialects.
   static llvm::StringRef getDialectNamespace() { return "toy"; }
 };
 
+} // end namespace toy
+} // end namespace mlir
+
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
-} // end namespace toy
-} // end namespace mlir
-
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch2/include/toy/Ops.td

 
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
-  let cppNamespace = "toy";
+  let cppNamespace = "::mlir::toy";
 }
 
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
 class Toy_Op<string mnemonic, list<OpTrait> traits = []> :

mlir/examples/toy/Ch3/include/toy/Dialect.h

 public:
   explicit ToyDialect(mlir::MLIRContext *ctx);
 
   /// Provide a utility accessor to the dialect namespace. This is used by
   /// several utilities for casting between dialects.
   static llvm::StringRef getDialectNamespace() { return "toy"; }
 };
 
+} // end namespace toy
+} // end namespace mlir
+
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
-} // end namespace toy
-} // end namespace mlir
-
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch3/include/toy/Ops.td

 #define TOY_OPS
 
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
-  let cppNamespace = "toy";
+  let cppNamespace = "::mlir::toy";
 }
 
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
 class Toy_Op<string mnemonic, list<OpTrait> traits = []> :

mlir/examples/toy/Ch4/include/toy/Dialect.h

 public:
   explicit ToyDialect(mlir::MLIRContext *ctx);
 
   /// Provide a utility accessor to the dialect namespace. This is used by
   /// several utilities for casting between dialects.
   static llvm::StringRef getDialectNamespace() { return "toy"; }
 };
 
+} // end namespace toy
+} // end namespace mlir
+
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
-} // end namespace toy
-} // end namespace mlir
-
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch4/include/toy/Ops.td

 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
-  let cppNamespace = "toy";
+  let cppNamespace = "::mlir::toy";
 }
 
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
 class Toy_Op<string mnemonic, list<OpTrait> traits = []> :

mlir/examples/toy/Ch5/include/toy/Dialect.h

 public:
   explicit ToyDialect(mlir::MLIRContext *ctx);
 
   /// Provide a utility accessor to the dialect namespace. This is used by
   /// several utilities for casting between dialects.
   static llvm::StringRef getDialectNamespace() { return "toy"; }
 };
 
+} // end namespace toy
+} // end namespace mlir
+
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
-} // end namespace toy
-} // end namespace mlir
-
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch5/include/toy/Ops.td

 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
-  let cppNamespace = "toy";
+  let cppNamespace = "::mlir::toy";
 }
 
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
 class Toy_Op<string mnemonic, list<OpTrait> traits = []> :

mlir/examples/toy/Ch6/include/toy/Dialect.h

 public:
   explicit ToyDialect(mlir::MLIRContext *ctx);
 
   /// Provide a utility accessor to the dialect namespace. This is used by
   /// several utilities for casting between dialects.
   static llvm::StringRef getDialectNamespace() { return "toy"; }
 };
 
+} // end namespace toy
+} // end namespace mlir
+
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
-} // end namespace toy
-} // end namespace mlir
-
 #endif // MLIR_TUTORIAL_TOY_DIALECT_H_

mlir/examples/toy/Ch6/include/toy/Ops.td

 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
-  let cppNamespace = "toy";
+  let cppNamespace = "::mlir::toy";
 }
 
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
 class Toy_Op<string mnemonic, list<OpTrait> traits = []> :

mlir/examples/toy/Ch7/include/toy/Dialect.h

public:
   void printType(mlir::Type type,
                  mlir::DialectAsmPrinter &printer) const override;
 
   /// Provide a utility accessor to the dialect namespace. This is used by
   /// several utilities for casting between dialects.
   static llvm::StringRef getDialectNamespace() { return "toy"; }
 };
 
+} // end namespace toy
+} // end namespace mlir
+
 //===----------------------------------------------------------------------===//
 // Toy Operations
 //===----------------------------------------------------------------------===//
 
 /// Include the auto-generated header file containing the declarations of the
 /// toy operations.
 #define GET_OP_CLASSES
 #include "toy/Ops.h.inc"
 
+namespace mlir {
+namespace toy {
+
 //===----------------------------------------------------------------------===//
 // Toy Types
 //===----------------------------------------------------------------------===//
 
 /// This class defines the Toy struct type. It represents a collection of
 /// element types. All derived types in MLIR must inherit from the CRTP class
 /// 'Type::TypeBase'. It takes as template parameters the concrete type
 /// (StructType), the base class to use (Type), and the storage class

mlir/examples/toy/Ch7/include/toy/Ops.td

 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "toy/ShapeInferenceInterface.td"
 
 // Provide a definition of the 'toy' dialect in the ODS framework so that we
 // can define our operations.
 def Toy_Dialect : Dialect {
   let name = "toy";
-  let cppNamespace = "toy";
+  let cppNamespace = "::mlir::toy";
 }
 
 // Base class for toy dialect operations. This operation inherits from the base
 // `Op` class in OpBase.td, and provides:
 //   * The parent dialect of the operation.
 //   * The mnemonic for the operation, or the name without the dialect prefix.
 //   * A list of traits for the operation.
 class Toy_Op<string mnemonic, list<OpTrait> traits = []> :

mlir/include/mlir/Dialect/AVX512/AVX512.td

 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // AVX512 dialect definition
 //===----------------------------------------------------------------------===//
 
 def AVX512_Dialect : Dialect {
   let name = "avx512";
-  let cppNamespace = "avx512";
+  let cppNamespace = "::mlir::avx512";
 }
 
 //===----------------------------------------------------------------------===//
 // AVX512 op definitions
 //===----------------------------------------------------------------------===//
 
 class AVX512_Op<string mnemonic, list<OpTrait> traits = []> :
   Op<AVX512_Dialect, mnemonic, traits> {}

mlir/include/mlir/Dialect/AVX512/AVX512Dialect.h

 
 #ifndef MLIR_DIALECT_AVX512_AVX512DIALECT_H_
 #define MLIR_DIALECT_AVX512_AVX512DIALECT_H_
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
-namespace mlir {
-namespace avx512 {
+#include "mlir/Dialect/AVX512/AVX512Dialect.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/AVX512/AVX512.h.inc"
 
-#include "mlir/Dialect/AVX512/AVX512Dialect.h.inc"
-
-} // namespace avx512
-} // namespace mlir
-
 #endif // MLIR_DIALECT_AVX512_AVX512DIALECT_H_

mlir/include/mlir/Dialect/GPU/GPUBase.td

 include "mlir/IR/OpBase.td"
 
 //===----------------------------------------------------------------------===//
 // GPU Dialect.
 //===----------------------------------------------------------------------===//
 
 def GPU_Dialect : Dialect {
   let name = "gpu";
+  let cppNamespace = "::mlir::gpu";
   let hasOperationAttrVerify = 1;
 
   let extraClassDeclaration = [{
     /// Get the name of the attribute used to annotate the modules that contain
     /// kernel modules.
     static StringRef getContainerModuleAttrName() {
       return "gpu.container_module";
     }
     /// Get the name of the attribute used to annotate external kernel
     /// functions.

mlir/include/mlir/Dialect/GPU/GPUDialect.h

 /// Utility class for the GPU dialect to represent triples of `Value`s
 /// accessible through `.x`, `.y`, and `.z` similarly to CUDA notation.
 struct KernelDim3 {
   Value x;
   Value y;
   Value z;
 };
 
+} // end namespace gpu
+} // end namespace mlir
+
 #include "mlir/Dialect/GPU/GPUOpsDialect.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/GPU/GPUOps.h.inc"
 
-} // end namespace gpu
-} // end namespace mlir
 
 #endif // MLIR_DIALECT_GPU_GPUDIALECT_H

mlir/include/mlir/Dialect/GPU/ParallelLoopMapper.h

 
 namespace mlir {
 
 class AffineMap;
 struct LogicalResult;
 class Operation;
 class Region;
 
+} // namespace mlir
+
 #include "mlir/Dialect/GPU/ParallelLoopMapperAttr.h.inc"
 
+namespace mlir {
 namespace scf {
 class ParallelOp;
 }
 
 namespace gpu {
 
 /// Name of the mapping attribute produced by loop mappers.
 StringRef getMappingAttrName();

mlir/include/mlir/Dialect/LLVMIR/LLVMAVX512.td

 include "mlir/Dialect/LLVMIR/LLVMOpBase.td"
 
 //===----------------------------------------------------------------------===//
 // LLVMAVX512 dialect definition
 //===----------------------------------------------------------------------===//
 
 def LLVMAVX512_Dialect : Dialect {
   let name = "llvm_avx512";
-  let cppNamespace = "LLVM";
+  let cppNamespace = "::mlir::LLVM";
 }
 
 //----------------------------------------------------------------------------//
 // MLIR LLVM AVX512 intrinsics using the MLIR LLVM Dialect type system
 //----------------------------------------------------------------------------//
 
 class LLVMAVX512_IntrOp<string mnemonic, list<OpTrait> traits = []> :
   LLVM_IntrOpBase<LLVMAVX512_Dialect, mnemonic,

mlir/include/mlir/Dialect/LLVMIR/LLVMAVX512Dialect.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_LLVMIR_LLVMAVX512DIALECT_H_
 #define MLIR_DIALECT_LLVMIR_LLVMAVX512DIALECT_H_
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 
-namespace mlir {
-namespace LLVM {
-
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/LLVMAVX512.h.inc"
 
 #include "mlir/Dialect/LLVMIR/LLVMAVX512Dialect.h.inc"
 
-} // namespace LLVM
-} // namespace mlir
-
 #endif // MLIR_DIALECT_LLVMIR_LLVMAVX512DIALECT_H_

mlir/include/mlir/Dialect/LLVMIR/LLVMDialect.h

 namespace LLVM {
 class LLVMDialect;
 
 namespace detail {
 struct LLVMTypeStorage;
 struct LLVMDialectImpl;
 } // namespace detail
 
+} // namespace LLVM
+} // namespace mlir
+
 ///// Ops /////
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/LLVMOps.h.inc"
 
 #include "mlir/Dialect/LLVMIR/LLVMOpsDialect.h.inc"
 
+namespace mlir {
+namespace LLVM {
 /// Create an LLVM global containing the string "value" at the module containing
 /// surrounding the insertion point of builder. Obtain the address of that
 /// global and use it to compute the address of the first character in the
 /// string (operations inserted at the builder insertion point).
 Value createGlobalString(Location loc, OpBuilder &builder, StringRef name,
-                         StringRef value, LLVM::Linkage linkage);
+                         StringRef value, Linkage linkage);
 
 /// LLVM requires some operations to be inside of a Module operation. This
 /// function confirms that the Operation has the desired properties.
 bool satisfiesLLVMModule(Operation *op);
 
 } // end namespace LLVM
 } // end namespace mlir
 
 #endif // MLIR_DIALECT_LLVMIR_LLVMDIALECT_H_

mlir/include/mlir/Dialect/LLVMIR/LLVMOpBase.td

 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // LLVM Dialect.
 //===----------------------------------------------------------------------===//
 
 def LLVM_Dialect : Dialect {
   let name = "llvm";
-  let cppNamespace = "LLVM";
+  let cppNamespace = "::mlir::LLVM";
 
   /// FIXME: at the moment this is a dependency of the translation to LLVM IR,
   /// not really one of this dialect per-se.
   let dependentDialects = ["omp::OpenMPDialect"];
 
   let hasRegionArgAttrVerify = 1;
   let hasOperationAttrVerify = 1;
   let extraClassDeclaration = [{

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

 }
 
 // Compatibility builder that takes an instance of wrapped llvm::VoidType
 // to indicate no result.
 def LLVM_VoidResultTypeOpBuilder : OpBuilder<
   "OpBuilder &builder, OperationState &result, Type resultType, "
   "ValueRange operands, ArrayRef<NamedAttribute> attributes = {}",
   [{
-    auto llvmType = resultType.dyn_cast<LLVM::LLVMType>(); (void)llvmType;
+    auto llvmType = resultType.dyn_cast<LLVMType>(); (void)llvmType;
     assert(llvmType && "result must be an LLVM type");
     assert(llvmType.isVoidTy() &&
            "for zero-result operands, only 'void' is accepted as result type");
     build(builder, result, operands, attributes);
   }]>;
 
 // Base class for LLVM operations with zero results.
 class LLVM_ZeroResultOp<string mnemonic, list<OpTrait> traits = []> :
def LLVM_LoadOp :
   }] # setAlignmentCode # setNonTemporalMetadataCode # [{
     $res = inst;
   }];
   let builders = [OpBuilder<
     "OpBuilder &b, OperationState &result, Value addr, "
     "unsigned alignment = 0, bool isVolatile = false, "
     "bool isNonTemporal = false",
     [{
-      auto type = addr.getType().cast<LLVM::LLVMType>().getPointerElementTy();
+      auto type = addr.getType().cast<LLVMType>().getPointerElementTy();
       build(b, result, type, addr, alignment, isVolatile, isNonTemporal);
     }]>,
     OpBuilder<
     "OpBuilder &b, OperationState &result, Type t, Value addr, "
     "unsigned alignment = 0, bool isVolatile = false, "
     "bool isNonTemporal = false">];
   let parser = [{ return parseLoadOp(parser, result); }];
   let printer = [{ printLoadOp(p, *this); }];
string llvmBuilder = [{
       SmallVector<unsigned, 4> position = extractPosition($mask);
       SmallVector<int, 4> mask(position.begin(), position.end());
       $res = builder.CreateShuffleVector($v1, $v2, mask);
   }];
   let builders = [OpBuilder<
     "OpBuilder &b, OperationState &result, Value v1, Value v2, "
     "ArrayAttr mask, ArrayRef<NamedAttribute> attrs = {}">];
   let verifier = [{
-    auto wrappedVectorType1 = v1().getType().cast<LLVM::LLVMType>();
-    auto wrappedVectorType2 = v2().getType().cast<LLVM::LLVMType>();
+    auto wrappedVectorType1 = v1().getType().cast<LLVMType>();
+    auto wrappedVectorType2 = v2().getType().cast<LLVMType>();
     if (!wrappedVectorType2.isVectorTy())
       return emitOpError("expected LLVM IR Dialect vector type for operand #2");
     if (wrappedVectorType1.getVectorElementType() !=
         wrappedVectorType2.getVectorElementType())
       return emitOpError("expected matching LLVM IR Dialect element types");
     return success();
   }];
   let parser = [{ return parseShuffleVectorOp(parser, result); }];
def LLVM_LLVMFuncOp
   let summary = "LLVM dialect function, has wrapped LLVM IR function type";
 
   let regions = (region AnyRegion:$body);
 
   let skipDefaultBuilders = 1;
 
   let builders = [
     OpBuilder<"OpBuilder &builder, OperationState &result, StringRef name, "
-              "LLVMType type, LLVM::Linkage linkage = LLVM::Linkage::External, "
+              "LLVMType type, Linkage linkage = Linkage::External, "
               "ArrayRef<NamedAttribute> attrs = {}, "
               "ArrayRef<MutableDictionaryAttr> argAttrs = {}">
   ];
 
   let extraClassDeclaration = [{
     // Add an entry block to an empty function, and set up the block arguments
     // to match the signature of the function.
     Block *addEntryBlock();

mlir/include/mlir/Dialect/LLVMIR/NVVMDialect.h

 #ifndef MLIR_DIALECT_LLVMIR_NVVMDIALECT_H_
 #define MLIR_DIALECT_LLVMIR_NVVMDIALECT_H_
 
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
-namespace mlir {
-namespace NVVM {
-
 ///// Ops /////
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/NVVMOps.h.inc"
 
 #include "mlir/Dialect/LLVMIR/NVVMOpsDialect.h.inc"
 
-} // namespace NVVM
-} // namespace mlir
-
 #endif /* MLIR_DIALECT_LLVMIR_NVVMDIALECT_H_ */

mlir/include/mlir/Dialect/LLVMIR/NVVMOps.td

 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // NVVM dialect definitions
 //===----------------------------------------------------------------------===//
 
 def NVVM_Dialect : Dialect {
   let name = "nvvm";
-  let cppNamespace = "NVVM";
+  let cppNamespace = "::mlir::NVVM";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // NVVM op definitions
 //===----------------------------------------------------------------------===//
 
 class NVVM_Op<string mnemonic, list<OpTrait> traits = []> :

mlir/include/mlir/Dialect/LLVMIR/ROCDLDialect.h

 #ifndef MLIR_DIALECT_LLVMIR_ROCDLDIALECT_H_
 #define MLIR_DIALECT_LLVMIR_ROCDLDIALECT_H_
 
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
-namespace mlir {
-namespace ROCDL {
-
 ///// Ops /////
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/ROCDLOps.h.inc"
 
 #include "mlir/Dialect/LLVMIR/ROCDLOpsDialect.h.inc"
 
-} // namespace ROCDL
-} // namespace mlir
-
 #endif /* MLIR_DIALECT_LLVMIR_ROCDLDIALECT_H_ */

mlir/include/mlir/Dialect/LLVMIR/ROCDLOps.td

 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 //===----------------------------------------------------------------------===//
 // ROCDL dialect definitions
 //===----------------------------------------------------------------------===//
 
 def ROCDL_Dialect : Dialect {
   let name = "rocdl";
-  let cppNamespace = "ROCDL";
+  let cppNamespace = "::mlir::ROCDL";
   let dependentDialects = ["LLVM::LLVMDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // ROCDL op definitions
 //===----------------------------------------------------------------------===//
 
 class ROCDL_Op<string mnemonic, list<OpTrait> traits = []> :

mlir/include/mlir/Dialect/Linalg/IR/LinalgBase.td

let description = [{
 
     Additional [Linalg Dialect
     Documentation](https://mlir.llvm.org/docs/Dialects/Linalg) and a
     [Rationale
     Document](https://mlir.llvm.org/docs/Rationale/RationaleLinalgDialect) are
     are also available and should be read first before going in the details of
     the op semantics.
   }];
+  let cppNamespace = "::mlir::linalg";
 }
 
 // Whether a type is a RangeType.
 def LinalgIsRangeTypePred : CPred<"$_self.isa<RangeType>()">;
 def Range : DialectType<Linalg_Dialect, LinalgIsRangeTypePred, "range">;
 
 #endif // LINALG_BASE

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.h

 /// symbol-less identity map of `rank`.
 AffineMap extractOrIdentityMap(Optional<AffineMap> maybeMap, unsigned rank,
                                MLIRContext *context);
 
 /// Return the vector that is the concatenation of `a` and `b`.
 SmallVector<AffineExpr, 4> concat(ArrayRef<AffineExpr> a,
                                   ArrayRef<AffineExpr> b);
 
+} // namespace linalg
+} // namespace mlir
+
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterfaces.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Linalg/IR/LinalgOps.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.h.inc"
 
-} // namespace linalg
-} // namespace mlir
 
 #endif // MLIR_DIALECT_LINALG_LINALGOPS_H_

mlir/include/mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterface.td

 #ifndef LINALG_IR_STRUCTURED_OPS_INTERFACE
 #define LINALG_IR_STRUCTURED_OPS_INTERFACE
 
 include "mlir/Dialect/Linalg/IR/LinalgBase.td"
 
 // The linalg 'LinalgStructuredInterface' provides access to the 'LinalgOp'
 // interface.
 def LinalgStructuredInterface : OpInterface<"LinalgOp"> {
+  let cppNamespace = "::mlir::linalg";
   let methods = [
     //===------------------------------------------------------------------===//
     // Loop types handling.
     //===------------------------------------------------------------------===//
     InterfaceMethod<
       /*desc=*/[{
         Return the number of parallel loops within the current operation.
       }],

mlir/include/mlir/Dialect/Linalg/IR/LinalgTypes.h

 //===- LinalgTypes.h - Linalg Types ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_LINALG_LINALGTYPES_H_
 #define MLIR_DIALECT_LINALG_LINALGTYPES_H_
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/Types.h"
 
+#include "mlir/Dialect/Linalg/IR/LinalgOpsDialect.h.inc"
+
 namespace mlir {
 class MLIRContext;
 
 namespace linalg {
-#include "mlir/Dialect/Linalg/IR/LinalgOpsDialect.h.inc"
 
 /// A RangeType represents a minimal range abstraction (min, max, step).
 /// It is constructed by calling the linalg.range op with three values index of
 /// index type:
 ///
 /// ```mlir
 ///    func @foo(%arg0 : index, %arg1 : index, %arg2 : index) {
 ///      %0 = linalg.range %arg0:%arg1:%arg2 : !linalg.range

mlir/include/mlir/Dialect/OpenACC/OpenACC.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_OPENACC_OPENACC_H_
 #define MLIR_DIALECT_OPENACC_OPENACC_H_
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 
+#include "mlir/Dialect/OpenACC/OpenACCOpsDialect.h.inc"
 #include "mlir/Dialect/OpenACC/OpenACCOpsEnums.h.inc"
 
-namespace mlir {
-namespace acc {
-
 #define GET_OP_CLASSES
 #include "mlir/Dialect/OpenACC/OpenACCOps.h.inc"
 
-#include "mlir/Dialect/OpenACC/OpenACCOpsDialect.h.inc"
+namespace mlir {
+namespace acc {
 
 /// Enumeration used to encode the execution mapping on a loop construct.
 /// They refer directly to the OpenACC 3.0 standard:
 /// 2.9.2. gang
 /// 2.9.3. worker
 /// 2.9.4. vector
 ///
 /// Value can be combined bitwise to reflect the mapping applied to the
 /// construct. e.g. `acc.loop gang vector`, the `gang` and `vector` could be
 /// combined and the final mapping value would be 5 (4 | 1).
 enum OpenACCExecMapping { NONE = 0, VECTOR = 1, WORKER = 2, GANG = 4 };
 
 } // end namespace acc
 } // end namespace mlir
 
 #endif // MLIR_DIALECT_OPENACC_OPENACC_H_

mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td

def OpenACC_Dialect : Dialect {
   let name = "acc";
 
   let summary = "An OpenACC dialect for MLIR.";
 
   let description = [{
     This dialect models the construct from the OpenACC 3.0 directive language.
   }];
 
-  let cppNamespace = "acc";
+  let cppNamespace = "::mlir::acc";
 }
 
 // Base class for OpenACC dialect ops.
 class OpenACC_Op<string mnemonic, list<OpTrait> traits = []> :
   Op<OpenACC_Dialect, mnemonic, traits> {
 
   let printer = [{ return ::print(p, *this); }];
   let verifier = [{ return ::verify(*this); }];

mlir/include/mlir/Dialect/OpenMP/OpenMPDialect.h

 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_DIALECT_OPENMP_OPENMPDIALECT_H_
 #define MLIR_DIALECT_OPENMP_OPENMPDIALECT_H_
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 
+#include "mlir/Dialect/OpenMP/OpenMPOpsDialect.h.inc"
 #include "mlir/Dialect/OpenMP/OpenMPOpsEnums.h.inc"
 
-namespace mlir {
-namespace omp {
-
 #define GET_OP_CLASSES
 #include "mlir/Dialect/OpenMP/OpenMPOps.h.inc"
 
-#include "mlir/Dialect/OpenMP/OpenMPOpsDialect.h.inc"
-} // namespace omp
-} // namespace mlir
-
 #endif // MLIR_DIALECT_OPENMP_OPENMPDIALECT_H_

mlir/include/mlir/Dialect/OpenMP/OpenMPOps.td

 #ifndef OPENMP_OPS
 #define OPENMP_OPS
 
 include "mlir/IR/OpBase.td"
 include "mlir/Dialect/OpenMP/OmpCommon.td"
 
 def OpenMP_Dialect : Dialect {
   let name = "omp";
-  let cppNamespace = "omp";
+  let cppNamespace = "::mlir::omp";
 }
 
 class OpenMP_Op<string mnemonic, list<OpTrait> traits = []> :
       Op<OpenMP_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // 2.6 parallel Construct
 //===----------------------------------------------------------------------===//

mlir/include/mlir/Dialect/PDL/IR/PDL.h

 #define MLIR_DIALECT_PDL_IR_PDL_H_
 
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/SymbolTable.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
-namespace mlir {
-namespace pdl {
 //===----------------------------------------------------------------------===//
 // PDL Dialect
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/PDL/IR/PDLOpsDialect.h.inc"
 
 //===----------------------------------------------------------------------===//
 // PDL Dialect Operations
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/PDL/IR/PDLOps.h.inc"
 
-} // end namespace pdl
-} // end namespace mlir
 
 #endif // MLIR_DIALECT_PDL_IR_PDL_H_

mlir/include/mlir/Dialect/PDL/IR/PDLBase.td

string description = [{
     The above pattern simply replaces an operation with its first operand. Note
     how the input operation is specified structurally, similarly to how it would
     look in memory. This is a simple example and pdl provides support for many
     other features such as applying external constraints or external generator
     methods. These features and more are detailed below.
   }];
 
   let name = "pdl";
-  let cppNamespace = "mlir::pdl";
+  let cppNamespace = "::mlir::pdl";
 }
 
 //===----------------------------------------------------------------------===//
 // PDL Types
 //===----------------------------------------------------------------------===//
 
 class PDL_Handle<string underlying> :
     DialectType<PDL_Dialect, CPred<"$_self.isa<" # underlying # ">()">,

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterp.h

 
 #ifndef MLIR_DIALECT_PDLINTERP_IR_PDLINTERP_H_
 #define MLIR_DIALECT_PDLINTERP_IR_PDLINTERP_H_
 
 #include "mlir/Dialect/PDL/IR/PDL.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
-namespace mlir {
-namespace pdl_interp {
 //===----------------------------------------------------------------------===//
 // PDLInterp Dialect
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/PDLInterp/IR/PDLInterpOpsDialect.h.inc"
 
 //===----------------------------------------------------------------------===//
 // PDLInterp Dialect Operations
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/PDLInterp/IR/PDLInterpOps.h.inc"
 
-} // end namespace pdl_interp
-} // end namespace mlir
-
 #endif // MLIR_DIALECT_PDLINTERP_IR_PDLINTERP_H_

mlir/include/mlir/Dialect/PDLInterp/IR/PDLInterpOps.td

let description = [{
     low-level pattern match and rewrite "primitives", such as navigating the
     IR (Operation::getOperand), creating new operations (OpBuilder::create),
     etc. Many of the operations within this dialect also fuse branching control
     flow with some form of a predicate comparison operation. This type of fusion
     reduces the amount of work that an interpreter must do when executing.
   }];
 
   let name = "pdl_interp";
-  let cppNamespace = "mlir::pdl_interp";
+  let cppNamespace = "::mlir::pdl_interp";
   let dependentDialects = ["pdl::PDLDialect"];
 }
 
 //===----------------------------------------------------------------------===//
 // PDLInterp Operations
 //===----------------------------------------------------------------------===//
 
 // Generic interpreter operation.

mlir/include/mlir/Dialect/Quant/QuantOps.h

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/IR/StandardTypes.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "llvm/Support/MathExtras.h"
 
-namespace mlir {
-namespace quant {
-
 #include "mlir/Dialect/Quant/QuantOpsDialect.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Quant/QuantOps.h.inc"
 
-} // namespace quant
-} // namespace mlir
-
 #endif // MLIR_DIALECT_QUANT_QUANTOPS_H_

mlir/include/mlir/Dialect/Quant/QuantOpsBase.td

 
 #ifndef DIALECT_QUANT_QUANT_OPS_BASE_
 #define DIALECT_QUANT_QUANT_OPS_BASE_
 
 include "mlir/IR/OpBase.td"
 
 def Quantization_Dialect : Dialect {
   let name = "quant";
+  let cppNamespace = "::mlir::quant";
 }
 
 //===----------------------------------------------------------------------===//
 // Quantization type definitions
 //===----------------------------------------------------------------------===//
 
 class quant_TypedPrimitiveOrContainer<Type etype> :
     Type<Or<[etype.predicate,

mlir/include/mlir/Dialect/SCF/SCF.h

 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/OpDefinition.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/LoopLikeInterface.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 namespace mlir {
 namespace scf {
-
 void buildTerminatedBody(OpBuilder &builder, Location loc);
+} // namespace scf
+} // namespace mlir
 
 #include "mlir/Dialect/SCF/SCFOpsDialect.h.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/SCF/SCFOps.h.inc"
 
+namespace mlir {
+namespace scf {
+
 // Insert `loop.yield` at the end of the only region's only block if it
 // does not have a terminator already.  If a new `loop.yield` is inserted,
 // the location is specified by `loc`. If the region is empty, insert a new
 // block first.
 void ensureLoopTerminator(Region &region, Builder &builder, Location loc);
 
 /// Returns the loop parent of an induction variable. If the provided value is
 /// not an induction variable, then return nullptr.

mlir/include/mlir/Dialect/SCF/SCFOps.td

 #define MLIR_DIALECT_SCF_SCFOPS
 
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/LoopLikeInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def SCF_Dialect : Dialect {
   let name = "scf";
-  let cppNamespace = "scf";
+  let cppNamespace = "::mlir::scf";
 }
 
 // Base class for SCF dialect ops.
 class SCF_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<SCF_Dialect, mnemonic, traits> {
   // For every standard op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)
   //   * LogicalResult verify(${C++ class of Op} op)

mlir/include/mlir/Dialect/SPIRV/SPIRVAttributes.h

 
 #ifndef MLIR_DIALECT_SPIRV_SPIRVATTRIBUTES_H
 #define MLIR_DIALECT_SPIRV_SPIRVATTRIBUTES_H
 
 #include "mlir/Dialect/SPIRV/SPIRVTypes.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/Support/LLVM.h"
 
-namespace mlir {
 // Pull in SPIR-V attribute definitions for target and ABI.
 #include "mlir/Dialect/SPIRV/TargetAndABI.h.inc"
 
+namespace mlir {
 namespace spirv {
 enum class Capability : uint32_t;
 enum class Extension;
 enum class Version : uint32_t;
 
 namespace detail {
 struct InterfaceVarABIAttributeStorage;
 struct TargetEnvAttributeStorage;

mlir/include/mlir/Dialect/SPIRV/SPIRVBase.td

let description = [{
     corresponding SPIR-V instructions; but they may deviate representationally
     to utilize MLIR mechanisms if it results in better representation and thus
     benefits transformations. The dialect also aims to maintain straightforward
     serialization into and deserialization from the SPIR-V binary format.
     See https://mlir.llvm.org/docs/Dialects/SPIR-V/ for more details regarding
     high-level designs and implementation structures of the SPIR-V dialect.
   }];
 
-  let cppNamespace = "spirv";
+  let cppNamespace = "::mlir::spirv";
   let hasConstantMaterializer = 1;
   let hasOperationAttrVerify = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
 
   let extraClassDeclaration = [{
     //===------------------------------------------------------------------===//
     // Attribute
StrJoin<!foreach(cap, capabilities,
       "::mlir::spirv::Capability::" # cap.symbol)>.result #
     "}; " #
     // The following manual ArrayRef constructor call is to satisfy GCC 5.
     "ArrayRef<::mlir::spirv::Capability> " #
       "ref(caps, ::llvm::array_lengthof(caps));");
   let instance = "ref";
 }
 
+class SPIRVOpInterface<string name> : OpInterface<name> {
+  let cppNamespace = "::mlir::spirv";
+}
 // TODO: the following interfaces definitions are duplicating with the above.
 // Remove them once we are able to support dialect-specific contents in ODS.
-def QueryMinVersionInterface : OpInterface<"QueryMinVersionInterface"> {
+def QueryMinVersionInterface : SPIRVOpInterface<"QueryMinVersionInterface"> {
   let methods = [InterfaceMethod<"", "::mlir::spirv::Version", "getMinVersion">];
 }
-def QueryMaxVersionInterface : OpInterface<"QueryMaxVersionInterface"> {
+def QueryMaxVersionInterface : SPIRVOpInterface<"QueryMaxVersionInterface"> {
   let methods = [InterfaceMethod<"", "::mlir::spirv::Version", "getMaxVersion">];
 }
-def QueryExtensionInterface : OpInterface<"QueryExtensionInterface"> {
+def QueryExtensionInterface : SPIRVOpInterface<"QueryExtensionInterface"> {
   let methods = [InterfaceMethod<
     "",
     "::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Extension>, 1>",
     "getExtensions">];
 }
-def QueryCapabilityInterface : OpInterface<"QueryCapabilityInterface"> {
+def QueryCapabilityInterface : SPIRVOpInterface<"QueryCapabilityInterface"> {
   let methods = [InterfaceMethod<
     "",
     "::llvm::SmallVector<::llvm::ArrayRef<::mlir::spirv::Capability>, 1>",
     "getCapabilities">];
 }
 
 //===----------------------------------------------------------------------===//
 // SPIR-V target GPU vendor and device definitions

mlir/include/mlir/Dialect/SPIRV/SPIRVDialect.h

 
 #include "mlir/IR/Dialect.h"
 
 namespace mlir {
 namespace spirv {
 
 enum class Decoration : uint32_t;
 
-#include "mlir/Dialect/SPIRV/SPIRVOpsDialect.h.inc"
-
 } // end namespace spirv
 } // end namespace mlir
 
+#include "mlir/Dialect/SPIRV/SPIRVOpsDialect.h.inc"
+
 #endif // MLIR_DIALECT_SPIRV_SPIRVDIALECT_H_

mlir/include/mlir/Dialect/SPIRV/SPIRVOps.h

 class OpBuilder;
 
 namespace spirv {
 class VerCapExtAttr;
 
 // TableGen'erated operation interfaces for querying versions, extensions, and
 // capabilities.
 #include "mlir/Dialect/SPIRV/SPIRVAvailability.h.inc"
+} // namespace spirv
+} // namespace mlir
 
 // TablenGen'erated operation declarations.
 #define GET_OP_CLASSES
 #include "mlir/Dialect/SPIRV/SPIRVOps.h.inc"
 
+namespace mlir {
+namespace spirv {
 // TableGen'erated helper functions.
 //
 // Get the name used in the Op to refer to an enum value of the given
 // `EnumClass`.
 // template <typename EnumClass> StringRef attributeName();
 //
 #include "mlir/Dialect/SPIRV/SPIRVOpUtils.inc"
 

mlir/include/mlir/Dialect/SPIRV/SPIRVTypes.h

public:
 
   static bool classof(Type type);
 
   bool isScalarOrVector();
 
   /// The extension requirements for each type are following the
   /// ((Extension::A OR Extension::B) AND (Extension::C OR Extension::D))
   /// convention.
-  using ExtensionArrayRefVector = SmallVectorImpl<ArrayRef<spirv::Extension>>;
+  using ExtensionArrayRefVector = SmallVectorImpl<ArrayRef<Extension>>;
 
   /// Appends to `extensions` the extensions needed for this type to appear in
   /// the given `storage` class. This method does not guarantee the uniqueness
   /// of extensions; the same extension may be appended multiple times.
   void getExtensions(ExtensionArrayRefVector &extensions,
-                     Optional<spirv::StorageClass> storage = llvm::None);
+                     Optional<StorageClass> storage = llvm::None);
 
   /// The capability requirements for each type are following the
   /// ((Capability::A OR Extension::B) AND (Capability::C OR Capability::D))
   /// convention.
-  using CapabilityArrayRefVector = SmallVectorImpl<ArrayRef<spirv::Capability>>;
+  using CapabilityArrayRefVector = SmallVectorImpl<ArrayRef<Capability>>;
 
   /// Appends to `capabilities` the capabilities needed for this type to appear
   /// in the given `storage` class. This method does not guarantee the
   /// uniqueness of capabilities; the same capability may be appended multiple
   /// times.
   void getCapabilities(CapabilityArrayRefVector &capabilities,
-                       Optional<spirv::StorageClass> storage = llvm::None);
+                       Optional<StorageClass> storage = llvm::None);
 
   /// Returns the size in bytes for each type. If no size can be calculated,
   /// returns `llvm::None`. Note that if the type has explicit layout, it is
   /// also taken into account in calculation.
   Optional<int64_t> getSizeInBytes();
 };
 
 // SPIR-V scalar type: bool type, integer type, floating point type.
 class ScalarType : public SPIRVType {
 public:
   using SPIRVType::SPIRVType;
 
   static bool classof(Type type);
 
   /// Returns true if the given integer type is valid for the SPIR-V dialect.
   static bool isValid(FloatType);
   /// Returns true if the given float type is valid for the SPIR-V dialect.
   static bool isValid(IntegerType);
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<spirv::StorageClass> storage = llvm::None);
+                     Optional<StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<spirv::StorageClass> storage = llvm::None);
+                       Optional<StorageClass> storage = llvm::None);
 
   Optional<int64_t> getSizeInBytes();
 };
 
 // SPIR-V composite type: VectorType, SPIR-V ArrayType, or SPIR-V StructType.
 class CompositeType : public SPIRVType {
 public:
   using SPIRVType::SPIRVType;
public:
 
   Type getElementType(unsigned) const;
 
   /// Return true if the number of elements is known at compile time and is not
   /// implementation dependent.
   bool hasCompileTimeKnownNumElements() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<spirv::StorageClass> storage = llvm::None);
+                     Optional<StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<spirv::StorageClass> storage = llvm::None);
+                       Optional<StorageClass> storage = llvm::None);
 
   Optional<int64_t> getSizeInBytes();
 };
 
 // SPIR-V array type
 class ArrayType : public Type::TypeBase<ArrayType, CompositeType,
                                         detail::ArrayTypeStorage> {
 public:
public:
 
   Type getElementType() const;
 
   /// Returns the array stride in bytes. 0 means no stride decorated on this
   /// type.
   unsigned getArrayStride() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<spirv::StorageClass> storage = llvm::None);
+                     Optional<StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<spirv::StorageClass> storage = llvm::None);
+                       Optional<StorageClass> storage = llvm::None);
 
   /// Returns the array size in bytes. Since array type may have an explicit
   /// stride declaration (in bytes), we also include it in the calculation.
   Optional<int64_t> getSizeInBytes();
 };
 
 // SPIR-V image type
 class ImageType
public:
   ImageDepthInfo getDepthInfo() const;
   ImageArrayedInfo getArrayedInfo() const;
   ImageSamplingInfo getSamplingInfo() const;
   ImageSamplerUseInfo getSamplerUseInfo() const;
   ImageFormat getImageFormat() const;
   // TODO: Add support for Access qualifier
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<spirv::StorageClass> storage = llvm::None);
+                     Optional<StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<spirv::StorageClass> storage = llvm::None);
+                       Optional<StorageClass> storage = llvm::None);
 };
 
 // SPIR-V pointer type
 class PointerType : public Type::TypeBase<PointerType, SPIRVType,
                                           detail::PointerTypeStorage> {
 public:
   using Base::Base;
 
   static PointerType get(Type pointeeType, StorageClass storageClass);
 
   Type getPointeeType() const;
 
   StorageClass getStorageClass() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<spirv::StorageClass> storage = llvm::None);
+                     Optional<StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<spirv::StorageClass> storage = llvm::None);
+                       Optional<StorageClass> storage = llvm::None);
 };
 
 // SPIR-V run-time array type
 class RuntimeArrayType
     : public Type::TypeBase<RuntimeArrayType, SPIRVType,
                             detail::RuntimeArrayTypeStorage> {
 public:
   using Base::Base;
 
   static RuntimeArrayType get(Type elementType);
 
   /// Returns a runtime array type with the given stride in bytes.
   static RuntimeArrayType get(Type elementType, unsigned stride);
 
   Type getElementType() const;
 
   /// Returns the array stride in bytes. 0 means no stride decorated on this
   /// type.
   unsigned getArrayStride() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<spirv::StorageClass> storage = llvm::None);
+                     Optional<StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<spirv::StorageClass> storage = llvm::None);
+                       Optional<StorageClass> storage = llvm::None);
 };
 
 // SPIR-V struct type
 class StructType : public Type::TypeBase<StructType, CompositeType,
                                          detail::StructTypeStorage> {
 public:
   using Base::Base;
 
private:
     friend RangeBaseT;
   };
 
   ElementTypeRange getElementTypes() const;
 
   bool hasOffset() const;
 
   uint64_t getMemberOffset(unsigned) const;
 
-  // Returns in `memberDecorations` the spirv::Decorations (apart from
-  // Offset) associated with all members of the StructType.
+  // Returns in `memberDecorations` the Decorations (apart from Offset)
+  // associated with all members of the StructType.
   void getMemberDecorations(SmallVectorImpl<StructType::MemberDecorationInfo>
                                 &memberDecorations) const;
 
-  // Returns in `decorationsInfo` all the spirv::Decorations (apart from
-  // Offset) associated with the `i`-th member of the StructType.
+  // Returns in `decorationsInfo` all the Decorations (apart from Offset)
+  // associated with the `i`-th member of the StructType.
   void getMemberDecorations(unsigned i,
                             SmallVectorImpl<StructType::MemberDecorationInfo>
                                 &decorationsInfo) const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<spirv::StorageClass> storage = llvm::None);
+                     Optional<StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<spirv::StorageClass> storage = llvm::None);
+                       Optional<StorageClass> storage = llvm::None);
 };
 
 llvm::hash_code
 hash_value(const StructType::MemberDecorationInfo &memberDecorationInfo);
 
 // SPIR-V cooperative matrix type
 class CooperativeMatrixNVType
     : public Type::TypeBase<CooperativeMatrixNVType, CompositeType,
                             detail::CooperativeMatrixTypeStorage> {
 public:
   using Base::Base;
 
-  static CooperativeMatrixNVType get(Type elementType, spirv::Scope scope,
+  static CooperativeMatrixNVType get(Type elementType, Scope scope,
                                      unsigned rows, unsigned columns);
   Type getElementType() const;
 
   /// Return the scope of the cooperative matrix.
-  spirv::Scope getScope() const;
+  Scope getScope() const;
   /// return the number of rows of the matrix.
   unsigned getRows() const;
   /// return the number of columns of the matrix.
   unsigned getColumns() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<spirv::StorageClass> storage = llvm::None);
+                     Optional<StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<spirv::StorageClass> storage = llvm::None);
+                       Optional<StorageClass> storage = llvm::None);
 };
 
 // SPIR-V matrix type
 class MatrixType : public Type::TypeBase<MatrixType, CompositeType,
                                          detail::MatrixTypeStorage> {
 public:
   using Base::Base;
 
public:
 
   /// Returns total number of elements (rows*columns).
   unsigned getNumElements() const;
 
   /// Returns the elements' type (i.e, single element type).
   Type getElementType() const;
 
   void getExtensions(SPIRVType::ExtensionArrayRefVector &extensions,
-                     Optional<spirv::StorageClass> storage = llvm::None);
+                     Optional<StorageClass> storage = llvm::None);
   void getCapabilities(SPIRVType::CapabilityArrayRefVector &capabilities,
-                       Optional<spirv::StorageClass> storage = llvm::None);
+                       Optional<StorageClass> storage = llvm::None);
 };
 
 } // end namespace spirv
 } // end namespace mlir
 
 #endif // MLIR_DIALECT_SPIRV_SPIRVTYPES_H_

mlir/include/mlir/Dialect/Shape/IR/Shape.h

 
 /// The Witness represents a runtime constraint, to be used as shape related
 /// preconditions on code execution.
 class WitnessType : public Type::TypeBase<WitnessType, Type, TypeStorage> {
 public:
   using Base::Base;
 };
 
+} // namespace shape
+} // namespace mlir
+
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Shape/IR/ShapeOps.h.inc"
 
 #include "mlir/Dialect/Shape/IR/ShapeOpsDialect.h.inc"
 
-} // namespace shape
-} // namespace mlir
-
 #endif // MLIR_SHAPE_IR_SHAPE_H

mlir/include/mlir/Dialect/Shape/IR/ShapeBase.td

let description = [{
     Note: Unless explicitly stated, all functions that return a shape and take
     shapes as input, return the invalid shape if one of its operands is an
     invalid shape. This avoids flagging multiple errors for one verification
     failure. The dialect itself does not specify how errors should be combined
     (there are multiple different options, from always choosing first operand,
     concatting etc. on how to combine them).
   }];
 
-  let cppNamespace = "shape";
+  let cppNamespace = "::mlir::shape";
 
   let hasConstantMaterializer = 1;
 }
 
 def Shape_ComponentType : DialectType<ShapeDialect,
     CPred<"$_self.isa<::mlir::shape::ComponentType>()">, "component type">,
     BuildableType<"$_builder.getType<::mlir::shape::ComponentType>()"> {
   let typeDescription = [{

mlir/include/mlir/Dialect/Vector/VectorOps.h

 
 namespace impl {
 /// Build the default minor identity map suitable for a vector transfer. This
 /// also handles the case memref<... x vector<...>> -> vector<...> in which the
 /// rank of the identity map must take the vector element type into account.
 AffineMap getTransferMinorIdentityMap(MemRefType memRefType,
                                       VectorType vectorType);
 } // namespace impl
+} // end namespace vector
+} // end namespace mlir
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Vector/VectorOps.h.inc"
-
 #include "mlir/Dialect/Vector/VectorOpsDialect.h.inc"
 
-} // end namespace vector
-} // end namespace mlir
-
 #endif // MLIR_DIALECT_VECTOR_VECTOROPS_H

mlir/include/mlir/Dialect/Vector/VectorOps.td

 #define VECTOR_OPS
 
 include "mlir/Dialect/Affine/IR/AffineOpsBase.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/VectorInterfaces.td"
 
 def Vector_Dialect : Dialect {
   let name = "vector";
-  let cppNamespace = "vector";
+  let cppNamespace = "::mlir::vector";
   let hasConstantMaterializer = 1;
 }
 
 // Base class for Vector dialect ops.
 class Vector_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<Vector_Dialect, mnemonic, traits> {
   // For every vector op, there needs to be a:
   //   * void print(OpAsmPrinter &p, ${C++ class of Op} op)

mlir/include/mlir/IR/OpBase.td

 
 // OpTrait represents a trait regarding an op.
 class OpTrait;
 
 // NativeOpTrait corresponds to the MLIR C++ OpTrait mechanism. The
 // purpose to wrap around C++ symbol string with this class is to make
 // traits specified for ops in TableGen less alien and more integrated.
 class NativeOpTrait<string prop> : OpTrait {
-  string trait = "OpTrait::" # prop;
+  string trait = "::mlir::OpTrait::" # prop;
 }
 
 // ParamNativeOpTrait corresponds to the template-parameterized traits in the
 // C++ implementation.  MLIR uses nested class templates to implement such
 // traits leading to constructs of the form "TraitName<Parameters>::Impl". Use
 // the value in `prop` as the trait name and the value in `params` as
 // parameters to construct the native trait class name.
 class ParamNativeOpTrait<string prop, string params>
     : NativeOpTrait<prop # "<" # params # ">::Impl">;
 
 // GenInternalOpTrait is an op trait that does not have direct C++ mapping but
 // affects op definition generator internals, like how op builders and
 // operand/attribute/result getters are generated.
 class GenInternalOpTrait<string prop> : OpTrait {
-  string trait = "OpTrait::" # prop;
+  string trait = "::mlir::OpTrait::" # prop;
 }
 
 // PredOpTrait is an op trait implemented by way of a predicate on the op.
 class PredOpTrait<string descr, Pred pred> : OpTrait {
   string description = descr;
   Pred predicate = pred;
 }
 

mlir/include/mlir/TableGen/Operator.h

public:
 
   // Returns the dialect of the op.
   const Dialect &getDialect() const { return dialect; }
 
   // Prints the contents in this operator to the given `os`. This is used for
   // debugging purposes.
   void print(llvm::raw_ostream &os) const;
 
+  // A helper RAII class to emit nested namespaces for this op.
+  class NamespaceEmitter {
+  public:
+    NamespaceEmitter(raw_ostream &os, Operator &op);
+    ~NamespaceEmitter();
+
+  private:
+    raw_ostream &os;
+    SmallVector<StringRef, 2> namespaces;
+  };
+
   // Return whether all the result types are known.
   bool allResultTypesKnown() const { return allResultsHaveKnownTypes; };
 
   // Pair representing either a index to an argument or a type constraint. Only
   // one of these entries should have the non-default value.
   struct ArgOrType {
     explicit ArgOrType(int index) : index(index), constraint(None) {}
     explicit ArgOrType(TypeConstraint constraint)

mlir/lib/Dialect/AVX512/IR/AVX512Dialect.cpp

 
 void avx512::AVX512Dialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/AVX512/AVX512.cpp.inc"
       >();
 }
 
-namespace mlir {
-namespace avx512 {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/AVX512/AVX512.cpp.inc"
-}  // namespace avx512
-} // namespace mlir
-

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

static void print(OpAsmPrinter &p, GPUModuleOp op) {
   p << op.getOperationName() << ' ';
   p.printSymbolName(op.getName());
   p.printOptionalAttrDictWithKeyword(op.getAttrs(),
                                      {SymbolTable::getSymbolAttrName()});
   p.printRegion(op.getOperation()->getRegion(0), /*printEntryBlockArgs=*/false,
                 /*printBlockTerminators=*/false);
 }
 
-// Namespace avoids ambiguous ReturnOpAdaptor.
-namespace mlir {
-namespace gpu {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/GPU/GPUOps.cpp.inc"
-} // namespace gpu
-} // namespace mlir

mlir/lib/Dialect/GPU/Transforms/ParallelLoopMapper.cpp

 #include "mlir/Dialect/SCF/SCF.h"
 #include "mlir/IR/AffineMap.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 using namespace mlir::gpu;
 using namespace mlir::scf;
 
+#include "mlir/Dialect/GPU/ParallelLoopMapperAttr.cpp.inc"
 #include "mlir/Dialect/GPU/ParallelLoopMapperEnums.cpp.inc"
 namespace mlir {
-
-#include "mlir/Dialect/GPU/ParallelLoopMapperAttr.cpp.inc"
 namespace gpu {
 
 StringRef getMappingAttrName() { return "mapping"; }
 
 ParallelLoopDimMapping getParallelLoopDimMappingAttr(Processor processor,
                                                      AffineMap map,
                                                      AffineMap bound) {
   MLIRContext *context = map.getContext();

mlir/lib/Dialect/LLVMIR/IR/LLVMAVX512Dialect.cpp

 
 void LLVM::LLVMAVX512Dialect::initialize() {
   addOperations<
 #define GET_OP_LIST
 #include "mlir/Dialect/LLVMIR/LLVMAVX512.cpp.inc"
       >();
 }
 
-namespace mlir {
-namespace LLVM {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/LLVMAVX512.cpp.inc"
-} // namespace LLVM
-} // namespace mlir

mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp

 //
 // The NVVM dialect only contains GPU specific additions on top of the general
 // LLVM dialect.
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/LLVMIR/NVVMDialect.h"
 
-#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/OperationSupport.h"
 #include "mlir/IR/StandardTypes.h"
 #include "llvm/AsmParser/Parser.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Function.h"

 #define GET_OP_LIST
 #include "mlir/Dialect/LLVMIR/NVVMOps.cpp.inc"
       >();
 
   // Support unknown operations because not all NVVM operations are registered.
   allowUnknownOperations();
 }
 
-namespace mlir {
-namespace NVVM {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/NVVMOps.cpp.inc"
-} // namespace NVVM
-} // namespace mlir
-

mlir/lib/Dialect/LLVMIR/IR/ROCDLDialect.cpp

 #define GET_OP_LIST
 #include "mlir/Dialect/LLVMIR/ROCDLOps.cpp.inc"
       >();
 
   // Support unknown operations because not all ROCDL operations are registered.
   allowUnknownOperations();
 }
 
-namespace mlir {
-namespace ROCDL {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/LLVMIR/ROCDLOps.cpp.inc"
-} // namespace ROCDL
-} // namespace mlir
-

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

 }
 static LogicalResult verify(PoolingMinOp op) {
   return verifySingleInputPoolingOp(op);
 }
 static LogicalResult verify(PoolingSumOp op) {
   return verifySingleInputPoolingOp(op);
 }
 
-namespace mlir {
-namespace linalg {
-
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOpsInterfaces.cpp.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Linalg/IR/LinalgOps.cpp.inc"
 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Linalg/IR/LinalgStructuredOps.cpp.inc"
 
-} // namespace linalg
-} // namespace mlir
-
 AffineMap mlir::linalg::extractOrIdentityMap(Optional<AffineMap> maybeMap,
                                              unsigned rank,
                                              MLIRContext *context) {
   if (maybeMap)
     return maybeMap.getValue();
   if (rank == 0)
     return AffineMap::get(context);
   return AffineMap::getMultiDimIdentityMap(rank, context);

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

static ParseResult parseParallelOp(OpAsmParser &parser,
   Region *body = result.addRegion();
   llvm::SmallVector<OpAsmParser::OperandType, 4> regionArgs;
   llvm::SmallVector<Type, 4> regionArgTypes;
   if (parser.parseRegion(*body, regionArgs, regionArgTypes))
     return failure();
   return success();
 }
 
-namespace mlir {
-namespace omp {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/OpenMP/OpenMPOps.cpp.inc"
-} // namespace omp
-} // namespace mlir

mlir/lib/Dialect/PDL/IR/PDL.cpp

static LogicalResult verify(TypeOp op) {
   return verifyHasBindingUseInMatcher(
       op, "`pdl.attribute`, `pdl.input`, or `pdl.operation`");
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
-namespace mlir {
-namespace pdl {
-
 #define GET_OP_CLASSES
 #include "mlir/Dialect/PDL/IR/PDLOps.cpp.inc"
-
-} // end namespace pdl
-} // end namespace mlir

mlir/lib/Dialect/SCF/SCF.cpp

static void print(OpAsmPrinter &p, scf::YieldOp op) {
   if (op.getNumOperands() != 0)
     p << ' ' << op.getOperands() << " : " << op.getOperandTypes();
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
-namespace mlir {
-namespace scf {
 #define GET_OP_CLASSES
 #include "mlir/Dialect/SCF/SCFOps.cpp.inc"
-} // namespace scf
-} // namespace mlir

mlir/lib/Dialect/SPIRV/SPIRVAttributes.cpp

 #include "mlir/IR/Builders.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
 // DictionaryDict derived attributes
 //===----------------------------------------------------------------------===//
 
-namespace mlir {
 #include "mlir/Dialect/SPIRV/TargetAndABI.cpp.inc"
 
+namespace mlir {
+
 //===----------------------------------------------------------------------===//
 // Attribute storage classes
 //===----------------------------------------------------------------------===//
 
 namespace spirv {
 namespace detail {
 
 struct InterfaceVarABIAttributeStorage : public AttributeStorage {

mlir/lib/Dialect/SPIRV/SPIRVOps.cpp

 }
 
 namespace mlir {
 namespace spirv {
 
 // TableGen'erated operation interfaces for querying versions, extensions, and
 // capabilities.
 #include "mlir/Dialect/SPIRV/SPIRVAvailability.cpp.inc"
+} // namespace spirv
+} // namespace mlir
 
 // TablenGen'erated operation definitions.
 #define GET_OP_CLASSES
 #include "mlir/Dialect/SPIRV/SPIRVOps.cpp.inc"
 
+namespace mlir {
+namespace spirv {
 // TableGen'erated operation availability interface implementations.
 #include "mlir/Dialect/SPIRV/SPIRVOpAvailabilityImpl.inc"
 
 } // namespace spirv
 } // namespace mlir

mlir/lib/Dialect/Shape/IR/Shape.cpp

 static void print(OpAsmPrinter &p, ReduceOp op) {
   p << op.getOperationName() << '(' << op.shape() << ", " << op.initVals()
     << ") : " << op.shape().getType();
   p.printOptionalArrowTypeList(op.getResultTypes());
   p.printRegion(op.region());
   p.printOptionalAttrDict(op.getAttrs());
 }
 
-namespace mlir {
-namespace shape {
-
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Shape/IR/ShapeOps.cpp.inc"
-
-} // namespace shape
-} // namespace mlir

mlir/lib/Dialect/Vector/VectorOps.cpp

 void mlir::vector::populateVectorToVectorCanonicalizationPatterns(
     OwningRewritePatternList &patterns, MLIRContext *context) {
   patterns.insert<CreateMaskFolder, MaskedLoadFolder, MaskedStoreFolder,
                   GatherFolder, ScatterFolder, ExpandLoadFolder,
                   CompressStoreFolder, StridedSliceConstantMaskFolder,
                   TransposeFolder>(context);
 }
 
-namespace mlir {
-namespace vector {
-
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Vector/VectorOps.cpp.inc"
-
-} // namespace vector
-} // namespace mlir

mlir/lib/TableGen/Operator.cpp

 #include "mlir/TableGen/Operator.h"
 #include "mlir/TableGen/OpTrait.h"
 #include "mlir/TableGen/Predicate.h"
 #include "mlir/TableGen/Type.h"
 #include "llvm/ADT/EquivalenceClasses.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/TableGen/Error.h"
 #include "llvm/TableGen/Record.h"
 
 #define DEBUG_TYPE "mlir-tblgen-operator"
 
void Operator::populateTypeInferenceInfo(
 
   // Skip for ops with variadic operands/results.
   // TODO: This can be relaxed.
   if (isVariadic())
     return;
 
   // Skip cases currently being custom generated.
   // TODO: Remove special cases.
-  if (getTrait("OpTrait::SameOperandsAndResultType"))
+  if (getTrait("::mlir::OpTrait::SameOperandsAndResultType"))
     return;
 
   // We create equivalence classes of argument/result types where arguments
   // and results are mapped into the same index space and indices corresponding
   // to the same type are in the same equivalence class.
   llvm::EquivalenceClasses<int> ecs;
   resultTypeMapping.resize(getNumResults());
   // Captures the argument whose type matches a given result type. Preference
void Operator::print(llvm::raw_ostream &os) const {
   for (Argument arg : arguments) {
     if (auto *attr = arg.dyn_cast<NamedAttribute *>())
       os << "[attribute] " << attr->name << '\n';
     else
       os << "[operand] " << arg.get<NamedTypeConstraint *>()->name << '\n';
   }
 }
 
+Operator::NamespaceEmitter::NamespaceEmitter(raw_ostream &os, Operator &op)
+    : os(os) {
+  auto dialect = op.getDialect();
+  if (!dialect)
+    return;
+  llvm::SplitString(dialect.getCppNamespace(), namespaces, "::");
+  for (StringRef ns : namespaces)
+    os << "namespace " << ns << " {\n";
+}
+
+Operator::NamespaceEmitter::~NamespaceEmitter() {
+  for (StringRef ns : llvm::reverse(namespaces))
+    os << "} // namespace " << ns << "\n";
+}
+
 auto Operator::VariableDecoratorIterator::unwrap(llvm::Init *init)
     -> VariableDecorator {
   return VariableDecorator(cast<llvm::DefInit>(init)->getDef());
 }
 
 auto Operator::getArgToOperandOrAttribute(int index) const
     -> OperandOrAttribute {
   return attrOrOperandMapping[index];
 }

mlir/test/lib/Dialect/Test/TestDialect.h

 #include "mlir/Interfaces/CallInterfaces.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/DerivedAttributeOpInterface.h"
 #include "mlir/Interfaces/InferTypeOpInterface.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 #include "TestOpEnums.h.inc"
 
-namespace mlir {
 
 #include "TestOpStructs.h.inc"
 #include "TestOpsDialect.h.inc"
 
 #define GET_OP_CLASSES
 #include "TestOps.h.inc"
 
+namespace mlir {
 void registerTestDialect(DialectRegistry &registry);
-
 } // end namespace mlir
 
 #endif // MLIR_TESTDIALECT_H

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

 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
-  let cppNamespace = "";
+  let cppNamespace = "::mlir";
   let hasOperationAttrVerify = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
 }
 
 class TEST_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<Test_Dialect, mnemonic, traits>;
 

mlir/test/mlir-tblgen/op-attribute.td

 
 // Test elementAttr field of TypedArrayAttr.
 // ---
 
 def SomeTypedArrayAttr : TypedArrayAttrBase<SomeAttr, "SomeAttr array">;
 
 // RECORD-LABEL: def SomeTypedArrayAttr
 // RECORD: Attr elementAttr = SomeAttr;
+
+def Test_Dialect_2 : Dialect {
+  let name = "dialect_2";
+}
+def MyStruct : StructAttr<"MyStruct", Test_Dialect_2, 
+[StructFieldAttr<"potatoes", I64ElementsAttr>]> {
+  let description = "A structure describing a number of potatoes.";
+}
+
+def StructAttrOp : NS_Op<"struct_attr_op", []> {
+  let arguments = (ins
+    MyStruct:$potatoes
+  );
+}
+
+// DECL: dialect_2::MyStruct potatoes();

mlir/test/mlir-tblgen/op-decl.td

 // CHECK:   ::mlir::Value a();
 // CHECK:   ::mlir::ValueRange b();
 // CHECK:   ::mlir::IntegerAttr attr1();
 // CHECK:   ::mlir::FloatAttr attr2();
 // CHECK: private:
 // CHECK:   ::mlir::ValueRange odsOperands;
 // CHECK: };
 
-// CHECK: class AOp : public ::mlir::Op<AOp, OpTrait::AtLeastNRegions<1>::Impl, OpTrait::AtLeastNResults<1>::Impl, OpTrait::ZeroSuccessor, OpTrait::AtLeastNOperands<1>::Impl, OpTrait::IsIsolatedFromAbove
-// CHECK-NOT: OpTrait::IsIsolatedFromAbove
+// CHECK: class AOp : public ::mlir::Op<AOp, ::mlir::OpTrait::AtLeastNRegions<1>::Impl, ::mlir::OpTrait::AtLeastNResults<1>::Impl, ::mlir::OpTrait::ZeroSuccessor, ::mlir::OpTrait::AtLeastNOperands<1>::Impl, ::mlir::OpTrait::IsIsolatedFromAbove
+// CHECK-NOT: ::mlir::OpTrait::IsIsolatedFromAbove
 // CHECK: public:
 // CHECK:   using Op::Op;
 // CHECK:   using Adaptor = AOpAdaptor;
 // CHECK:   static ::llvm::StringRef getOperationName();
 // CHECK:   ::mlir::Operation::operand_range getODSOperands(unsigned index);
 // CHECK:   ::mlir::Value a();
 // CHECK:   ::mlir::Operation::operand_range b();
 // CHECK:   ::mlir::MutableOperandRange aMutable();

mlir/tools/mlir-tblgen/DialectGen.cpp

static void emitDialectDecl(Dialect &dialect,
   /// Build the list of dependent dialects
   std::string dependentDialectRegistrations;
   {
     llvm::raw_string_ostream dialectsOs(dependentDialectRegistrations);
     for (StringRef dependentDialect : dialect.getDependentDialects())
       dialectsOs << llvm::formatv(dialectRegistrationTemplate,
                                   dependentDialect);
   }
+
+  // Emit all nested namespaces.
+  StringRef cppNamespace = dialect.getCppNamespace();
+  llvm::SmallVector<StringRef, 2> namespaces;
+  llvm::SplitString(cppNamespace, namespaces, "::");
+
+  for (auto ns : namespaces)
+    os << "namespace " << ns << " {\n";
+
   // Emit the start of the decl.
   std::string cppName = dialect.getCppClassName();
   os << llvm::formatv(dialectDeclBeginStr, cppName, dialect.getName(),
                       dependentDialectRegistrations);
 
   // Check for any attributes/types registered to this dialect.  If there are,
   // add the hooks for parsing/printing.
   if (!dialectAttrs.empty())
if (dialect.hasRegionArgAttrVerify())
     os << regionArgAttrVerifierDecl;
   if (dialect.hasRegionResultAttrVerify())
     os << regionResultAttrVerifierDecl;
   if (llvm::Optional<StringRef> extraDecl = dialect.getExtraClassDeclaration())
     os << *extraDecl;
 
   // End the dialect decl.
   os << "};\n";
+
+  // Close all nested namespaces in reverse order.
+  for (auto ns : llvm::reverse(namespaces))
+    os << "} // namespace " << ns << "\n";
 }
 
 static bool emitDialectDecls(const llvm::RecordKeeper &recordKeeper,
                              raw_ostream &os) {
   emitSourceFileHeader("Dialect Declarations", os);
 
   auto defs = recordKeeper.getAllDerivedDefinitions("Dialect");
   if (defs.empty())

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 void OpEmitter::emitDecl(raw_ostream &os) { opClass.writeDeclTo(os); }
 
 void OpEmitter::emitDef(raw_ostream &os) { opClass.writeDefTo(os); }
 
 void OpEmitter::genAttrGetters() {
   FmtContext fctx;
   fctx.withBuilder("::mlir::Builder(this->getContext())");
 
+  Dialect opDialect = op.getDialect();
   // Emit the derived attribute body.
   auto emitDerivedAttr = [&](StringRef name, Attribute attr) {
     auto &method = opClass.newMethod(attr.getReturnType(), name);
     auto &body = method.body();
     body << "  " << attr.getDerivedCodeBody() << "\n";
   };
 
   // Emit with return type specified.
   auto emitAttrWithReturnType = [&](StringRef name, Attribute attr) {
-    auto &method = opClass.newMethod(attr.getReturnType(), name);
+    Dialect attrDialect = attr.getDialect();
+    // Does the current operation have a different namespace than the attribute?
+    bool differentNamespace =
+        attrDialect && opDialect && attrDialect != opDialect;
+    std::string returnType = differentNamespace
+                                 ? (llvm::Twine(attrDialect.getCppNamespace()) +
+                                    "::" + attr.getReturnType())
+                                       .str()
+                                 : attr.getReturnType().str();
+    auto &method = opClass.newMethod(returnType, name);
     auto &body = method.body();
     body << "  auto attr = " << name << "Attr();\n";
     if (attr.hasDefaultValue()) {
       // Returns the default value if not set.
       // TODO: this is inefficient, we are recreating the attribute for every
       // call. This should be set instead.
       std::string defaultValue = std::string(
           tgfmt(attr.getConstBuilderTemplate(), &fctx, attr.getDefaultValue()));
static void generateNamedOperandGetters(const Operator &op, Class &opClass,
                                         StringRef rangeBeginCall,
                                         StringRef rangeSizeCall,
                                         StringRef getOperandCallPattern) {
   const int numOperands = op.getNumOperands();
   const int numVariadicOperands = op.getNumVariableLengthOperands();
   const int numNormalOperands = numOperands - numVariadicOperands;
 
   const auto *sameVariadicSize =
-      op.getTrait("OpTrait::SameVariadicOperandSize");
+      op.getTrait("::mlir::OpTrait::SameVariadicOperandSize");
   const auto *attrSizedOperands =
-      op.getTrait("OpTrait::AttrSizedOperandSegments");
+      op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments");
 
   if (numVariadicOperands > 1 && !sameVariadicSize && !attrSizedOperands) {
     PrintFatalError(op.getLoc(), "op has multiple variadic operands but no "
                                  "specification over their sizes");
   }
 
   if (numVariadicOperands < 2 && attrSizedOperands) {
     PrintFatalError(op.getLoc(), "op must have at least two variadic operands "
generateNamedOperandGetters(
       formatv(opSegmentSizeAttrInitCode, "operand_segment_sizes").str(),
       /*rangeType=*/"::mlir::Operation::operand_range",
       /*rangeBeginCall=*/"getOperation()->operand_begin()",
       /*rangeSizeCall=*/"getOperation()->getNumOperands()",
       /*getOperandCallPattern=*/"getOperation()->getOperand({0})");
 }
 
 void OpEmitter::genNamedOperandSetters() {
-  auto *attrSizedOperands = op.getTrait("OpTrait::AttrSizedOperandSegments");
+  auto *attrSizedOperands =
+      op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments");
   for (int i = 0, e = op.getNumOperands(); i != e; ++i) {
     const auto &operand = op.getOperand(i);
     if (operand.name.empty())
       continue;
     auto &m = opClass.newMethod("::mlir::MutableOperandRange",
                                 (operand.name + "Mutable").str());
     auto &body = m.body();
     body << "  auto range = getODSOperandIndexAndLength(" << i << ");\n"

 void OpEmitter::genNamedResultGetters() {
   const int numResults = op.getNumResults();
   const int numVariadicResults = op.getNumVariableLengthResults();
   const int numNormalResults = numResults - numVariadicResults;
 
   // If we have more than one variadic results, we need more complicated logic
   // to calculate the value range for each result.
 
-  const auto *sameVariadicSize = op.getTrait("OpTrait::SameVariadicResultSize");
+  const auto *sameVariadicSize =
+      op.getTrait("::mlir::OpTrait::SameVariadicResultSize");
   const auto *attrSizedResults =
-      op.getTrait("OpTrait::AttrSizedResultSegments");
+      op.getTrait("::mlir::OpTrait::AttrSizedResultSegments");
 
   if (numVariadicResults > 1 && !sameVariadicSize && !attrSizedResults) {
     PrintFatalError(op.getLoc(), "op has multiple variadic results but no "
                                  "specification over their sizes");
   }
 
   if (numVariadicResults < 2 && attrSizedResults) {
     PrintFatalError(op.getLoc(), "op must have at least two variadic results "
void OpEmitter::genBuilder() {
   genSeparateArgParamBuilder();
   // 2. one having an aggregated parameter for all result types / operands /
   //    attributes, and
   genCollectiveParamBuilder();
   // 3. one having a stand-alone parameter for each operand and attribute,
   //    use the first operand or attribute's type as all result types
   //    to facilitate different call patterns.
   if (op.getNumVariableLengthResults() == 0) {
-    if (op.getTrait("OpTrait::SameOperandsAndResultType")) {
+    if (op.getTrait("::mlir::OpTrait::SameOperandsAndResultType")) {
       // If the operation has a single variadic input, then the build method
       // generated by `genUseOperandAsResultTypeSeparateParamBuilder` will be
       // ambiguous with the one generated by
       // `genUseOperandAsResultTypeCollectiveParamBuilder` (they both will have
       // a single `ValueRange` argument for operands, and the collective one
       // will have a `ArrayRef<NamedAttribute>` argument initialized to empty).
       // Suppress such ambiguous build method.
       if (!op.hasSingleVariadicArg())
         genUseOperandAsResultTypeSeparateParamBuilder();
 
       // The build method generated by the inferred type collective param
       // builder and one generated here have the same arguments and hence
       // generating both will be ambiguous. Enable just one of them.
       if (!shouldGenerateInferredTypeCollectiveParamBuilder())
         genUseOperandAsResultTypeCollectiveParamBuilder();
     }
-    if (op.getTrait("OpTrait::FirstAttrDerivedResultType"))
+    if (op.getTrait("::mlir::OpTrait::FirstAttrDerivedResultType"))
       genUseAttrAsResultTypeBuilder();
   }
 }
 
 void OpEmitter::genCollectiveParamBuilder() {
   int numResults = op.getNumResults();
   int numVariadicResults = op.getNumVariableLengthResults();
   int numNonVariadicResults = numResults - numVariadicResults;
void OpEmitter::genCodeForAddingArgAndRegionForBuilder(OpMethodBody &body,
   for (int i = 0, e = op.getNumOperands(); i < e; ++i) {
     std::string argName = getArgumentName(op, i);
     if (op.getOperand(i).isOptional())
       body << "  if (" << argName << ")\n  ";
     body << "  " << builderOpState << ".addOperands(" << argName << ");\n";
   }
 
   // If the operation has the operand segment size attribute, add it here.
-  if (op.getTrait("OpTrait::AttrSizedOperandSegments")) {
+  if (op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
     body << "  " << builderOpState
          << ".addAttribute(\"operand_segment_sizes\", "
             "odsBuilder.getI32VectorAttr({";
     interleaveComma(llvm::seq<int>(0, op.getNumOperands()), body, [&](int i) {
       if (op.getOperand(i).isOptional())
         body << "(" << getArgumentName(op, i) << " ? 1 : 0)";
       else if (op.getOperand(i).isVariadic())
         body << "static_cast<int32_t>(" << getArgumentName(op, i) << ".size())";
void OpEmitter::genTypeInterfaceMethods() {
   for (int i = 0, e = op.getNumResults(); i != e; ++i) {
     os << "  inferredReturnTypes[" << i << "] = ";
     auto types = op.getSameTypeAsResult(i);
     emitType(types[0]) << ";\n";
     if (types.size() == 1)
       continue;
     // TODO: We could verify equality here, but skipping that for verification.
   }
-  os << "  return success();";
+  os << "  return ::mlir::success();";
 }
 
 void OpEmitter::genParser() {
   if (!hasStringAttribute(def, "parser") ||
       hasStringAttribute(def, "assemblyFormat"))
     return;
 
   auto &method = opClass.newMethod(

 }
 
 void OpEmitter::genVerifier() {
   auto &method =
       opClass.newMethod("::mlir::LogicalResult", "verify", /*params=*/"");
   auto &body = method.body();
   body << "  if (failed(" << op.getAdaptorName()
        << "(*this).verify(this->getLoc()))) "
-       << "return failure();\n";
+       << "return ::mlir::failure();\n";
 
   auto *valueInit = def.getValueInit("verifier");
   CodeInit *codeInit = dyn_cast<CodeInit>(valueInit);
   bool hasCustomVerify = codeInit && !codeInit->getValue().empty();
   populateSubstitutions(op, "this->getAttr", "this->getODSOperands",
                         "this->getODSResults", verifyCtx);
 
   genAttributeVerifier(op, "this->getAttr", "emitOpError(",
void OpEmitter::genSuccessorVerifier(OpMethodBody &body) {
   body << "  }\n";
 }
 
 /// Add a size count trait to the given operation class.
 static void addSizeCountTrait(OpClass &opClass, StringRef traitKind,
                               int numTotal, int numVariadic) {
   if (numVariadic != 0) {
     if (numTotal == numVariadic)
-      opClass.addTrait("OpTrait::Variadic" + traitKind + "s");
+      opClass.addTrait("::mlir::OpTrait::Variadic" + traitKind + "s");
     else
-      opClass.addTrait("OpTrait::AtLeastN" + traitKind + "s<" +
+      opClass.addTrait("::mlir::OpTrait::AtLeastN" + traitKind + "s<" +
                        Twine(numTotal - numVariadic) + ">::Impl");
     return;
   }
   switch (numTotal) {
   case 0:
-    opClass.addTrait("OpTrait::Zero" + traitKind);
+    opClass.addTrait("::mlir::OpTrait::Zero" + traitKind);
     break;
   case 1:
-    opClass.addTrait("OpTrait::One" + traitKind);
+    opClass.addTrait("::mlir::OpTrait::One" + traitKind);
     break;
   default:
-    opClass.addTrait("OpTrait::N" + traitKind + "s<" + Twine(numTotal) +
+    opClass.addTrait("::mlir::OpTrait::N" + traitKind + "s<" + Twine(numTotal) +
                      ">::Impl");
     break;
   }
 }
 
 void OpEmitter::genTraits() {
   // Add region size trait.
   unsigned numRegions = op.getNumRegions();
void OpEmitter::genTraits() {
 
   // Add variadic size trait and normal op traits.
   int numOperands = op.getNumOperands();
   int numVariadicOperands = op.getNumVariableLengthOperands();
 
   // Add operand size trait.
   if (numVariadicOperands != 0) {
     if (numOperands == numVariadicOperands)
-      opClass.addTrait("OpTrait::VariadicOperands");
+      opClass.addTrait("::mlir::OpTrait::VariadicOperands");
     else
-      opClass.addTrait("OpTrait::AtLeastNOperands<" +
+      opClass.addTrait("::mlir::OpTrait::AtLeastNOperands<" +
                        Twine(numOperands - numVariadicOperands) + ">::Impl");
   } else {
     switch (numOperands) {
     case 0:
-      opClass.addTrait("OpTrait::ZeroOperands");
+      opClass.addTrait("::mlir::OpTrait::ZeroOperands");
       break;
     case 1:
-      opClass.addTrait("OpTrait::OneOperand");
+      opClass.addTrait("::mlir::OpTrait::OneOperand");
       break;
     default:
-      opClass.addTrait("OpTrait::NOperands<" + Twine(numOperands) + ">::Impl");
+      opClass.addTrait("::mlir::OpTrait::NOperands<" + Twine(numOperands) +
+                       ">::Impl");
       break;
     }
   }
 
   // Add the native and interface traits.
   for (const auto &trait : op.getTraits()) {
     if (auto opTrait = dyn_cast<tblgen::NativeOpTrait>(&trait))
       opClass.addTrait(opTrait->getTrait());

 };
 } // end namespace
 
 OpOperandAdaptorEmitter::OpOperandAdaptorEmitter(const Operator &op)
     : op(op), adaptor(op.getAdaptorName()) {
   adaptor.newField("::mlir::ValueRange", "odsOperands");
   adaptor.newField("::mlir::DictionaryAttr", "odsAttrs");
   const auto *attrSizedOperands =
-      op.getTrait("OpTrait::AttrSizedOperandSegments");
+      op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments");
   {
     auto &constructor = adaptor.newConstructor(
         attrSizedOperands
             ? "::mlir::ValueRange values, ::mlir::DictionaryAttr attrs"
             : "::mlir::ValueRange values, ::mlir::DictionaryAttr attrs = "
               "nullptr");
     constructor.addMemberInitializer("odsOperands", "values");
     constructor.addMemberInitializer("odsAttrs", "attrs");
if (numElements != {1})
                        "must have {1} elements");
   }
   )";
 
   // Verify a few traits first so that we can use
   // getODSOperands()/getODSResults() in the rest of the verifier.
   for (auto &trait : op.getTraits()) {
     if (auto *t = dyn_cast<tblgen::NativeOpTrait>(&trait)) {
-      if (t->getTrait() == "OpTrait::AttrSizedOperandSegments") {
+      if (t->getTrait() == "::mlir::OpTrait::AttrSizedOperandSegments") {
         body << formatv(checkAttrSizedValueSegmentsCode,
                         "operand_segment_sizes", op.getNumOperands(),
                         "operand");
-      } else if (t->getTrait() == "OpTrait::AttrSizedResultSegments") {
+      } else if (t->getTrait() == "::mlir::OpTrait::AttrSizedResultSegments") {
         body << formatv(checkAttrSizedValueSegmentsCode, "result_segment_sizes",
                         op.getNumResults(), "result");
       }
     }
   }
 
   FmtContext verifyCtx;
   populateSubstitutions(op, "odsAttrs.get", "getODSOperands",
                         "<no results should be genarated>", verifyCtx);
   genAttributeVerifier(op, "odsAttrs.get",
                        Twine("emitError(loc, \"'") + op.getOperationName() +
                            "' op \"",
                        /*emitVerificationRequiringOp*/ false, verifyCtx, body);
 
-  body << "  return success();";
+  body << "  return ::mlir::success();";
 }
 
 void OpOperandAdaptorEmitter::emitDecl(const Operator &op, raw_ostream &os) {
   OpOperandAdaptorEmitter(op).adaptor.writeDeclTo(os);
 }
 
 void OpOperandAdaptorEmitter::emitDef(const Operator &op, raw_ostream &os) {
   OpOperandAdaptorEmitter(op).adaptor.writeDefTo(os);
 }
 
 // Emits the opcode enum and op classes.
 static void emitOpClasses(const std::vector<Record *> &defs, raw_ostream &os,
                           bool emitDecl) {
   // First emit forward declaration for each class, this allows them to refer
   // to each others in traits for example.
   if (emitDecl) {
     os << "#if defined(GET_OP_CLASSES) || defined(GET_OP_FWD_DEFINES)\n";
     os << "#undef GET_OP_FWD_DEFINES\n";
     for (auto *def : defs) {
       Operator op(*def);
+      Operator::NamespaceEmitter emitter(os, op);
       os << "class " << op.getCppClassName() << ";\n";
     }
     os << "#endif\n\n";
   }
 
   IfDefScope scope("GET_OP_CLASSES", os);
   for (auto *def : defs) {
     Operator op(*def);
+    Operator::NamespaceEmitter emitter(os, op);
     if (emitDecl) {
       os << formatv(opCommentHeader, op.getQualCppClassName(), "declarations");
       OpOperandAdaptorEmitter::emitDecl(op, os);
       OpEmitter::emitDecl(op, os);
     } else {
       os << formatv(opCommentHeader, op.getQualCppClassName(), "definitions");
       OpOperandAdaptorEmitter::emitDef(op, os);
       OpEmitter::emitDef(op, os);
     }

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 }
 
 /// The code snippet used to generate a parser call for an attribute.
 ///
 /// {0}: The name of the attribute.
 /// {1}: The type for the attribute.
 const char *const attrParserCode = R"(
   if (parser.parseAttribute({0}Attr{1}, "{0}", result.attributes))
-    return failure();
+    return ::mlir::failure();
 )";
 const char *const optionalAttrParserCode = R"(
   {
     ::mlir::OptionalParseResult parseResult =
       parser.parseOptionalAttribute({0}Attr{1}, "{0}", result.attributes);
     if (parseResult.hasValue() && failed(*parseResult))
-      return failure();
+      return ::mlir::failure();
   }
 )";
 
 /// The code snippet used to generate a parser call for a symbol name attribute.
 ///
 /// {0}: The name of the attribute.
 const char *const symbolNameAttrParserCode = R"(
   if (parser.parseSymbolName({0}Attr, "{0}", result.attributes))
-    return failure();
+    return ::mlir::failure();
 )";
 const char *const optionalSymbolNameAttrParserCode = R"(
   // Parsing an optional symbol name doesn't fail, so no need to check the
   // result.
   (void)parser.parseOptionalSymbolName({0}Attr, "{0}", result.attributes);
 )";
 
 /// The code snippet used to generate a parser call for an enum attribute.
 ///
 /// {0}: The name of the attribute.
 /// {1}: The c++ namespace for the enum symbolize functions.
 /// {2}: The function to symbolize a string of the enum.
 /// {3}: The constant builder call to create an attribute of the enum type.
 const char *const enumAttrParserCode = R"(
   {
     ::mlir::StringAttr attrVal;
     ::mlir::NamedAttrList attrStorage;
     auto loc = parser.getCurrentLocation();
     if (parser.parseAttribute(attrVal, parser.getBuilder().getNoneType(),
                               "{0}", attrStorage))
-      return failure();
+      return ::mlir::failure();
 
     auto attrOptional = {1}::{2}(attrVal.getValue());
     if (!attrOptional)
       return parser.emitError(loc, "invalid ")
              << "{0} attribute specification: " << attrVal;
 
     {0}Attr = {3};
     result.addAttribute("{0}", {0}Attr);
   }
 )";
 const char *const optionalEnumAttrParserCode = R"(
   {
     ::mlir::StringAttr attrVal;
     ::mlir::NamedAttrList attrStorage;
     auto loc = parser.getCurrentLocation();
 
     ::mlir::OptionalParseResult parseResult =
       parser.parseOptionalAttribute(attrVal, parser.getBuilder().getNoneType(),
                                     "{0}", attrStorage);
     if (parseResult.hasValue()) {
       if (failed(*parseResult))
-        return failure();
+        return ::mlir::failure();
 
       auto attrOptional = {1}::{2}(attrVal.getValue());
       if (!attrOptional)
         return parser.emitError(loc, "invalid ")
                << "{0} attribute specification: " << attrVal;
 
       {0}Attr = {3};
       result.addAttribute("{0}", {0}Attr);
     }
   }
 )";
 
 /// The code snippet used to generate a parser call for an operand.
 ///
 /// {0}: The name of the operand.
 const char *const variadicOperandParserCode = R"(
   {0}OperandsLoc = parser.getCurrentLocation();
   if (parser.parseOperandList({0}Operands))
-    return failure();
+    return ::mlir::failure();
 )";
 const char *const optionalOperandParserCode = R"(
   {
     {0}OperandsLoc = parser.getCurrentLocation();
     ::mlir::OpAsmParser::OperandType operand;
     ::mlir::OptionalParseResult parseResult =
                                     parser.parseOptionalOperand(operand);
     if (parseResult.hasValue()) {
       if (failed(*parseResult))
-        return failure();
+        return ::mlir::failure();
       {0}Operands.push_back(operand);
     }
   }
 )";
 const char *const operandParserCode = R"(
   {0}OperandsLoc = parser.getCurrentLocation();
   if (parser.parseOperand({0}RawOperands[0]))
-    return failure();
+    return ::mlir::failure();
 )";
 
 /// The code snippet used to generate a parser call for a type list.
 ///
 /// {0}: The name for the type list.
 const char *const variadicTypeParserCode = R"(
   if (parser.parseTypeList({0}Types))
-    return failure();
+    return ::mlir::failure();
 )";
 const char *const optionalTypeParserCode = R"(
   {
     ::mlir::Type optionalType;
     ::mlir::OptionalParseResult parseResult =
                                     parser.parseOptionalType(optionalType);
     if (parseResult.hasValue()) {
       if (failed(*parseResult))
-        return failure();
+        return ::mlir::failure();
       {0}Types.push_back(optionalType);
     }
   }
 )";
 const char *const typeParserCode = R"(
   if (parser.parseType({0}RawTypes[0]))
-    return failure();
+    return ::mlir::failure();
 )";
 
 /// The code snippet used to generate a parser call for a functional type.
 ///
 /// {0}: The name for the input type list.
 /// {1}: The name for the result type list.
 const char *const functionalTypeParserCode = R"(
   ::mlir::FunctionType {0}__{1}_functionType;
   if (parser.parseType({0}__{1}_functionType))
-    return failure();
+    return ::mlir::failure();
   {0}Types = {0}__{1}_functionType.getInputs();
   {1}Types = {0}__{1}_functionType.getResults();
 )";
 
 /// The code snippet used to generate a parser call for a region list.
 ///
 /// {0}: The name for the region list.
 const char *regionListParserCode = R"(
   {
     std::unique_ptr<::mlir::Region> region;
     auto firstRegionResult = parser.parseOptionalRegion(region);
     if (firstRegionResult.hasValue()) {
       if (failed(*firstRegionResult))
-        return failure();
+        return ::mlir::failure();
       {0}Regions.emplace_back(std::move(region));
 
       // Parse any trailing regions.
       while (succeeded(parser.parseOptionalComma())) {
         region = std::make_unique<::mlir::Region>();
         if (parser.parseRegion(*region))
-          return failure();
+          return ::mlir::failure();
         {0}Regions.emplace_back(std::move(region));
       }
     }
   }
 )";
 
 /// The code snippet used to ensure a list of regions have terminators.
 ///
 /// {0}: The name of the region list.
 const char *regionListEnsureTerminatorParserCode = R"(
   for (auto &region : {0}Regions)
     ensureTerminator(*region, parser.getBuilder(), result.location);
 )";
 
 /// The code snippet used to generate a parser call for an optional region.
 ///
 /// {0}: The name of the region.
 const char *optionalRegionParserCode = R"(
   if (parser.parseOptionalRegion(*{0}Region))
-    return failure();
+    return ::mlir::failure();
 )";
 
 /// The code snippet used to generate a parser call for a region.
 ///
 /// {0}: The name of the region.
 const char *regionParserCode = R"(
   if (parser.parseRegion(*{0}Region))
-    return failure();
+    return ::mlir::failure();
 )";
 
 /// The code snippet used to ensure a region has a terminator.
 ///
 /// {0}: The name of the region.
 const char *regionEnsureTerminatorParserCode = R"(
   ensureTerminator(*{0}Region, parser.getBuilder(), result.location);
 )";
 
 /// The code snippet used to generate a parser call for a successor list.
 ///
 /// {0}: The name for the successor list.
 const char *successorListParserCode = R"(
   {
     ::mlir::Block *succ;
     auto firstSucc = parser.parseOptionalSuccessor(succ);
     if (firstSucc.hasValue()) {
       if (failed(*firstSucc))
-        return failure();
+        return ::mlir::failure();
       {0}Successors.emplace_back(succ);
 
       // Parse any trailing successors.
       while (succeeded(parser.parseOptionalComma())) {
         if (parser.parseSuccessor(succ))
-          return failure();
+          return ::mlir::failure();
         {0}Successors.emplace_back(succ);
       }
     }
   }
 )";
 
 /// The code snippet used to generate a parser call for a successor.
 ///
 /// {0}: The name of the successor.
 const char *successorParserCode = R"(
   if (parser.parseSuccessor({0}Successor))
-    return failure();
+    return ::mlir::failure();
 )";
 
 namespace {
 /// The type of length for a given parse argument.
 enum class ArgumentLengthKind {
   /// The argument is variadic, and may contain 0->N elements.
   Variadic,
   /// The argument is optional, and may contain 0 or 1 elements.
for (Element &param : dir->getArguments()) {
     }
   }
 
   body << "    if (parse" << dir->getName() << "(parser";
   for (Element &param : dir->getArguments())
     genCustomParameterParser(param, body);
 
   body << "))\n"
-       << "      return failure();\n";
+       << "      return ::mlir::failure();\n";
 
   // After parsing, add handling for any of the optional constructs.
   for (Element &param : dir->getArguments()) {
     if (auto *attr = dyn_cast<AttributeVariable>(&param)) {
       const NamedAttribute *var = attr->getVar();
       if (var->attr.isOptional())
         body << llvm::formatv("    if ({0}Attr)\n  ", var->name);
 
void OperationFormat::genParser(Operator &op, OpClass &opClass) {
 
   // Generate the code to resolve the operand/result types and successors now
   // that they have been parsed.
   genParserTypeResolution(op, body);
   genParserRegionResolution(op, body);
   genParserSuccessorResolution(op, body);
   genParserVariadicSegmentResolution(op, body);
 
-  body << "  return success();\n";
+  body << "  return ::mlir::success();\n";
 }
 
 void OperationFormat::genElementParser(Element *element, OpMethodBody &body,
                                        FmtContext &attrTypeCtx) {
   /// Optional Group.
   if (auto *optional = dyn_cast<OptionalElement>(element)) {
     auto elements = optional->getElements();
 
for (Element &childElement : llvm::drop_begin(elements, 1)) {
         genElementParser(&childElement, body, attrTypeCtx);
     }
     body << "  }\n";
 
     /// Literals.
   } else if (LiteralElement *literal = dyn_cast<LiteralElement>(element)) {
     body << "  if (parser.parse";
     genLiteralParser(literal->getLiteral(), body);
-    body << ")\n    return failure();\n";
+    body << ")\n    return ::mlir::failure();\n";
 
     /// Arguments.
   } else if (auto *attr = dyn_cast<AttributeVariable>(element)) {
     const NamedAttribute *var = attr->getVar();
 
     // Check to see if we can parse this as an enum attribute.
     if (canFormatEnumAttr(var)) {
       const EnumAttr &enumAttr = cast<EnumAttr>(var->attr);
if (auto *optional = dyn_cast<OptionalElement>(element)) {
     body << formatv(isVariadic ? successorListParserCode : successorParserCode,
                     successor->getVar()->name);
 
     /// Directives.
   } else if (auto *attrDict = dyn_cast<AttrDictDirective>(element)) {
     body << "  if (parser.parseOptionalAttrDict"
          << (attrDict->isWithKeyword() ? "WithKeyword" : "")
          << "(result.attributes))\n"
-         << "    return failure();\n";
+         << "    return ::mlir::failure();\n";
   } else if (auto *customDir = dyn_cast<CustomDirective>(element)) {
     genCustomDirectiveParser(customDir, body);
 
   } else if (isa<OperandsDirective>(element)) {
     body << "  ::llvm::SMLoc allOperandLoc = parser.getCurrentLocation();\n"
          << "  if (parser.parseOperandList(allOperands))\n"
-         << "    return failure();\n";
+         << "    return ::mlir::failure();\n";
 
   } else if (isa<RegionsDirective>(element)) {
     body << llvm::formatv(regionListParserCode, "full");
     if (hasImplicitTermTrait)
       body << llvm::formatv(regionListEnsureTerminatorParserCode, "full");
 
   } else if (isa<SuccessorsDirective>(element)) {
     body << llvm::formatv(successorListParserCode, "full");
if (op.getNumOperands() == 0)
     return;
 
   // Handle the case where all operand types are in one group.
   if (allOperandTypes) {
     // If we have all operands together, use the full operand list directly.
     if (allOperands) {
       body << "  if (parser.resolveOperands(allOperands, allOperandTypes, "
               "allOperandLoc, result.operands))\n"
-              "    return failure();\n";
+              "    return ::mlir::failure();\n";
       return;
     }
 
     // Otherwise, use llvm::concat to merge the disjoint operand lists together.
     // llvm::concat does not allow the case of a single range, so guard it here.
     body << "  if (parser.resolveOperands(";
     if (op.getNumOperands() > 1) {
       body << "::llvm::concat<const ::mlir::OpAsmParser::OperandType>(";
       llvm::interleaveComma(op.getOperands(), body, [&](auto &operand) {
         body << operand.name << "Operands";
       });
       body << ")";
     } else {
       body << op.operand_begin()->name << "Operands";
     }
     body << ", allOperandTypes, parser.getNameLoc(), result.operands))\n"
-         << "    return failure();\n";
+         << "    return ::mlir::failure();\n";
     return;
   }
   // Handle the case where all of the operands were grouped together.
   if (allOperands) {
     body << "  if (parser.resolveOperands(allOperands, ";
 
     // Group all of the operand types together to perform the resolution all at
     // once. Use llvm::concat to perform the merge. llvm::concat does not allow
     // the case of a single range, so guard it here.
     if (op.getNumOperands() > 1) {
       body << "::llvm::concat<const Type>(";
       llvm::interleaveComma(
           llvm::seq<int>(0, op.getNumOperands()), body, [&](int i) {
             body << "::llvm::ArrayRef<::mlir::Type>(";
             emitTypeResolver(operandTypes[i], op.getOperand(i).name);
             body << ")";
           });
       body << ")";
     } else {
       emitTypeResolver(operandTypes.front(), op.getOperand(0).name);
     }
 
     body << ", allOperandLoc, result.operands))\n"
-         << "    return failure();\n";
+         << "    return ::mlir::failure();\n";
     return;
   }
 
   // The final case is the one where each of the operands types are resolved
   // separately.
   for (unsigned i = 0, e = op.getNumOperands(); i != e; ++i) {
     NamedTypeConstraint &operand = op.getOperand(i);
     body << "  if (parser.resolveOperands(" << operand.name << "Operands, ";
if (auto *resolverVar = operandType.getVariable()) {
       verifyOperandAndTypeSize = !operandType.getBuilderIdx();
     }
 
     // Check to see if the sizes between the types and operands must match. If
     // they do, provide the operand location to select the proper resolution
     // overload.
     if (verifyOperandAndTypeSize)
       body << ", " << operand.name << "OperandsLoc";
-    body << ", result.operands))\n    return failure();\n";
+    body << ", result.operands))\n    return ::mlir::failure();\n";
   }
 }
 
 void OperationFormat::genParserRegionResolution(Operator &op,
                                                 OpMethodBody &body) {
   // Check for the case where all regions were parsed.
   bool hasAllRegions = llvm::any_of(
       elements, [](auto &elt) { return isa<RegionsDirective>(elt.get()); });
if (successor.isVariadic())
       body << "  result.addSuccessors(" << successor.name << "Successors);\n";
     else
       body << "  result.addSuccessors(" << successor.name << "Successor);\n";
   }
 }
 
 void OperationFormat::genParserVariadicSegmentResolution(Operator &op,
                                                          OpMethodBody &body) {
-  if (!allOperands && op.getTrait("OpTrait::AttrSizedOperandSegments")) {
+  if (!allOperands &&
+      op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments")) {
     body << "  result.addAttribute(\"operand_segment_sizes\", "
          << "parser.getBuilder().getI32VectorAttr({";
     auto interleaveFn = [&](const NamedTypeConstraint &operand) {
       // If the operand is variadic emit the parsed size.
       if (operand.isVariableLength())
         body << "static_cast<int32_t>(" << operand.name << "Operands.size())";
       else
         body << "1";
     };
     llvm::interleaveComma(op.getOperands(), body, interleaveFn);
     body << "}));\n";
   }
 
-  if (!allResultTypes && op.getTrait("OpTrait::AttrSizedResultSegments")) {
+  if (!allResultTypes &&
+      op.getTrait("::mlir::OpTrait::AttrSizedResultSegments")) {
     body << "  result.addAttribute(\"result_segment_sizes\", "
          << "parser.getBuilder().getI32VectorAttr({";
     auto interleaveFn = [&](const NamedTypeConstraint &result) {
       // If the result is variadic emit the parsed size.
       if (result.isVariableLength())
         body << "static_cast<int32_t>(" << result.name << "Types.size())";
       else
         body << "1";

 )";
 
 /// Generate the printer for the 'attr-dict' directive.
 static void genAttrDictPrinter(OperationFormat &fmt, Operator &op,
                                OpMethodBody &body, bool withKeyword) {
   body << "  p.printOptionalAttrDict" << (withKeyword ? "WithKeyword" : "")
        << "(getAttrs(), /*elidedAttrs=*/{";
   // Elide the variadic segment size attributes if necessary.
-  if (!fmt.allOperands && op.getTrait("OpTrait::AttrSizedOperandSegments"))
+  if (!fmt.allOperands &&
+      op.getTrait("::mlir::OpTrait::AttrSizedOperandSegments"))
     body << "\"operand_segment_sizes\", ";
-  if (!fmt.allResultTypes && op.getTrait("OpTrait::AttrSizedResultSegments"))
+  if (!fmt.allResultTypes &&
+      op.getTrait("::mlir::OpTrait::AttrSizedResultSegments"))
     body << "\"result_segment_sizes\", ";
   llvm::interleaveComma(
       fmt.usedAttributes, body,
       [&](const NamedAttribute *attr) { body << "\"" << attr->name << "\""; });
   body << "});\n";
 }
 
 /// Generate the printer for a literal value. `shouldEmitSpace` is true if a
if (auto *attr = dyn_cast<AttributeVariable>(element)) {
     genTypeOperandPrinter(dir->getInputs(), body) << ", ";
     genTypeOperandPrinter(dir->getResults(), body) << ");\n";
   } else {
     llvm_unreachable("unknown format element");
   }
 }
 
 void OperationFormat::genPrinter(Operator &op, OpClass &opClass) {
-  auto &method = opClass.newMethod("void", "print", "OpAsmPrinter &p");
+  auto &method = opClass.newMethod("void", "print", "::mlir::OpAsmPrinter &p");
   auto &body = method.body();
 
   // Emit the operation name, trimming the prefix if this is the standard
   // dialect.
   body << "  p << \"";
   std::string opName = op.getOperationName();
   if (op.getDialectName() == "std")
     body << StringRef(opName).drop_front(4);
assert(curToken.getKind() != Token::eof &&
            curToken.getKind() != Token::error &&
            "shouldn't advance past EOF or errors");
     curToken = lexer.lexToken();
   }
   LogicalResult parseToken(Token::Kind kind, const Twine &msg) {
     if (curToken.getKind() != kind)
       return emitError(curToken.getLoc(), msg);
     consumeToken();
-    return success();
+    return ::mlir::success();
   }
   LogicalResult emitError(llvm::SMLoc loc, const Twine &msg) {
     lexer.emitError(loc, msg);
-    return failure();
+    return ::mlir::failure();
   }
   LogicalResult emitErrorAndNote(llvm::SMLoc loc, const Twine &msg,
                                  const Twine &note) {
     lexer.emitErrorAndNote(loc, msg, note);
-    return failure();
+    return ::mlir::failure();
   }
 
   //===--------------------------------------------------------------------===//
   // Fields
   //===--------------------------------------------------------------------===//
 
   FormatLexer lexer;
   Token curToken;

 
 LogicalResult FormatParser::parse() {
   llvm::SMLoc loc = curToken.getLoc();
 
   // Parse each of the format elements into the main format.
   while (curToken.getKind() != Token::eof) {
     std::unique_ptr<Element> element;
     if (failed(parseElement(element, /*isTopLevel=*/true)))
-      return failure();
+      return ::mlir::failure();
     fmt.elements.push_back(std::move(element));
   }
 
   // Check that the attribute dictionary is in the format.
   if (!hasAttrDict)
     return emitError(loc, "'attr-dict' directive not found in "
                           "custom assembly format");
 
for (const OpTrait &trait : op.getTraits()) {
     }
   }
 
   // Verify the state of the various operation components.
   if (failed(verifyAttributes(loc)) ||
       failed(verifyResults(loc, variableTyResolver)) ||
       failed(verifyOperands(loc, variableTyResolver)) ||
       failed(verifyRegions(loc)) || failed(verifySuccessors(loc)))
-    return failure();
+    return ::mlir::failure();
 
   // Collect the set of used attributes in the format.
   fmt.usedAttributes = seenAttrs.takeVector();
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult FormatParser::verifyAttributes(llvm::SMLoc loc) {
   // Check that there are no `:` literals after an attribute without a constant
   // type. The attribute grammar contains an optional trailing colon type, which
   // can lead to unexpected and generally unintended behavior. Given that, it is
   // better to just error out here instead.
   using ElementsIterT = llvm::pointee_iterator<
       std::vector<std::unique_ptr<Element>>::const_iterator>;
   SmallVector<std::pair<ElementsIterT, ElementsIterT>, 1> iteratorStack;
   iteratorStack.emplace_back(fmt.elements.begin(), fmt.elements.end());
   while (!iteratorStack.empty())
     if (failed(verifyAttributes(loc, iteratorStack)))
-      return failure();
-  return success();
+      return ::mlir::failure();
+  return ::mlir::success();
 }
 /// Verify the attribute elements at the back of the given stack of iterators.
 LogicalResult FormatParser::verifyAttributes(
     llvm::SMLoc loc,
     SmallVectorImpl<std::pair<ElementsIterT, ElementsIterT>> &iteratorStack) {
   auto &stackIt = iteratorStack.back();
   ElementsIterT &it = stackIt.first, e = stackIt.second;
   while (it != e) {
     Element *element = &*(it++);
 
     // Traverse into optional groups.
     if (auto *optional = dyn_cast<OptionalElement>(element)) {
       auto elements = optional->getElements();
       iteratorStack.emplace_back(elements.begin(), elements.end());
-      return success();
+      return ::mlir::success();
     }
 
     // We are checking for an attribute element followed by a `:`, so there is
     // no need to check the end.
     if (it == e && iteratorStack.size() == 1)
       break;
 
     // Check for an attribute with a constant type builder, followed by a `:`.
for (auto &nextItPair : iteratorStack) {
             loc, llvm::formatv("format ambiguity caused by `:` literal found "
                                "after attribute `{0}` which does not have "
                                "a buildable type",
                                prevAttr->getVar()->name));
       }
     }
   }
   iteratorStack.pop_back();
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult FormatParser::verifyOperands(
     llvm::SMLoc loc,
     llvm::StringMap<TypeResolutionInstance> &variableTyResolver) {
   // Check that all of the operands are within the format, and their types can
   // be inferred.
   auto &buildableTypes = fmt.buildableTypes;
if (!builder || (fmt.allOperands && operand.isVariableLength())) {
               "', is not buildable and a buildable type cannot be inferred",
           "suggest adding a type constraint to the operation or adding a "
           "'type($" +
               operand.name + ")' directive to the " + "custom assembly format");
     }
     auto it = buildableTypes.insert({*builder, buildableTypes.size()});
     fmt.operandTypes[i].setBuilderIdx(it.first->second);
   }
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult FormatParser::verifyRegions(llvm::SMLoc loc) {
   // Check that all of the regions are within the format.
   if (hasAllRegions)
-    return success();
+    return ::mlir::success();
 
   for (unsigned i = 0, e = op.getNumRegions(); i != e; ++i) {
     const NamedRegion &region = op.getRegion(i);
     if (!seenRegions.count(&region)) {
       return emitErrorAndNote(loc,
                               "region #" + Twine(i) + ", named '" +
                                   region.name + "', not found",
                               "suggest adding a '$" + region.name +
                                   "' directive to the custom assembly format");
     }
   }
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult FormatParser::verifyResults(
     llvm::SMLoc loc,
     llvm::StringMap<TypeResolutionInstance> &variableTyResolver) {
   // If we format all of the types together, there is nothing to check.
   if (fmt.allResultTypes)
-    return success();
+    return ::mlir::success();
 
   // Check that all of the result types can be inferred.
   auto &buildableTypes = fmt.buildableTypes;
   for (unsigned i = 0, e = op.getNumResults(); i != e; ++i) {
     if (seenResultTypes.test(i))
       continue;
 
     // Check to see if we can infer this type from another variable.
if (!builder || result.isVariableLength()) {
           "suggest adding a type constraint to the operation or adding a "
           "'type($" +
               result.name + ")' directive to the " + "custom assembly format");
     }
     // Note in the format that this result uses the custom builder.
     auto it = buildableTypes.insert({*builder, buildableTypes.size()});
     fmt.resultTypes[i].setBuilderIdx(it.first->second);
   }
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult FormatParser::verifySuccessors(llvm::SMLoc loc) {
   // Check that all of the successors are within the format.
   if (hasAllSuccessors)
-    return success();
+    return ::mlir::success();
 
   for (unsigned i = 0, e = op.getNumSuccessors(); i != e; ++i) {
     const NamedSuccessor &successor = op.getSuccessor(i);
     if (!seenSuccessors.count(&successor)) {
       return emitErrorAndNote(loc,
                               "successor #" + Twine(i) + ", named '" +
                                   successor.name + "', not found",
                               "suggest adding a '$" + successor.name +
                                   "' directive to the custom assembly format");
     }
   }
-  return success();
+  return ::mlir::success();
 }
 
 void FormatParser::handleAllTypesMatchConstraint(
     ArrayRef<StringRef> values,
     llvm::StringMap<TypeResolutionInstance> &variableTyResolver) {
   for (unsigned i = 0, e = values.size(); i != e; ++i) {
     // Check to see if this value matches a resolved operand or result type.
     ConstArgument arg = findSeenArg(values[i]);
LogicalResult FormatParser::parseVariable(std::unique_ptr<Element> &element,
 
   // Check that the parsed argument is something actually registered on the
   // op.
   /// Attributes
   if (const NamedAttribute *attr = findArg(op.getAttributes(), name)) {
     if (isTopLevel && !seenAttrs.insert(attr))
       return emitError(loc, "attribute '" + name + "' is already bound");
     element = std::make_unique<AttributeVariable>(attr);
-    return success();
+    return ::mlir::success();
   }
   /// Operands
   if (const NamedTypeConstraint *operand = findArg(op.getOperands(), name)) {
     if (isTopLevel) {
       if (fmt.allOperands || !seenOperands.insert(operand).second)
         return emitError(loc, "operand '" + name + "' is already bound");
     }
     element = std::make_unique<OperandVariable>(operand);
-    return success();
+    return ::mlir::success();
   }
   /// Regions
   if (const NamedRegion *region = findArg(op.getRegions(), name)) {
     if (!isTopLevel)
       return emitError(loc, "regions can only be used at the top level");
     if (hasAllRegions || !seenRegions.insert(region).second)
       return emitError(loc, "region '" + name + "' is already bound");
     element = std::make_unique<RegionVariable>(region);
-    return success();
+    return ::mlir::success();
   }
   /// Results.
   if (const auto *result = findArg(op.getResults(), name)) {
     if (isTopLevel)
       return emitError(loc, "results can not be used at the top level");
     element = std::make_unique<ResultVariable>(result);
-    return success();
+    return ::mlir::success();
   }
   /// Successors.
   if (const auto *successor = findArg(op.getSuccessors(), name)) {
     if (!isTopLevel)
       return emitError(loc, "successors can only be used at the top level");
     if (hasAllSuccessors || !seenSuccessors.insert(successor).second)
       return emitError(loc, "successor '" + name + "' is already bound");
     element = std::make_unique<SuccessorVariable>(successor);
-    return success();
+    return ::mlir::success();
   }
   return emitError(loc, "expected variable to refer to an argument, region, "
                         "result, or successor");
 }
 
 LogicalResult FormatParser::parseDirective(std::unique_ptr<Element> &element,
                                            bool isTopLevel) {
   Token dirTok = curToken;
LogicalResult FormatParser::parseLiteral(std::unique_ptr<Element> &element) {
   consumeToken();
 
   // Check that the parsed literal is valid.
   StringRef value = literalTok.getSpelling().drop_front().drop_back();
   if (!LiteralElement::isValidLiteral(value))
     return emitError(literalTok.getLoc(), "expected valid literal");
 
   element = std::make_unique<LiteralElement>(value);
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult FormatParser::parseOptional(std::unique_ptr<Element> &element,
                                           bool isTopLevel) {
   llvm::SMLoc curLoc = curToken.getLoc();
   if (!isTopLevel)
     return emitError(curLoc, "optional groups can only be used as top-level "
                              "elements");
   consumeToken();
 
   // Parse the child elements for this optional group.
   std::vector<std::unique_ptr<Element>> elements;
   SmallPtrSet<const NamedTypeConstraint *, 8> seenVariables;
   Optional<unsigned> anchorIdx;
   do {
     if (failed(parseOptionalChildElement(elements, seenVariables, anchorIdx)))
-      return failure();
+      return ::mlir::failure();
   } while (curToken.getKind() != Token::r_paren);
   consumeToken();
   if (failed(parseToken(Token::question, "expected '?' after optional group")))
-    return failure();
+    return ::mlir::failure();
 
   // The optional group is required to have an anchor.
   if (!anchorIdx)
     return emitError(curLoc, "optional group specified no anchor element");
 
   // The first element of the group must be one that can be parsed/printed in an
   // optional fashion.
   Element *firstElement = &*elements.front();
   if (!isa<AttributeVariable>(firstElement) &&
       !isa<LiteralElement>(firstElement) &&
       !isa<OperandVariable>(firstElement) && !isa<RegionVariable>(firstElement))
     return emitError(curLoc, "first element of an operand group must be an "
                              "attribute, literal, operand, or region");
 
   // After parsing all of the elements, ensure that all type directives refer
   // only to elements within the group.
   auto checkTypeOperand = [&](Element *typeEle) {
     auto *opVar = dyn_cast<OperandVariable>(typeEle);
     const NamedTypeConstraint *var = opVar ? opVar->getVar() : nullptr;
     if (!seenVariables.count(var))
       return emitError(curLoc, "type directive can only refer to variables "
                                "within the optional group");
-    return success();
+    return ::mlir::success();
   };
   for (auto &ele : elements) {
     if (auto *typeEle = dyn_cast<TypeDirective>(ele.get())) {
       if (failed(checkTypeOperand(typeEle->getOperand())))
-        return failure();
+        return ::mlir::failure();
     } else if (auto *typeEle = dyn_cast<FunctionalTypeDirective>(ele.get())) {
       if (failed(checkTypeOperand(typeEle->getInputs())) ||
           failed(checkTypeOperand(typeEle->getResults())))
-        return failure();
+        return ::mlir::failure();
     }
   }
 
   optionalVariables.insert(seenVariables.begin(), seenVariables.end());
   element = std::make_unique<OptionalElement>(std::move(elements), *anchorIdx);
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult FormatParser::parseOptionalChildElement(
     std::vector<std::unique_ptr<Element>> &childElements,
     SmallPtrSetImpl<const NamedTypeConstraint *> &seenVariables,
     Optional<unsigned> &anchorIdx) {
   llvm::SMLoc childLoc = curToken.getLoc();
   childElements.push_back({});
   if (failed(parseElement(childElements.back(), /*isTopLevel=*/true)))
-    return failure();
+    return ::mlir::failure();
 
   // Check to see if this element is the anchor of the optional group.
   bool isAnchor = curToken.getKind() == Token::caret;
   if (isAnchor) {
     if (anchorIdx)
       return emitError(childLoc, "only one element can be marked as the anchor "
                                  "of an optional group");
     anchorIdx = childElements.size() - 1;
     consumeToken();
   }
 
   return TypeSwitch<Element *, LogicalResult>(childElements.back().get())
       // All attributes can be within the optional group, but only optional
       // attributes can be the anchor.
       .Case([&](AttributeVariable *attrEle) {
         if (isAnchor && !attrEle->getVar()->attr.isOptional())
           return emitError(childLoc, "only optional attributes can be used to "
                                      "anchor an optional group");
-        return success();
+        return ::mlir::success();
       })
       // Only optional-like(i.e. variadic) operands can be within an optional
       // group.
       .Case<OperandVariable>([&](OperandVariable *ele) {
         if (!ele->getVar()->isVariableLength())
           return emitError(childLoc, "only variable length operands can be "
                                      "used within an optional group");
         seenVariables.insert(ele->getVar());
-        return success();
+        return ::mlir::success();
       })
       .Case<RegionVariable>([&](RegionVariable *) {
         // TODO: When ODS has proper support for marking "optional" regions, add
         // a check here.
-        return success();
+        return ::mlir::success();
       })
       // Literals, custom directives, and type directives may be used,
       // but they can't anchor the group.
       .Case<LiteralElement, CustomDirective, FunctionalTypeDirective,
             OptionalElement, TypeDirective>([&](Element *) {
         if (isAnchor)
           return emitError(childLoc, "only variables can be used to anchor "
                                      "an optional group");
-        return success();
+        return ::mlir::success();
       })
       .Default([&](Element *) {
         return emitError(childLoc, "only literals, types, and variables can be "
                                    "used within an optional group");
       });
 }
 
 LogicalResult
 FormatParser::parseAttrDictDirective(std::unique_ptr<Element> &element,
                                      llvm::SMLoc loc, bool isTopLevel,
                                      bool withKeyword) {
   if (!isTopLevel)
     return emitError(loc, "'attr-dict' directive can only be used as a "
                           "top-level directive");
   if (hasAttrDict)
     return emitError(loc, "'attr-dict' directive has already been seen");
 
   hasAttrDict = true;
   element = std::make_unique<AttrDictDirective>(withKeyword);
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseCustomDirective(std::unique_ptr<Element> &element,
                                    llvm::SMLoc loc, bool isTopLevel) {
   llvm::SMLoc curLoc = curToken.getLoc();
 
   // Parse the custom directive name.
   if (failed(
           parseToken(Token::less, "expected '<' before custom directive name")))
-    return failure();
+    return ::mlir::failure();
 
   Token nameTok = curToken;
   if (failed(parseToken(Token::identifier,
                         "expected custom directive name identifier")) ||
       failed(parseToken(Token::greater,
                         "expected '>' after custom directive name")) ||
       failed(parseToken(Token::l_paren,
                         "expected '(' before custom directive parameters")))
-    return failure();
+    return ::mlir::failure();
 
   // Parse the child elements for this optional group.=
   std::vector<std::unique_ptr<Element>> elements;
   do {
     if (failed(parseCustomDirectiveParameter(elements)))
-      return failure();
+      return ::mlir::failure();
     if (curToken.getKind() != Token::comma)
       break;
     consumeToken();
   } while (true);
 
   if (failed(parseToken(Token::r_paren,
                         "expected ')' after custom directive parameters")))
-    return failure();
+    return ::mlir::failure();
 
   // After parsing all of the elements, ensure that all type directives refer
   // only to variables.
   for (auto &ele : elements) {
     if (auto *typeEle = dyn_cast<TypeDirective>(ele.get())) {
       if (!isa<OperandVariable, ResultVariable>(typeEle->getOperand())) {
         return emitError(curLoc, "type directives within a custom directive "
                                  "may only refer to variables");
       }
     }
   }
 
   element = std::make_unique<CustomDirective>(nameTok.getSpelling(),
                                               std::move(elements));
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult FormatParser::parseCustomDirectiveParameter(
     std::vector<std::unique_ptr<Element>> &parameters) {
   llvm::SMLoc childLoc = curToken.getLoc();
   parameters.push_back({});
   if (failed(parseElement(parameters.back(), /*isTopLevel=*/true)))
-    return failure();
+    return ::mlir::failure();
 
   // Verify that the element can be placed within a custom directive.
   if (!isa<TypeDirective, AttributeVariable, OperandVariable, RegionVariable,
            SuccessorVariable>(parameters.back().get())) {
     return emitError(childLoc, "only variables and types may be used as "
                                "parameters to a custom directive");
   }
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseFunctionalTypeDirective(std::unique_ptr<Element> &element,
                                            Token tok, bool isTopLevel) {
   llvm::SMLoc loc = tok.getLoc();
   if (!isTopLevel)
     return emitError(
         loc, "'functional-type' is only valid as a top-level directive");
 
   // Parse the main operand.
   std::unique_ptr<Element> inputs, results;
   if (failed(parseToken(Token::l_paren, "expected '(' before argument list")) ||
       failed(parseTypeDirectiveOperand(inputs)) ||
       failed(parseToken(Token::comma, "expected ',' after inputs argument")) ||
       failed(parseTypeDirectiveOperand(results)) ||
       failed(parseToken(Token::r_paren, "expected ')' after argument list")))
-    return failure();
+    return ::mlir::failure();
   element = std::make_unique<FunctionalTypeDirective>(std::move(inputs),
                                                       std::move(results));
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseOperandsDirective(std::unique_ptr<Element> &element,
                                      llvm::SMLoc loc, bool isTopLevel) {
   if (isTopLevel) {
     if (fmt.allOperands || !seenOperands.empty())
       return emitError(loc, "'operands' directive creates overlap in format");
     fmt.allOperands = true;
   }
   element = std::make_unique<OperandsDirective>();
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseRegionsDirective(std::unique_ptr<Element> &element,
                                     llvm::SMLoc loc, bool isTopLevel) {
   if (!isTopLevel)
     return emitError(loc, "'regions' is only valid as a top-level directive");
   if (hasAllRegions || !seenRegions.empty())
     return emitError(loc, "'regions' directive creates overlap in format");
   hasAllRegions = true;
   element = std::make_unique<RegionsDirective>();
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseResultsDirective(std::unique_ptr<Element> &element,
                                     llvm::SMLoc loc, bool isTopLevel) {
   if (isTopLevel)
     return emitError(loc, "'results' directive can not be used as a "
                           "top-level directive");
   element = std::make_unique<ResultsDirective>();
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseSuccessorsDirective(std::unique_ptr<Element> &element,
                                        llvm::SMLoc loc, bool isTopLevel) {
   if (!isTopLevel)
     return emitError(loc,
                      "'successors' is only valid as a top-level directive");
   if (hasAllSuccessors || !seenSuccessors.empty())
     return emitError(loc, "'successors' directive creates overlap in format");
   hasAllSuccessors = true;
   element = std::make_unique<SuccessorsDirective>();
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseTypeDirective(std::unique_ptr<Element> &element, Token tok,
                                  bool isTopLevel) {
   llvm::SMLoc loc = tok.getLoc();
   if (!isTopLevel)
     return emitError(loc, "'type' is only valid as a top-level directive");
 
   std::unique_ptr<Element> operand;
   if (failed(parseToken(Token::l_paren, "expected '(' before argument list")) ||
       failed(parseTypeDirectiveOperand(operand)) ||
       failed(parseToken(Token::r_paren, "expected ')' after argument list")))
-    return failure();
+    return ::mlir::failure();
   element = std::make_unique<TypeDirective>(std::move(operand));
-  return success();
+  return ::mlir::success();
 }
 
 LogicalResult
 FormatParser::parseTypeDirectiveOperand(std::unique_ptr<Element> &element) {
   llvm::SMLoc loc = curToken.getLoc();
   if (failed(parseElement(element, /*isTopLevel=*/false)))
-    return failure();
+    return ::mlir::failure();
   if (isa<LiteralElement>(element.get()))
     return emitError(
         loc, "'type' directive operand expects variable or directive operand");
 
   if (auto *var = dyn_cast<OperandVariable>(element.get())) {
     unsigned opIdx = var->getVar() - op.operand_begin();
     if (fmt.allOperandTypes || seenOperandTypes.test(opIdx))
       return emitError(loc, "'type' of '" + var->getVar()->name +
if (auto *var = dyn_cast<OperandVariable>(element.get())) {
     fmt.allOperandTypes = true;
   } else if (isa<ResultsDirective>(&*element)) {
     if (fmt.allResultTypes || seenResultTypes.any())
       return emitError(loc, "'results' 'type' is already bound");
     fmt.allResultTypes = true;
   } else {
     return emitError(loc, "invalid argument to 'type' directive");
   }
-  return success();
+  return ::mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // Interface
 //===----------------------------------------------------------------------===//
 
 void mlir::tblgen::generateOpFormat(const Operator &constOp, OpClass &opClass) {
   // TODO: Operator doesn't expose all necessary functionality via

mlir/tools/mlir-tblgen/RewriterGen.cpp

std::string PatternEmitter::handleOpCreation(DagNode tree, int resultIndex,
   os.indent(4) << formatv("{0} {1};\n", resultOp.getQualCppClassName(),
                           valuePackName);
   os.indent(4) << "{\n";
 
   // Right now ODS don't have general type inference support. Except a few
   // special cases listed below, DRR needs to supply types for all results
   // when building an op.
   bool isSameOperandsAndResultType =
-      resultOp.getTrait("OpTrait::SameOperandsAndResultType");
-  bool useFirstAttr = resultOp.getTrait("OpTrait::FirstAttrDerivedResultType");
+      resultOp.getTrait("::mlir::OpTrait::SameOperandsAndResultType");
+  bool useFirstAttr =
+      resultOp.getTrait("::mlir::OpTrait::FirstAttrDerivedResultType");
 
   if (isSameOperandsAndResultType || useFirstAttr) {
     // We know how to deduce the result type for ops with these traits and we've
     // generated builders taking aggregate parameters. Use those builders to
     // create the ops.
 
     // First prepare local variables for op arguments used in builder call.
     createAggregateLocalVarsForOpArgs(tree, childNodeNames);