[mlir-tblgen] Use fully qualified names in generated code files

[Kayjukh]

Summary

Using fully qualified names wherever possible avoids ambiguous class and function names. This is a follow-up to D82371.

[Kayjukh]

Not sure why clang-tidy complains about EnumsGenTest.h.inc here.

[rriddle]

mlir/include/mlir/IR/OpBase.td

220

Please go through and make sure everything is wrapped at 80 characters.

[Kayjukh]

Make sure that OpBase.td is wrapped at 80 characters.

[Kayjukh]

I'm wondering how hard it would be to have a linter check for TableGen files that reports whether there are lines longer than 80 characters. This could be useful for such situations: I had to change some locations in OpBase.td that went unnoticed during earlier reviews (e.g. the constBuilderCall for I32EnumAttr).

[rriddle]

LGTM after making sure that LLVM types use the proper llvm namespace.

mlir/tools/mlir-tblgen/PassGen.cpp

45

Please use the proper definition in LLVM for LLVM types.

mlir/include/mlir/IR/OpBase.td

 // * Use uncategorized constraint to specify
 //   * Multi-entity constraints in rewrite rules
 
 //===----------------------------------------------------------------------===//
 // Common predicates
 //===----------------------------------------------------------------------===//
 
 // Whether a type is a VectorType.
-def IsVectorTypePred : CPred<"$_self.isa<VectorType>()">;
+def IsVectorTypePred : CPred<"$_self.isa<::mlir::VectorType>()">;
 
 // Whether a type is a TensorType.
-def IsTensorTypePred : CPred<"$_self.isa<TensorType>()">;
+def IsTensorTypePred : CPred<"$_self.isa<::mlir::TensorType>()">;
 
 // Whether a type is a MemRefType.
-def IsMemRefTypePred : CPred<"$_self.isa<MemRefType>()">;
+def IsMemRefTypePred : CPred<"$_self.isa<::mlir::MemRefType>()">;
 
 // Whether a type is an  IsUnrankedMemRefType
-def IsUnrankedMemRefTypePred : CPred<"$_self.isa<UnrankedMemRefType>()">;
+def IsUnrankedMemRefTypePred : CPred<"$_self.isa<::mlir::UnrankedMemRefType>()">;
 
 // Whether a type is a ShapedType.
-def IsShapedTypePred : CPred<"$_self.isa<ShapedType>()">;
+def IsShapedTypePred : CPred<"$_self.isa<::mlir::ShapedType>()">;
 
 // For a ShapedType, verify that it has a static shape.
-def HasStaticShapePred : CPred<"$_self.cast<ShapedType>().hasStaticShape()">;
+def HasStaticShapePred :
+        CPred<"$_self.cast<::mlir::ShapedType>().hasStaticShape()">;
 
 // Whether a type is a TupleType.
-def IsTupleTypePred : CPred<"$_self.isa<TupleType>()">;
+def IsTupleTypePred : CPred<"$_self.isa<::mlir::TupleType>()">;
 
 //===----------------------------------------------------------------------===//
 // Dialect definitions
 //===----------------------------------------------------------------------===//
 
 class Dialect {
   // The name of the dialect.
   string name = ?;
class BuildableType<code builder> {
   // The builder call to invoke (if specified) to construct the BuildableType.
   code builderCall = builder;
 }
 
 // Any type at all.
 def AnyType : Type<CPred<"true">, "any type">;
 
 // None type
-def NoneType : Type<CPred<"$_self.isa<NoneType>()">, "none type">,
-      BuildableType<"$_builder.getType<NoneType>()">;
+def NoneType : Type<CPred<"$_self.isa<::mlir::NoneType>()">, "none type">,
+      BuildableType<"$_builder.getType<::mlir::NoneType>()">;
 
 // Any type from the given list
 class AnyTypeOf<list<Type> allowedTypes, string description = ""> : Type<
     // Satisfy any of the allowed type's condition
     Or<!foreach(allowedtype, allowedTypes, allowedtype.predicate)>,
     !if(!eq(description, ""),
         StrJoin<!foreach(t, allowedTypes, t.description), " or ">.result,
         description)>;
 
 // Integer types.
 
 // Any integer type irrespective of its width and signedness semantics.
-def AnyInteger : Type<CPred<"$_self.isa<IntegerType>()">, "integer">;
+def AnyInteger : Type<CPred<"$_self.isa<::mlir::IntegerType>()">, "integer">;
 
 // Any integer type (regardless of signedness semantics) of a specific width.
 class AnyI<int width>
     : Type<CPred<"$_self.isInteger(" # width # ")">, width # "-bit integer"> {
   int bitwidth = width;
 }
 
 class AnyIntOfWidths<list<int> widths> :

 
 def UI1  : UI<1>;
 def UI8  : UI<8>;
 def UI16 : UI<16>;
 def UI32 : UI<32>;
 def UI64 : UI<64>;
 
 // Index type.
-def Index : Type<CPred<"$_self.isa<IndexType>()">, "index">,
+def Index : Type<CPred<"$_self.isa<::mlir::IndexType>()">, "index">,
             BuildableType<"$_builder.getIndexType()">;
 
 // Floating point types.
 
 // Any float type irrespective of its width.
-def AnyFloat : Type<CPred<"$_self.isa<FloatType>()">, "floating-point">;
+def AnyFloat : Type<CPred<"$_self.isa<::mlir::FloatType>()">, "floating-point">;
 
 // Float type of a specific width.
 class F<int width>
     : Type<CPred<"$_self.isF" # width # "()">,
                 width # "-bit float">,
       BuildableType<"$_builder.getF" # width # "Type()"> {
   int bitwidth = width;
 }
 
 class FloatOfWidths<list<int> widths> :
     AnyTypeOf<!foreach(w, widths, F<w>),
               StrJoinInt<widths, "/">.result # "-bit float">;
 
 def F16 : F<16>;
 def F32 : F<32>;
 def F64 : F<64>;
 
 def BF16 : Type<CPred<"$_self.isBF16()">, "bfloat16 type">,
            BuildableType<"$_builder.getBF16Type()">;
 
 class Complex<Type type>
     : Type<And<[
-          CPred<"$_self.isa<ComplexType>()">,
-          SubstLeaves<"$_self", "$_self.cast<ComplexType>().getElementType()",
+          CPred<"$_self.isa<::mlir::ComplexType>()">,
+          SubstLeaves<"$_self",
+                      "$_self.cast<::mlir::ComplexType>().getElementType()",
            type.predicate>]>,
            "complex type with " # type.description # " elements"> {
   Type elementType = type;
 }
 
-def AnyComplex : Type<CPred<"$_self.isa<ComplexType>()">, "complex-type">;
+def AnyComplex : Type<CPred<"$_self.isa<::mlir::ComplexType>()">,
+                            "complex-type">;
 
 class OpaqueType<string dialect, string name, string description>
   : Type<CPred<"isOpaqueTypeWithName($_self, \""#dialect#"\", \""#name#"\")">,
          description>,
-    BuildableType<"OpaqueType::get($_builder.getIdentifier(\"" # dialect #
-                  "\"), \"" # name # "\", $_builder.getContext())">;
+    BuildableType<"::mlir::OpaqueType::get($_builder.getIdentifier(\""
+                  # dialect # "\"), \"" # name # "\", $_builder.getContext())">;
 
 // Function Type
 
 // Any function type.
-def FunctionType : Type<CPred<"$_self.isa<FunctionType>()">, "function type">;
+def FunctionType : Type<CPred<"$_self.isa<::mlir::FunctionType>()">,
+                              "function type">;
 
 // A container type is a type that has another type embedded within it.
 class ContainerType<Type etype, Pred containerPred, code elementTypeCall,
                     string descr> :
     // First, check the container predicate.  Then, substitute the extracted
     // element into the element type checker.
     Type<And<[containerPred,
                 SubstLeaves<"$_self", !cast<string>(elementTypeCall),
                 etype.predicate>]>,
          descr # " of " # etype.description # " values"> {
   // The type of elements in the container.
   Type elementType = etype;
 
   // Call to retrieve.
   code getElementTypeCall = elementTypeCall;
 }
 
 class ShapedContainerType<list<Type> allowedTypes, Pred containerPred, string descr> :
     ContainerType<AnyTypeOf<allowedTypes>, containerPred,
-                  "$_self.cast<ShapedType>().getElementType()", descr>;
+                  "$_self.cast<::mlir::ShapedType>().getElementType()", descr>;
 
 // Whether a shaped type is ranked.
-def HasRankPred : CPred<"$_self.cast<ShapedType>().hasRank()">;
+def HasRankPred : CPred<"$_self.cast<::mlir::ShapedType>().hasRank()">;
 
 // Whether a shaped type has one of the specified ranks.
 class HasAnyRankOfPred<list<int> ranks> : And<[
     HasRankPred,
     Or<!foreach(rank, ranks,
-                CPred<"$_self.cast<ShapedType>().getRank() == " # rank>)>]>;
+                CPred<"$_self.cast<::mlir::ShapedType>().getRank() == " # rank>)>]>;
 
 // Vector types.
 
 class VectorOf<list<Type> allowedTypes> :
   ShapedContainerType<allowedTypes, IsVectorTypePred, "vector">;
 
 // Whether the number of elements of a vector is from the given
 // `allowedRanks` list
 class IsVectorOfRankPred<list<int> allowedRanks> :
   And<[IsVectorTypePred,
        Or<!foreach(allowedlength, allowedRanks,
-                   CPred<[{$_self.cast<VectorType>().getRank()
+                   CPred<[{$_self.cast<::mlir::VectorType>().getRank()
                            == }]
                          # allowedlength>)>]>;
 
 // Any vector where the rank is from the given `allowedRanks` list
 class VectorOfRank<list<int> allowedRanks> : Type<
   IsVectorOfRankPred<allowedRanks>,
   " of ranks " # StrJoinInt<allowedRanks, "/">.result>;
 
 // Any vector where the rank is from the given `allowedRanks` list and the type
 // is from the given `allowedTypes` list
 class VectorOfRankAndType<list<int> allowedRanks,
                           list<Type> allowedTypes> : Type<
   And<[VectorOf<allowedTypes>.predicate,
        VectorOfRank<allowedRanks>.predicate]>,
   VectorOf<allowedTypes>.description #
   VectorOfRank<allowedRanks>.description>;
 
 // Whether the number of elements of a vector is from the given
 // `allowedLengths` list
 class IsVectorOfLengthPred<list<int> allowedLengths> :
   And<[IsVectorTypePred,
        Or<!foreach(allowedlength, allowedLengths,
-                   CPred<[{$_self.cast<VectorType>().getNumElements()
+                   CPred<[{$_self.cast<::mlir::VectorType>().getNumElements()
                            == }]
                          # allowedlength>)>]>;
 
 // Any vector where the number of elements is from the given
 // `allowedLengths` list
 class VectorOfLength<list<int> allowedLengths> : Type<
   IsVectorOfLengthPred<allowedLengths>,
   " of length " # StrJoinInt<allowedLengths, "/">.result>;

 
 class StaticShapeMemRefOf<list<Type> allowedTypes>
     : Type<And<[MemRefOf<allowedTypes>.predicate, HasStaticShapePred]>,
            "statically shaped " # MemRefOf<allowedTypes>.description>;
 
 def AnyStaticShapeMemRef : StaticShapeMemRefOf<[AnyType]>;
 
 // For a MemRefType, verify that it has strides.
-def HasStridesPred : CPred<[{ isStrided($_self.cast<MemRefType>()) }]>;
+def HasStridesPred : CPred<[{ isStrided($_self.cast<::mlir::MemRefType>()) }]>;
 
 class StridedMemRefOf<list<Type> allowedTypes>
     : Type<And<[MemRefOf<allowedTypes>.predicate, HasStridesPred]>,
            "strided " # MemRefOf<allowedTypes>.description>;
 
 def AnyStridedMemRef : StridedMemRefOf<[AnyType]>;
 
 class AnyStridedMemRefOfRank<int rank> :
   Type<And<[AnyStridedMemRef.predicate,
             MemRefRankOf<[AnyType], [rank]>.predicate]>,
        AnyStridedMemRef.description # " of rank " # rank>;
 
 // This represents a generic tuple without any constraints on element type.
 def AnyTuple : Type<IsTupleTypePred, "tuple">;
 
 // A container type that has other types embedded in it, but (unlike
 // ContainerType) can hold elements with a mix of types. Requires a call that
 // produces a list of all elements' types.
 class MixedContainerType<Type etype, Pred containerPred, code elementTypesCall,
                          string descr> :
     Type<
         And<[
             containerPred,
             Concat<
-                "llvm::all_of(" # elementTypesCall # ", [](Type t) { return ",
+                "::llvm::all_of(" # elementTypesCall # ", [](Type t) { return ",
                 SubstLeaves<"$_self", "t", etype.predicate>,
                 "; })"
             >
         ]>,
         descr # " with any combination of " # etype.description # " values"> {
   // The type of elements in the container.
   Type elementType = etype;
 
   // Call to retrieve.
   code getElementTypesCall = elementTypesCall;
 }
 
 // A Tuple that holds a mix of elements of the allowed types.
 class TupleOf<list<Type> allowedTypes>
     : MixedContainerType<AnyTypeOf<allowedTypes>, IsTupleTypePred,
-                         "$_self.cast<TupleType>().getTypes()", "tuple">;
+                         "$_self.cast<::mlir::TupleType>().getTypes()",
+                         "tuple">;
 
 // A Tuple with arbitrary nesting, where all elements are a mix of the allowed
 // types.
 class NestedTupleOf<list<Type> allowedTypes> :
     MixedContainerType<AnyTypeOf<allowedTypes>, IsTupleTypePred,
-                       "getFlattenedTypes($_self.cast<TupleType>())",
+                       "getFlattenedTypes($_self.cast<::mlir::TupleType>())",
                        "nested tuple">;
 
 //===----------------------------------------------------------------------===//
 // Common type constraints
 //===----------------------------------------------------------------------===//
 
 // Type constraint for bool-like types: bools, vectors of bools, tensors of
 // bools.

 }
 
 // Decorates an attribute as optional. The return type of the generated
 // attribute accessor method will be Optional<>.
 class OptionalAttr<Attr attr> : Attr<attr.predicate, attr.description> {
   // Rewrite the attribute to be optional.
   // Note: this has to be kept up to date with Attr above.
   let storageType = attr.storageType;
-  let returnType = "Optional<" # attr.returnType #">";
+  let returnType = "::mlir::Optional<" # attr.returnType #">";
   let convertFromStorage = "$_self ? " # returnType # "(" #
-                           attr.convertFromStorage # ") : (llvm::None)";
+                           attr.convertFromStorage # ") : (::llvm::None)";
   let valueType = attr.valueType;
   let isOptional = 1;
 
   let baseAttr = attr;
 }
 
 //===----------------------------------------------------------------------===//
 // Primitive attribute kinds
 
 // A generic attribute that must be constructed around a specific buildable type
 // `attrValType`. Backed by MLIR attribute kind `attrKind`.
 class TypedAttrBase<Type attrValType, string attrKind, Pred condition,
                     string descr> :
     Attr<condition, descr> {
   let constBuilderCall = "$_builder.get" # attrKind # "(" #
                          attrValType.builderCall # ", $0)";
-  let storageType = attrKind;
+  let storageType = "::mlir::" # attrKind;
   let valueType = attrValType;
 }
 
 // Any attribute.
 def AnyAttr : Attr<CPred<"true">, "any attribute"> {
-  let storageType = "Attribute";
-  let returnType = "Attribute";
+  let storageType = "::mlir::Attribute";
+  let returnType = "::mlir::Attribute";
   let convertFromStorage = "$_self";
   let constBuilderCall = "$0";
 }
 
-def BoolAttr : Attr<CPred<"$_self.isa<BoolAttr>()">, "bool attribute"> {
-  let storageType = [{ BoolAttr }];
+def BoolAttr : Attr<CPred<"$_self.isa<::mlir::BoolAttr>()">, "bool attribute"> {
+  let storageType = [{ ::mlir::BoolAttr }];
   let returnType = [{ bool }];
   let valueType = I1;
   let constBuilderCall = "$_builder.getBoolAttr($0)";
 }
 
 // Index attribute.
 def IndexAttr :
     TypedAttrBase<
       Index, "IntegerAttr",
-      And<[CPred<"$_self.isa<IntegerAttr>()">,
-           CPred<"$_self.cast<IntegerAttr>().getType().isa<IndexType>()">]>,
+      And<[CPred<"$_self.isa<::mlir::IntegerAttr>()">,
+           CPred<"$_self.cast<::mlir::IntegerAttr>().getType()"
+                 ".isa<::mlir::IndexType>()">]>,
       "index attribute"> {
-  let returnType = [{ APInt }];
+  let returnType = [{ ::mlir::APInt }];
 }
 
 // Base class for any integer (regardless of signedness semantics) attributes
 // of fixed width.
 class AnyIntegerAttrBase<AnyI attrValType, string descr> :
     TypedAttrBase<
       attrValType, "IntegerAttr",
-      And<[CPred<"$_self.isa<IntegerAttr>()">,
-           CPred<"$_self.cast<IntegerAttr>().getType()."
+      And<[CPred<"$_self.isa<::mlir::IntegerAttr>()">,
+           CPred<"$_self.cast<::mlir::IntegerAttr>().getType()."
                  "isInteger(" # attrValType.bitwidth # ")">]>,
       descr> {
-  let returnType = [{ APInt }];
+  let returnType = [{ ::mlir::APInt }];
   let constBuilderCall = ?;
 }
 
 def AnyI1Attr  : AnyIntegerAttrBase<AnyI1,  "1-bit integer attribute">;
 def AnyI8Attr  : AnyIntegerAttrBase<AnyI8,  "8-bit integer attribute">;
 def AnyI16Attr : AnyIntegerAttrBase<AnyI16, "16-bit integer attribute">;
 def AnyI32Attr : AnyIntegerAttrBase<AnyI32, "32-bit integer attribute">;
 def AnyI64Attr : AnyIntegerAttrBase<AnyI64, "64-bit integer attribute">;
 
-def APIntAttr : Attr<CPred<"$_self.isa<IntegerAttr>()">,
+def APIntAttr : Attr<CPred<"$_self.isa<::mlir::IntegerAttr>()">,
                      "arbitrary integer attribute"> {
-  let storageType = [{ IntegerAttr }];
-  let returnType = [{ APInt }];
+  let storageType = [{ ::mlir::IntegerAttr }];
+  let returnType = [{ ::mlir::APInt }];
 }
 
 // Base class for signless integer attributes of fixed width.
 class SignlessIntegerAttrBase<I attrValType, string descr> :
     TypedAttrBase<
       attrValType, "IntegerAttr",
-      And<[CPred<"$_self.isa<IntegerAttr>()">,
-           CPred<"$_self.cast<IntegerAttr>().getType()."
+      And<[CPred<"$_self.isa<::mlir::IntegerAttr>()">,
+           CPred<"$_self.cast<::mlir::IntegerAttr>().getType()."
                  "isSignlessInteger(" # attrValType.bitwidth # ")">]>,
       descr> {
-  let returnType = [{ APInt }];
+  let returnType = [{ ::mlir::APInt }];
 }
 
 def I1Attr  : SignlessIntegerAttrBase<I1,  "1-bit signless integer attribute">;
 def I8Attr  : SignlessIntegerAttrBase<I8,  "8-bit signless integer attribute">;
 def I16Attr : SignlessIntegerAttrBase<I16, "16-bit signless integer attribute">;
 def I32Attr : SignlessIntegerAttrBase<I32, "32-bit signless integer attribute">;
 def I64Attr : SignlessIntegerAttrBase<I64, "64-bit signless integer attribute">;
 
 // Base class for signed integer attributes of fixed width.
 class SignedIntegerAttrBase<SI attrValType, string descr> :
     TypedAttrBase<
       attrValType, "IntegerAttr",
-      And<[CPred<"$_self.isa<IntegerAttr>()">,
-           CPred<"$_self.cast<IntegerAttr>().getType()."
+      And<[CPred<"$_self.isa<::mlir::IntegerAttr>()">,
+           CPred<"$_self.cast<::mlir::IntegerAttr>().getType()."
                  "isSignedInteger(" # attrValType.bitwidth # ")">]>,
       descr> {
-  let returnType = [{ APInt }];
+  let returnType = [{ ::mlir::APInt }];
 }
 
 def SI1Attr  : SignedIntegerAttrBase<
     SI1,  "1-bit signed integer attribute">;
 def SI8Attr  : SignedIntegerAttrBase<
     SI8,  "8-bit signed integer attribute">;
 def SI16Attr : SignedIntegerAttrBase<
     SI16, "16-bit signed integer attribute">;
 def SI32Attr : SignedIntegerAttrBase<
     SI32, "32-bit signed integer attribute">;
 def SI64Attr : SignedIntegerAttrBase<
     SI64, "64-bit signed integer attribute">;
 
 // Base class for unsigned integer attributes of fixed width.
 class UnsignedIntegerAttrBase<UI attrValType, string descr> :
     TypedAttrBase<
       attrValType, "IntegerAttr",
-      And<[CPred<"$_self.isa<IntegerAttr>()">,
-           CPred<"$_self.cast<IntegerAttr>().getType()."
+      And<[CPred<"$_self.isa<::mlir::IntegerAttr>()">,
+           CPred<"$_self.cast<::mlir::IntegerAttr>().getType()."
                  "isUnsignedInteger(" # attrValType.bitwidth # ")">]>,
       descr> {
-  let returnType = [{ APInt }];
+  let returnType = [{ ::mlir::APInt }];
 }
 
 def UI1Attr  : UnsignedIntegerAttrBase<
     UI1,  "1-bit unsigned integer attribute">;
 def UI8Attr  : UnsignedIntegerAttrBase<
     UI8,  "8-bit unsigned integer attribute">;
 def UI16Attr : UnsignedIntegerAttrBase<
     UI16, "16-bit unsigned integer attribute">;
 def UI32Attr : UnsignedIntegerAttrBase<
     UI32, "32-bit unsigned integer attribute">;
 def UI64Attr : UnsignedIntegerAttrBase<
     UI64, "64-bit unsigned integer attribute">;
 
 // Base class for float attributes of fixed width.
 class FloatAttrBase<F attrValType, string descr> :
     TypedAttrBase<attrValType, "FloatAttr",
-              And<[CPred<"$_self.isa<FloatAttr>()">,
-                     CPred<"$_self.cast<FloatAttr>().getType().isF" #
+              And<[CPred<"$_self.isa<::mlir::FloatAttr>()">,
+                     CPred<"$_self.cast<::mlir::FloatAttr>().getType().isF" #
                            attrValType.bitwidth # "()">]>,
               descr> {
-  let returnType = [{ APFloat }];
+  let returnType = [{ ::mlir::APFloat }];
 }
 
 def F32Attr : FloatAttrBase<F32, "32-bit float attribute">;
 def F64Attr : FloatAttrBase<F64, "64-bit float attribute">;
 
 // An attribute backed by a string type.
 class StringBasedAttr<Pred condition, string descr> : Attr<condition, descr> {
   let constBuilderCall = "$_builder.getStringAttr(\"$0\")";
-  let storageType = [{ StringAttr }];
-  let returnType = [{ StringRef }];
+  let storageType = [{ ::mlir::StringAttr }];
+  let returnType = [{ ::mlir::StringRef }];
   let valueType = NoneType;
 }
 
-def StrAttr : StringBasedAttr<CPred<"$_self.isa<StringAttr>()">,
+def StrAttr : StringBasedAttr<CPred<"$_self.isa<::mlir::StringAttr>()">,
                               "string attribute">;
 
 // String attribute that has a specific value type.
-class TypedStrAttr<Type ty> : StringBasedAttr<CPred<"$_self.isa<StringAttr>()">,
-                                                    "string attribute"> {
+class TypedStrAttr<Type ty>
+    : StringBasedAttr<CPred<"$_self.isa<::mlir::StringAttr>()">,
   let valueType = ty;
 }
 
 // Base class for attributes containing types. Example:
 //   def IntTypeAttr : TypeAttrBase<"IntegerType", "integer type attribute">
 // defines a type attribute containing an integer type.
 class TypeAttrBase<string retType, string description> :
     Attr<And<[
-      CPred<"$_self.isa<TypeAttr>()">,
-      CPred<"$_self.cast<TypeAttr>().getValue().isa<" # retType # ">()">]>,
+      CPred<"$_self.isa<::mlir::TypeAttr>()">,
+      CPred<"$_self.cast<::mlir::TypeAttr>().getValue().isa<"
+            # retType # ">()">]>,
     description> {
-  let storageType = [{ TypeAttr }];
+  let storageType = [{ ::mlir::TypeAttr }];
   let returnType = retType;
   let valueType = NoneType;
   let convertFromStorage = "$_self.getValue().cast<" # retType # ">()";
 }
 
-def TypeAttr : TypeAttrBase<"Type", "any type attribute">;
+def TypeAttr : TypeAttrBase<"::mlir::Type", "any type attribute">;
 
 // The mere presence of unit attributes has a meaning.  Therefore, unit
 // attributes are always treated as optional and accessors to them return
 // "true" if the attribute is present and "false" otherwise.
-def UnitAttr : Attr<CPred<"$_self.isa<UnitAttr>()">, "unit attribute"> {
-  let storageType = [{ UnitAttr }];
+def UnitAttr : Attr<CPred<"$_self.isa<::mlir::UnitAttr>()">, "unit attribute"> {
+  let storageType = [{ ::mlir::UnitAttr }];
   let constBuilderCall = "$_builder.getUnitAttr()";
   let convertFromStorage = "$_self != nullptr";
   let returnType = "bool";
   let valueType = NoneType;
   let isOptional = 1;
 }
 
 //===----------------------------------------------------------------------===//
class EnumAttrCaseInfo<string sym, int intVal, string strVal> {
   // The string representation of the enumerant. May be the same as symbol.
   string str = strVal;
 }
 
 // An enum attribute case stored with StringAttr.
 class StrEnumAttrCase<string sym, int val = -1> :
     EnumAttrCaseInfo<sym, val, sym>,
     StringBasedAttr<
-      CPred<"$_self.cast<StringAttr>().getValue() == \"" # sym # "\"">,
+      CPred<"$_self.cast<::mlir::StringAttr>().getValue() == \"" # sym # "\"">,
       "case " # sym>;
 
 // An enum attribute case stored with IntegerAttr, which has an integer value,
 // its representation as a string and a C++ symbol name which may be different.
 class IntEnumAttrCaseBase<I intType, string sym, string strVal, int intVal> :
     EnumAttrCaseInfo<sym, intVal, strVal>,
     SignlessIntegerAttrBase<intType, "case " # strVal> {
   let predicate =
-    CPred<"$_self.cast<IntegerAttr>().getInt() == " # intVal>;
+    CPred<"$_self.cast<::mlir::IntegerAttr>().getInt() == " # intVal>;
 }
 
 // Cases of integer enum attributes with a specific type. By default, the string
 // representation is the same as the C++ symbol name.
 class I32EnumAttrCase<string sym, int val, string str = sym>
     : IntEnumAttrCaseBase<I32, sym, str, val>;
 class I64EnumAttrCase<string sym, int val, string str = sym>
     : IntEnumAttrCaseBase<I64, sym, str, val>;
 
 // A bit enum case stored with 32-bit IntegerAttr. `val` here is *not* the
 // ordinal number of the bit that is set. It is the 32-bit integer with only
 // one bit set.
 class BitEnumAttrCase<string sym, int val> :
     EnumAttrCaseInfo<sym, val, sym>,
     SignlessIntegerAttrBase<I32, "case " # sym> {
   let predicate = CPred<
-    "$_self.cast<IntegerAttr>().getValue().getZExtValue() & " # val # "u">;
+    "$_self.cast<::mlir::IntegerAttr>().getValue().getZExtValue() & "
+    # val # "u">;
 }
 
 // Additional information for an enum attribute.
 class EnumAttrInfo<string name, list<EnumAttrCaseInfo> cases> {
   // The C++ enum class name
   string className = name;
 
   // List of all accepted cases
class EnumAttrInfo<string name, list<EnumAttrCaseInfo> cases> {
 
   // The name of the utility function that converts a symbol to the
   // corresponding string. It will have the following signature:
   //
   // ```c++
   // <return-type> <fn-name>(<qualified-enum-class-name>);
   // ```
   string symbolToStringFnName = "stringify" # name;
-  string symbolToStringFnRetType = "llvm::StringRef";
+  string symbolToStringFnRetType = "::mlir::StringRef";
 
   // The name of the utility function that returns the max enum value used
   // within the enum class. It will have the following signature:
   //
   // ```c++
   // static constexpr unsigned <fn-name>();
   // ```
   string maxEnumValFnName = "getMaxEnumValFor" # name;

 // helper methods are generated to parse a string separated with a specified
 // delimiter to a symbol and vice versa.
 class BitEnumAttr<string name, string description,
                   list<BitEnumAttrCase> cases> :
     EnumAttrInfo<name, cases>, SignlessIntegerAttrBase<I32, description> {
   let predicate = And<[
     I32Attr.predicate,
     // Make sure we don't have unknown bit set.
-    CPred<"!($_self.cast<IntegerAttr>().getValue().getZExtValue() & (~(" #
-          StrJoin<!foreach(case, cases, case.value # "u"), "|">.result #
+    CPred<"!($_self.cast<::mlir::IntegerAttr>().getValue().getZExtValue() & (~("
+          # StrJoin<!foreach(case, cases, case.value # "u"), "|">.result #
           ")))">
   ]>;
 
   let returnType = cppNamespace # "::" # name;
   let underlyingType = "uint32_t";
   let convertFromStorage = "static_cast<" # returnType # ">($_self.getInt())";
   let constBuilderCall = "$_builder.getI32IntegerAttr(static_cast<int32_t>($0))";
 
   // We need to return a string because we may concatenate symbols for multiple
   // bits together.
   let symbolToStringFnRetType = "std::string";
 
   // The delimiter used to separate bit enum cases in strings.
   string separator = "|";
 }
 
 //===----------------------------------------------------------------------===//
 // Composite attribute kinds
 
 class DictionaryAttrBase<Pred condition, string description> :
     Attr<condition, description> {
-  let storageType = [{ DictionaryAttr }];
-  let returnType = [{ DictionaryAttr }];
+  let storageType = [{ ::mlir::DictionaryAttr }];
+  let returnType = [{ ::mlir::DictionaryAttr }];
   let valueType = NoneType;
   let convertFromStorage = "$_self";
 }
 
-def DictionaryAttr : DictionaryAttrBase<CPred<"$_self.isa<DictionaryAttr>()">,
-                                        "dictionary of named attribute values">;
+def DictionaryAttr 
+    : DictionaryAttrBase<CPred<"$_self.isa<::mlir::DictionaryAttr>()">,
 
 class ElementsAttrBase<Pred condition, string description> :
     Attr<condition, description> {
-  let storageType = [{ ElementsAttr }];
-  let returnType = [{ ElementsAttr }];
+  let storageType = [{ ::mlir::ElementsAttr }];
+  let returnType = [{ ::mlir::ElementsAttr }];
   let convertFromStorage = "$_self";
 }
 
-def ElementsAttr : ElementsAttrBase<CPred<"$_self.isa<ElementsAttr>()">,
+def ElementsAttr : ElementsAttrBase<CPred<"$_self.isa<::mlir::ElementsAttr>()">,
                                     "constant vector/tensor attribute">;
 
 class IntElementsAttrBase<Pred condition, string description> :
-    ElementsAttrBase<And<[CPred<"$_self.isa<DenseIntElementsAttr>()">,
+    ElementsAttrBase<And<[CPred<"$_self.isa<::mlir::DenseIntElementsAttr>()">,
                           condition]>,
                      description> {
-  let storageType = [{ DenseIntElementsAttr }];
-  let returnType = [{ DenseIntElementsAttr }];
+  let storageType = [{ ::mlir::DenseIntElementsAttr }];
+  let returnType = [{ ::mlir::DenseIntElementsAttr }];
 
   let convertFromStorage = "$_self";
 }
 
 def IndexElementsAttr
-    : IntElementsAttrBase<CPred<[{$_self.cast<DenseIntElementsAttr>()
+    : IntElementsAttrBase<CPred<[{$_self.cast<::mlir::DenseIntElementsAttr>()
                                       .getType()
                                       .getElementType()
                                       .isIndex()}]>,
                           "index elements attribute">;
 
 class AnyIntElementsAttr<int width> : IntElementsAttrBase<
-  CPred<"$_self.cast<DenseIntElementsAttr>().getType()."
+  CPred<"$_self.cast<::mlir::DenseIntElementsAttr>().getType()."
         "getElementType().isInteger(" # width # ")">,
   width # "-bit integer elements attribute">;
 
 def AnyI32ElementsAttr : AnyIntElementsAttr<32>;
 def AnyI64ElementsAttr : AnyIntElementsAttr<64>;
 
 class SignlessIntElementsAttr<int width> : IntElementsAttrBase<
-  CPred<"$_self.cast<DenseIntElementsAttr>().getType()."
+  CPred<"$_self.cast<::mlir::DenseIntElementsAttr>().getType()."
         "getElementType().isSignlessInteger(" # width # ")">,
   width # "-bit signless integer elements attribute"> {
 
   // Note that this is only constructing scalar elements attribute.
-  let constBuilderCall = "DenseElementsAttr::get("
-    "RankedTensorType::get({}, $_builder.getIntegerType(" # width # ")), "
-    "llvm::makeArrayRef($0)).cast<DenseIntElementsAttr>()";
+  let constBuilderCall = "::mlir::DenseElementsAttr::get("
+    "::mlir::RankedTensorType::get({}, "
+                                  "$_builder.getIntegerType(" # width # ")), "
+    "::llvm::makeArrayRef($0)).cast<::mlir::DenseIntElementsAttr>()";
 }
 
 def I32ElementsAttr : SignlessIntElementsAttr<32>;
 def I64ElementsAttr : SignlessIntElementsAttr<64>;
 
 // A `width`-bit signless integer elements attribute. The attribute should be
 // ranked and has a shape as specified in `dims`.
 class RankedSignlessIntElementsAttr<int width, list<int> dims> :
     SignlessIntElementsAttr<width> {
   // Check that this has the specified shape.
   let predicate = And<[
     SignlessIntElementsAttr<width>.predicate,
-    CPred<"$_self.cast<DenseIntElementsAttr>().getType().getShape() == "
-        "ArrayRef<int64_t>({" # StrJoinInt<dims>.result # "})">]>;
+    CPred<"$_self.cast<::mlir::DenseIntElementsAttr>().getType().getShape() == "
+        "::mlir::ArrayRef<int64_t>({" # StrJoinInt<dims>.result # "})">]>;
 
   let description = width # "-bit signless int elements attribute of shape [" #
                     StrJoinInt<dims>.result # "]";
 
-  let constBuilderCall = "DenseIntElementsAttr::get("
-    "RankedTensorType::get({" # StrJoinInt<dims>.result #
-    "}, $_builder.getIntegerType(" # width # ")), makeArrayRef($0))";
+  let constBuilderCall = "::mlir::DenseIntElementsAttr::get("
+    "::mlir::RankedTensorType::get({" # StrJoinInt<dims>.result #
+    "}, $_builder.getIntegerType(" # width # ")), ::llvm::makeArrayRef($0))";
 }
 
 class RankedI32ElementsAttr<list<int> dims> :
     RankedSignlessIntElementsAttr<32, dims>;
 class RankedI64ElementsAttr<list<int> dims> :
     RankedSignlessIntElementsAttr<64, dims>;
 
 class FloatElementsAttr<int width> : ElementsAttrBase<
-  CPred<"$_self.isa<DenseFPElementsAttr>() &&"
-      "$_self.cast<DenseElementsAttr>().getType()."
+  CPred<"$_self.isa<::mlir::DenseFPElementsAttr>() &&"
+      "$_self.cast<::mlir::DenseElementsAttr>().getType()."
       "getElementType().isF" # width # "()">,
   width # "-bit float elements attribute"> {
 
-  let storageType = [{ DenseElementsAttr }];
-  let returnType = [{ DenseElementsAttr }];
+  let storageType = [{ ::mlir::DenseElementsAttr }];
+  let returnType = [{ ::mlir::DenseElementsAttr }];
 
   // Note that this is only constructing scalar elements attribute.
-  let constBuilderCall = "DenseElementsAttr::get("
-    "RankedTensorType::get({}, $_builder.getF" # width # "Type()),"
-    "llvm::makeArrayRef($0))";
+  let constBuilderCall = "::mlir::DenseElementsAttr::get("
+    "::mlir::RankedTensorType::get({}, $_builder.getF" # width # "Type()),"
+    "::llvm::makeArrayRef($0))";
   let convertFromStorage = "$_self";
 }
 
 def F64ElementsAttr : FloatElementsAttr<64>;
 
 // A `width`-bit floating point elements attribute. The attribute should be
 // ranked and has a shape as specified in `dims`.
 class RankedFloatElementsAttr<int width, list<int> dims> : ElementsAttrBase<
-  CPred<"$_self.isa<DenseFPElementsAttr>() &&"
-      "$_self.cast<DenseFPElementsAttr>().getType()."
+  CPred<"$_self.isa<::mlir::DenseFPElementsAttr>() &&"
+      "$_self.cast<::mlir::DenseFPElementsAttr>().getType()."
       "getElementType().isF" # width # "() && "
       // Check that this is ranked and has the specified shape.
-      "$_self.cast<DenseFPElementsAttr>().getType().hasRank() && "
-      "$_self.cast<DenseFPElementsAttr>().getType().getShape() == "
-      "llvm::ArrayRef<int64_t>({" # StrJoinInt<dims>.result # "})">,
+      "$_self.cast<::mlir::DenseFPElementsAttr>().getType().hasRank() && "
+      "$_self.cast<::mlir::DenseFPElementsAttr>().getType().getShape() == "
+      "::mlir::ArrayRef<int64_t>({" # StrJoinInt<dims>.result # "})">,
   width # "-bit float elements attribute of shape [" #
   StrJoinInt<dims>.result # "]"> {
 
-  let storageType = [{ DenseFPElementsAttr }];
-  let returnType = [{ DenseFPElementsAttr }];
+  let storageType = [{ ::mlir::DenseFPElementsAttr }];
+  let returnType = [{ ::mlir::DenseFPElementsAttr }];
 
-  let constBuilderCall = "DenseElementsAttr::get("
-    "RankedTensorType::get({" # StrJoinInt<dims>.result #
+  let constBuilderCall = "::mlir::DenseElementsAttr::get("
+    "::mlir::RankedTensorType::get({" # StrJoinInt<dims>.result #
     "}, $_builder.getF" # width # "Type()), "
-    "llvm::makeArrayRef($0)).cast<DenseFPElementsAttr>()";
+    "::llvm::makeArrayRef($0)).cast<::mlir::DenseFPElementsAttr>()";
   let convertFromStorage = "$_self";
 }
 
 class RankedF32ElementsAttr<list<int> dims> : RankedFloatElementsAttr<32, dims>;
 class RankedF64ElementsAttr<list<int> dims> : RankedFloatElementsAttr<64, dims>;
 
 def StringElementsAttr : ElementsAttrBase<
-  CPred<"$_self.isa<DenseStringElementsAttr>()" >,
+  CPred<"$_self.isa<::mlir::DenseStringElementsAttr>()" >,
   "string elements attribute"> {
 
-  let storageType = [{ DenseElementsAttr }];
-  let returnType = [{ DenseElementsAttr }];
+  let storageType = [{ ::mlir::DenseElementsAttr }];
+  let returnType = [{ ::mlir::DenseElementsAttr }];
 
   let convertFromStorage = "$_self";
 }
 
 // Base class for array attributes.
 class ArrayAttrBase<Pred condition, string description> :
     Attr<condition, description> {
-  let storageType = [{ ArrayAttr }];
-  let returnType = [{ ArrayAttr }];
+  let storageType = [{ ::mlir::ArrayAttr }];
+  let returnType = [{ ::mlir::ArrayAttr }];
   let valueType = NoneType;
   let convertFromStorage = "$_self";
 }
 
-def ArrayAttr : ArrayAttrBase<CPred<"$_self.isa<ArrayAttr>()">,
+def ArrayAttr : ArrayAttrBase<CPred<"$_self.isa<::mlir::ArrayAttr>()">,
                               "array attribute">;
 
 // Base class for array attributes whose elements are of the same kind.
 // `element` specifies the element attribute kind stored in this array.
 class TypedArrayAttrBase<Attr element, string description>: ArrayAttrBase<
     And<[
       // Guarantee this is an ArrayAttr first
-      CPred<"$_self.isa<ArrayAttr>()">,
+      CPred<"$_self.isa<::mlir::ArrayAttr>()">,
       // Guarantee all elements satisfy the constraints from `element`
-      Concat<"llvm::all_of($_self.cast<ArrayAttr>(), "
-                          "[](Attribute attr) { return ",
+      Concat<"::llvm::all_of($_self.cast<::mlir::ArrayAttr>(), "
+                            "[](::mlir::Attribute attr) { return ",
                                SubstLeaves<"$_self", "attr", element.predicate>,
                             "; })">]>,
     description> {
   let constBuilderCall = "$_builder.getArrayAttr($0)";
 
   Attr elementAttr = element;
 }
 
 def BoolArrayAttr : TypedArrayAttrBase<BoolAttr,
                                       "1-bit boolean array attribute"> {
class StructAttr<string name, Dialect dialect,
   // The dialect this StructAttr belongs to.
   Dialect structDialect = dialect;
 
   // List of fields that the StructAttr contains.
   list<StructFieldAttr> fields = attributes;
 }
 
 // Attributes containing symbol references.
-def SymbolRefAttr : Attr<CPred<"$_self.isa<SymbolRefAttr>()">,
+def SymbolRefAttr : Attr<CPred<"$_self.isa<::mlir::SymbolRefAttr>()">,
                         "symbol reference attribute"> {
-  let storageType = [{ SymbolRefAttr }];
-  let returnType = [{ SymbolRefAttr }];
+  let storageType = [{ ::mlir::SymbolRefAttr }];
+  let returnType = [{ ::mlir::SymbolRefAttr }];
   let valueType = NoneType;
   let constBuilderCall = "$_builder.getSymbolRefAttr($0)";
   let convertFromStorage = "$_self";
 }
-def FlatSymbolRefAttr : Attr<CPred<"$_self.isa<FlatSymbolRefAttr>()">,
+def FlatSymbolRefAttr : Attr<CPred<"$_self.isa<::mlir::FlatSymbolRefAttr>()">,
                                    "flat symbol reference attribute"> {
-  let storageType = [{ FlatSymbolRefAttr }];
-  let returnType = [{ StringRef }];
+  let storageType = [{ ::mlir::FlatSymbolRefAttr }];
+  let returnType = [{ ::mlir::StringRef }];
   let valueType = NoneType;
   let constBuilderCall = "$_builder.getSymbolRefAttr($0)";
   let convertFromStorage = "$_self.getValue()";
 }
 
 def SymbolRefArrayAttr :
   TypedArrayAttrBase<SymbolRefAttr, "symbol ref array attribute"> {
   let constBuilderCall = ?;
class DerivedAttr<code ret, code b, code convert = ""> :
   // * `$_ctx` will be replaced by the MLIRContext* instance.
   // * `$_self` will be replaced with the derived attribute (value produces
   //    `returnType`).
   let convertFromStorage = convert;
 }
 
 // Derived attribute that returns a mlir::Type.
 class DerivedTypeAttr<code body> : DerivedAttr<"Type", body> {
-  let convertFromStorage = "TypeAttr::get($_self)";
+  let convertFromStorage = "::mlir::TypeAttr::get($_self)";
 }
 
 //===----------------------------------------------------------------------===//
 // Constant attribute kinds
 
 // Represents a constant attribute of specific Attr type. A constant
 // attribute can be specified only of attributes that have a constant
 // builder call defined. The constant value is specified as a string.

 class AllAttrConstraintsOf<list<AttrConstraint> constraints> : AttrConstraint<
     And<!listconcat([!head(constraints).predicate],
                       !foreach(pred, !tail(constraints), pred.predicate))>,
     !foldl(/*init*/!head(constraints).description, /*list*/!tail(constraints),
            prev, cur, prev # " and " # cur.description)> {
 }
 
 class IntMinValue<int n> : AttrConstraint<
-    CPred<"$_self.cast<IntegerAttr>().getInt() >= " # n>,
+    CPred<"$_self.cast<::mlir::IntegerAttr>().getInt() >= " # n>,
     "whose minimum value is " # n>;
 
 class IntMaxValue<int n> : AttrConstraint<
-    CPred<"$_self.cast<IntegerAttr>().getInt() <= " # n>,
+    CPred<"$_self.cast<::mlir::IntegerAttr>().getInt() <= " # n>,
     "whose maximum value is " # n>;
 
 def IntNonNegative : AttrConstraint<
-    CPred<"!$_self.cast<IntegerAttr>().getValue().isNegative()">,
+    CPred<"!$_self.cast<::mlir::IntegerAttr>().getValue().isNegative()">,
     "whose value is non-negative">;
 
 def IntPositive : AttrConstraint<
     CPred<"$_self.cast<IntegerAttr>().getValue().isStrictlyPositive()">,
     "whose value is positive">;
 
 class ArrayMinCount<int n> : AttrConstraint<
-    CPred<"$_self.cast<ArrayAttr>().size() >= " # n>,
+    CPred<"$_self.cast<::mlir::ArrayAttr>().size() >= " # n>,
     "with at least " # n # " elements">;
 
 class ArrayCount<int n> : AttrConstraint<
-    CPred<"$_self.cast<ArrayAttr>().size() == " #n>,
+    CPred<"$_self.cast<::mlir::ArrayAttr>().size() == " #n>,
     "with exactly " # n # " elements">;
 
 class IntArrayNthElemEq<int index, int value> : AttrConstraint<
     And<[
-      CPred<"$_self.cast<ArrayAttr>().size() > " # index>,
-      CPred<"$_self.cast<ArrayAttr>()[" # index # "]"
-        ".cast<IntegerAttr>().getInt() == " # value>
+      CPred<"$_self.cast<::mlir::ArrayAttr>().size() > " # index>,
+      CPred<"$_self.cast<::mlir::ArrayAttr>()[" # index # "]"
+        ".cast<::mlir::IntegerAttr>().getInt() == " # value>
        ]>,
     "whose " # index # "-th element must be " # value>;
 
 class IntArrayNthElemMinValue<int index, int min> : AttrConstraint<
     And<[
-      CPred<"$_self.cast<ArrayAttr>().size() > " # index>,
-      CPred<"$_self.cast<ArrayAttr>()[" # index # "]"
-        ".cast<IntegerAttr>().getInt() >= " # min>
+      CPred<"$_self.cast<::mlir::ArrayAttr>().size() > " # index>,
+      CPred<"$_self.cast<::mlir::ArrayAttr>()[" # index # "]"
+        ".cast<::mlir::IntegerAttr>().getInt() >= " # min>
         ]>,
     "whose " # index # "-th element must be at least " # min>;
 
 def IsNullAttr : AttrConstraint<
     CPred<"!$_self">, "empty attribute (for optional attributes)">;
 
 // An attribute constraint on FlatSymbolRefAttr that requires that the
 // reference point to an op of `opClass` within the closest parent with a symbol
 // table.
 // TODO(riverriddle) Add support for nested symbol references.
 class ReferToOp<string opClass> : AttrConstraint<
     CPred<"isa_and_nonnull<" # opClass # ">("
             "::mlir::SymbolTable::lookupNearestSymbolFrom("
-              "&$_op, $_self.cast<FlatSymbolRefAttr>().getValue()))">,
+              "&$_op, $_self.cast<::mlir::FlatSymbolRefAttr>().getValue()))">,
     "referencing to a '" # opClass # "' symbol">;
 
 //===----------------------------------------------------------------------===//
 // Region definitions
 //===----------------------------------------------------------------------===//
 
 class Region<Pred condition, string descr = ""> :
     RegionConstraint<condition, descr>;
 
 // Any region.
 def AnyRegion : Region<CPred<"true">, "any region">;
 
 // A region with the given number of blocks.
 class SizedRegion<int numBlocks> : Region<
-  CPred<"llvm::hasNItems($_self, " # numBlocks # ")">,
+  CPred<"::llvm::hasNItems($_self, " # numBlocks # ")">,
   "region with " # numBlocks # " blocks">;
 
 // A variadic region constraint. It expands to zero or more of the base region.
 class VariadicRegion<Region region>
   : Region<region.predicate, region.description>;
 
 //===----------------------------------------------------------------------===//
 // Successor definitions

 // multiple arguments or results. For verifying properties of a single argument
 // or result, prefer operand type constraints.
 
 // These traits often require including "mlir/IR/TypeUtilities.h".
 
 // TODO(b/135033717): Improve the autogenerated error messages.
 
 class Rank<string name> :
-    StrFunc<"$" # name # ".getType().cast<ShapedType>().getRank()">;
+    StrFunc<"$" # name # ".getType().cast<::mlir::ShapedType>().getRank()">;
 
 class Shape<string name> :
-    StrFunc<"$" # name # ".getType().cast<ShapedType>().getShape()">;
+    StrFunc<"$" # name # ".getType().cast<::mlir::ShapedType>().getShape()">;
 
 class ElementCount<string name> :
-  StrFunc<"$" # name # ".getType().cast<ShapedType>().getNumElements()">;
+  StrFunc<"$" # name # ".getType().cast<::mlir::ShapedType>()"
+                                 ".getNumElements()">;
 
 class ElementType<string name> : StrFunc<"getElementTypeOrSelf($" # name # ")">;
 
 class AllMatchPred<list<string> values> :
-    CPred<"llvm::is_splat(llvm::makeArrayRef({"# StrJoin<values>.result #"}))">;
+    CPred<"::llvm::is_splat(::llvm::makeArrayRef({"
+          # StrJoin<values>.result #"}))">;
 
 class AllMatch<list<string> values, string description> :
     PredOpTrait<description, AllMatchPred<values>>;
 
 // TODO(b/135032064): Only works for non-variadic.
 class AllMatchSameOperatorPred<list<string> names, string operator> :
     AllMatchPred<!foreach(n, names, !subst("$_self", "$" # n, operator))>;
 

 // Type Constraint operand `i`'s Element type is Same As operand `j`'s Element
 // type.
 class TCopVTEtIsSameAs<int i, int j> : And<[
     CPred<"$_op.getNumOperands() > " # !if(!gt(i,j),i,j)>,
     SubstLeaves<"$_self", "$_op.getOperand(" # i # ").getType()",
       IsShapedTypePred>,
     SubstLeaves<"$_self", "$_op.getOperand(" # j # ").getType()",
       IsShapedTypePred>,
-    CPred<"mlir::getElementTypeOrSelf($_op.getOperand(" # i # ")) == "
-          "mlir::getElementTypeOrSelf($_op.getOperand(" # j # "))">]>;
+    CPred<"::mlir::getElementTypeOrSelf($_op.getOperand(" # i # ")) == "
+          "::mlir::getElementTypeOrSelf($_op.getOperand(" # j # "))">]>;
 
 // Predicate to verify that the i'th result and the j'th operand exist and has
 // shaped types.
 class TCOpResIsShapedTypePred<int i, int j> : And<[
     CPred<"$_op.getNumResults() > " # i>,
     CPred<"$_op.getNumOperands() > " # j>,
     SubstLeaves<"$_self", "$_op.getResult(" # i # ").getType()",
       IsShapedTypePred>,

 class TCresVTEtIsSameAsOp<int i, int j> : And<[
     TCOpResIsShapedTypePred<i, j>,
     TCresVTEtIsSameAsOpBase<i, j>]>;
 
 // Predicate to verify that the opId'th operand can be broadcasted to the type
 // of the resId'th result.
 class TCOpIsBroadcastableToRes<int opId, int resId> : And<[
     TCOpResIsShapedTypePred<opId, resId>,
-    CPred<"OpTrait::util::getBroadcastedType("
+    CPred<"::mlir::OpTrait::util::getBroadcastedType("
                   "$_op.getOperand(" # opId # ").getType(), "
                   "$_op.getResult(" # resId # ").getType())">]>;
 
 // Predicate to verify that all the operands at the given `indices`
 // have the same element type.
 // Type Constraint operands' Element type are all Same At the given `indices`.
 // We query the operands' types into a list and check they are all the same.
 // Precondition:
 // 1) all operands involved are of shaped type and
 // 2) the indices are not out of range.
 class TCopVTEtAreSameAt<list<int> indices> : CPred<
-  "llvm::is_splat(llvm::map_range("
-    "llvm::ArrayRef<unsigned>({" # StrJoinInt<indices>.result # "}), "
+  "::llvm::is_splat(::llvm::map_range("
+      "::mlir::ArrayRef<unsigned>({" # StrJoinInt<indices>.result # "}), "
       "[this](unsigned i) { return getElementTypeOrSelf(this->getOperand(i)); "
       "}))">;
 
 //===----------------------------------------------------------------------===//
 // Pattern definitions
 //===----------------------------------------------------------------------===//
 
 // Marker used to identify the delta value added to the default benefit value.
 def addBenefit;
 

mlir/lib/TableGen/OpClass.cpp

 
 void tblgen::OpClass::addTrait(Twine trait) {
   auto traitStr = trait.str();
   if (traitsSet.insert(traitStr).second)
     traitsVec.push_back(std::move(traitStr));
 }
 
 void tblgen::OpClass::writeDeclTo(raw_ostream &os) const {
-  os << "class " << className << " : public Op<" << className;
+  os << "class " << className << " : public ::mlir::Op<" << className;
   for (const auto &trait : traitsVec)
     os << ", " << trait;
   os << "> {\npublic:\n";
   os << "  using Op::Op;\n";
   os << "  using Adaptor = " << className << "Adaptor;\n";
 
   bool hasPrivateMethod = false;
   for (const auto &method : methods) {

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

def AOp : NS_Op<"a_op", []> {
   );
 }
 
 // DEF-LABEL: AOp definitions
 
 // Test verify method
 // ---
 
-// DEF:      LogicalResult AOpAdaptor::verify
+// DEF:      ::mlir::LogicalResult AOpAdaptor::verify
 // DEF:      auto tblgen_aAttr = odsAttrs.get("aAttr");
 // DEF-NEXT: if (!tblgen_aAttr) return emitError(loc, "'test.a_op' op ""requires attribute 'aAttr'");
 // DEF:        if (!((some-condition))) return emitError(loc, "'test.a_op' op ""attribute 'aAttr' failed to satisfy constraint: some attribute kind");
 // DEF:      auto tblgen_bAttr = odsAttrs.get("bAttr");
 // DEF-NEXT: if (tblgen_bAttr) {
 // DEF-NEXT:   if (!((some-condition))) return emitError(loc, "'test.a_op' op ""attribute 'bAttr' failed to satisfy constraint: some attribute kind");
 // DEF:      auto tblgen_cAttr = odsAttrs.get("cAttr");
 // DEF-NEXT: if (tblgen_cAttr) {
 // DEF-NEXT:   if (!((some-condition))) return emitError(loc, "'test.a_op' op ""attribute 'cAttr' failed to satisfy constraint: some attribute kind");
 
 // Test getter methods
 // ---
 
 // DEF:      some-attr-kind AOp::aAttrAttr()
 // DEF-NEXT:   this->getAttr("aAttr").cast<some-attr-kind>()
 // DEF:      some-return-type AOp::aAttr() {
 // DEF-NEXT:   auto attr = aAttrAttr()
 // DEF-NEXT:   return attr.some-convert-from-storage();
 
 // DEF:      some-attr-kind AOp::bAttrAttr()
 // DEF-NEXT:   return this->getAttr("bAttr").dyn_cast_or_null<some-attr-kind>()
 // DEF:      some-return-type AOp::bAttr() {
 // DEF-NEXT:   auto attr = bAttrAttr();
 // DEF-NEXT:   if (!attr)
-// DEF-NEXT:       return some-const-builder-call(mlir::Builder(this->getContext()), 4.2).some-convert-from-storage();
+// DEF-NEXT:       return some-const-builder-call(::mlir::Builder(this->getContext()), 4.2).some-convert-from-storage();
 // DEF-NEXT:   return attr.some-convert-from-storage();
 
 // DEF:      some-attr-kind AOp::cAttrAttr()
 // DEF-NEXT:   return this->getAttr("cAttr").dyn_cast_or_null<some-attr-kind>()
-// DEF:      Optional<some-return-type> AOp::cAttr() {
+// DEF:      ::mlir::Optional<some-return-type> AOp::cAttr() {
 // DEF-NEXT:   auto attr = cAttrAttr()
-// DEF-NEXT:   return attr ? Optional<some-return-type>(attr.some-convert-from-storage()) : (llvm::None);
+// DEF-NEXT:   return attr ? ::mlir::Optional<some-return-type>(attr.some-convert-from-storage()) : (::llvm::None);
 
 // Test setter methods
 // ---
 
 // DEF:      void AOp::aAttrAttr(some-attr-kind attr) {
 // DEF-NEXT:   this->getOperation()->setAttr("aAttr", attr);
 // DEF:      void AOp::bAttrAttr(some-attr-kind attr) {
 // DEF-NEXT:   this->getOperation()->setAttr("bAttr", attr);

 // DEF:        if (cAttr) {
 // DEF-NEXT:     odsState.addAttribute("cAttr", cAttr);
 
 // DEF:      void AOp::build(
 // DEF:        some-return-type aAttr, some-return-type bAttr, /*optional*/some-attr-kind cAttr
 // DEF:        odsState.addAttribute("aAttr", some-const-builder-call(odsBuilder, aAttr));
 
 // DEF:      void AOp::build(
-// DEF:        ArrayRef<NamedAttribute> attributes
+// DEF:        ::mlir::ArrayRef<::mlir::NamedAttribute> attributes
 // DEF:      odsState.addAttributes(attributes);
 
 def SomeTypeAttr : TypeAttrBase<"SomeType", "some type attribute">;
 
 def BOp : NS_Op<"b_op", []> {
   let arguments = (ins
     AnyAttr:$any_attr,
     BoolAttr:$bool_attr,

 }
 
 
 // Test common attribute kinds' constraints
 // ---
 
 // DEF-LABEL: BOpAdaptor::verify
 // DEF: if (!((true)))
-// DEF: if (!((tblgen_bool_attr.isa<BoolAttr>())))
-// DEF: if (!(((tblgen_i32_attr.isa<IntegerAttr>())) && ((tblgen_i32_attr.cast<IntegerAttr>().getType().isSignlessInteger(32)))))
-// DEF: if (!(((tblgen_i64_attr.isa<IntegerAttr>())) && ((tblgen_i64_attr.cast<IntegerAttr>().getType().isSignlessInteger(64)))))
-// DEF: if (!(((tblgen_f32_attr.isa<FloatAttr>())) && ((tblgen_f32_attr.cast<FloatAttr>().getType().isF32()))))
-// DEF: if (!(((tblgen_f64_attr.isa<FloatAttr>())) && ((tblgen_f64_attr.cast<FloatAttr>().getType().isF64()))))
-// DEF: if (!((tblgen_str_attr.isa<StringAttr>())))
-// DEF: if (!((tblgen_elements_attr.isa<ElementsAttr>())))
-// DEF: if (!((tblgen_function_attr.isa<FlatSymbolRefAttr>())))
-// DEF: if (!(((tblgen_type_attr.isa<TypeAttr>())) && ((tblgen_type_attr.cast<TypeAttr>().getValue().isa<SomeType>()))))
-// DEF: if (!((tblgen_array_attr.isa<ArrayAttr>())))
-// DEF: if (!(((tblgen_some_attr_array.isa<ArrayAttr>())) && (llvm::all_of(tblgen_some_attr_array.cast<ArrayAttr>(), [](Attribute attr) { return (some-condition); }))))
-// DEF: if (!(((tblgen_type_attr.isa<TypeAttr>())) && ((tblgen_type_attr.cast<TypeAttr>().getValue().isa<Type>()))))
+// DEF: if (!((tblgen_bool_attr.isa<::mlir::BoolAttr>())))
+// DEF: if (!(((tblgen_i32_attr.isa<::mlir::IntegerAttr>())) && ((tblgen_i32_attr.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(32)))))
+// DEF: if (!(((tblgen_i64_attr.isa<::mlir::IntegerAttr>())) && ((tblgen_i64_attr.cast<::mlir::IntegerAttr>().getType().isSignlessInteger(64)))))
+// DEF: if (!(((tblgen_f32_attr.isa<::mlir::FloatAttr>())) && ((tblgen_f32_attr.cast<::mlir::FloatAttr>().getType().isF32()))))
+// DEF: if (!(((tblgen_f64_attr.isa<::mlir::FloatAttr>())) && ((tblgen_f64_attr.cast<::mlir::FloatAttr>().getType().isF64()))))
+// DEF: if (!((tblgen_str_attr.isa<::mlir::StringAttr>())))
+// DEF: if (!((tblgen_elements_attr.isa<::mlir::ElementsAttr>())))
+// DEF: if (!((tblgen_function_attr.isa<::mlir::FlatSymbolRefAttr>())))
+// DEF: if (!(((tblgen_type_attr.isa<::mlir::TypeAttr>())) && ((tblgen_type_attr.cast<::mlir::TypeAttr>().getValue().isa<SomeType>()))))
+// DEF: if (!((tblgen_array_attr.isa<::mlir::ArrayAttr>())))
+// DEF: if (!(((tblgen_some_attr_array.isa<::mlir::ArrayAttr>())) && (::llvm::all_of(tblgen_some_attr_array.cast<::mlir::ArrayAttr>(), [](::mlir::Attribute attr) { return (some-condition); }))))
+// DEF: if (!(((tblgen_type_attr.isa<::mlir::TypeAttr>())) && ((tblgen_type_attr.cast<::mlir::TypeAttr>().getValue().isa<::mlir::Type>()))))
 
 // Test common attribute kind getters' return types
 // ---
 
-// DEF: Attribute BOp::any_attr()
+// DEF: ::mlir::Attribute BOp::any_attr()
 // DEF: bool BOp::bool_attr()
-// DEF: APInt BOp::i32_attr()
-// DEF: APInt BOp::i64_attr()
-// DEF: APFloat BOp::f32_attr()
-// DEF: APFloat BOp::f64_attr()
-// DEF: StringRef BOp::str_attr()
-// DEF: ElementsAttr BOp::elements_attr()
-// DEF: StringRef BOp::function_attr()
+// DEF: ::mlir::APInt BOp::i32_attr()
+// DEF: ::mlir::APInt BOp::i64_attr()
+// DEF: ::mlir::APFloat BOp::f32_attr()
+// DEF: ::mlir::APFloat BOp::f64_attr()
+// DEF: ::mlir::StringRef BOp::str_attr()
+// DEF: ::mlir::ElementsAttr BOp::elements_attr()
+// DEF: ::mlir::StringRef BOp::function_attr()
 // DEF: SomeType BOp::type_attr()
-// DEF: ArrayAttr BOp::array_attr()
-// DEF: ArrayAttr BOp::some_attr_array()
-// DEF: Type BOp::type_attr()
+// DEF: ::mlir::ArrayAttr BOp::array_attr()
+// DEF: ::mlir::ArrayAttr BOp::some_attr_array()
+// DEF: ::mlir::Type BOp::type_attr()
 
 // Test building constant values for array attribute kinds
 // ---
 
 def COp : NS_Op<"c_op", []> {
   let arguments = (ins
     DefaultValuedAttr<I32ArrayAttr, "{1, 2}">:$i32_array_attr,
     DefaultValuedAttr<I64ArrayAttr, "{3, 4}">:$i64_array_attr,
     DefaultValuedAttr<F32ArrayAttr, "{5.f, 6.f}">:$f32_array_attr,
     DefaultValuedAttr<F64ArrayAttr, "{7., 8.}">:$f64_array_attr,
     DefaultValuedAttr<StrArrayAttr, "{\"a\", \"b\"}">:$str_array_attr
   );
 }
 
 // DEF-LABEL: COp definitions
-// DEF: mlir::Builder(this->getContext()).getI32ArrayAttr({1, 2})
-// DEF: mlir::Builder(this->getContext()).getI64ArrayAttr({3, 4})
-// DEF: mlir::Builder(this->getContext()).getF32ArrayAttr({5.f, 6.f})
-// DEF: mlir::Builder(this->getContext()).getF64ArrayAttr({7., 8.})
-// DEF: mlir::Builder(this->getContext()).getStrArrayAttr({"a", "b"})
+// DEF: ::mlir::Builder(this->getContext()).getI32ArrayAttr({1, 2})
+// DEF: ::mlir::Builder(this->getContext()).getI64ArrayAttr({3, 4})
+// DEF: ::mlir::Builder(this->getContext()).getF32ArrayAttr({5.f, 6.f})
+// DEF: ::mlir::Builder(this->getContext()).getF64ArrayAttr({7., 8.})
+// DEF: ::mlir::Builder(this->getContext()).getStrArrayAttr({"a", "b"})
 
 
 // Test builder method which takes unwrapped values for attributes
 // ---
 
 def I32Case5:  I32EnumAttrCase<"case5", 5>;
 def I32Case10: I32EnumAttrCase<"case10", 10>;
 
let arguments = (ins
     DefaultValuedAttr<F64Attr, "8.">:$dv_f64_attr,
     DefaultValuedAttr<StrAttr, "abc">:$dv_str_attr,
     DefaultValuedAttr<BoolAttr, "true">:$dv_bool_attr,
     DefaultValuedAttr<SomeI32Enum, "::SomeI32Enum::case5">:$dv_enum_attr
   );
 }
 
 // DECL-LABEL: DOp declarations
-// DECL: static void build({{.*}}, APInt i32_attr, APFloat f64_attr, StringRef str_attr, bool bool_attr, ::SomeI32Enum enum_attr, APInt dv_i32_attr, APFloat dv_f64_attr, StringRef dv_str_attr = "abc", bool dv_bool_attr = true, ::SomeI32Enum dv_enum_attr = ::SomeI32Enum::case5)
+// DECL: static void build({{.*}}, ::mlir::APInt i32_attr, ::mlir::APFloat f64_attr, ::mlir::StringRef str_attr, bool bool_attr, ::SomeI32Enum enum_attr, ::mlir::APInt dv_i32_attr, ::mlir::APFloat dv_f64_attr, ::mlir::StringRef dv_str_attr = "abc", bool dv_bool_attr = true, ::SomeI32Enum dv_enum_attr = ::SomeI32Enum::case5)
 
 // DEF-LABEL: DOp definitions
 // DEF: odsState.addAttribute("str_attr", odsBuilder.getStringAttr(str_attr));
 // DEF: odsState.addAttribute("dv_str_attr", odsBuilder.getStringAttr(dv_str_attr));
 
 // Test derived type attr.
 // ---
 def DerivedTypeAttrOp : NS_Op<"derived_type_attr_op", []> {
   let results = (outs AnyTensor:$output);
   DerivedTypeAttr element_dtype = DerivedTypeAttr<"return output().getType();">;
 }
 
-// DECL: class DerivedTypeAttrOp : public Op
+// DECL: class DerivedTypeAttrOp : public ::mlir::Op
 // DECL-SAME: DerivedAttributeOpInterface::Trait
 // DECL: static bool isDerivedAttribute
-// DEF: bool DerivedTypeAttrOp::isDerivedAttribute(StringRef name) {
+// DEF: bool DerivedTypeAttrOp::isDerivedAttribute(::mlir::StringRef name) {
 // DEF:   if (name == "element_dtype") return true;
 // DEF:   return false;
 // DEF: }
 // DEF: DerivedTypeAttrOp::materializeDerivedAttributes
 
 // Test that only default valued attributes at the end of the arguments
 // list get default values in the builder signature
 // ---
let arguments = (ins
     BoolAttr:$bool_attr,
     DefaultValuedAttr<BoolAttr, "true">:$dv_bool_attr,
     SomeI32Enum:$enum_attr,
     DefaultValuedAttr<SomeI32Enum, "::SomeI32Enum::case5">:$dv_enum_attr
   );
 }
 
 // DECL-LABEL: EOp declarations
-// DECL: static void build({{.*}}, APInt i32_attr, APInt dv_i32_attr, APFloat f64_attr, APFloat dv_f64_attr, StringRef str_attr, StringRef dv_str_attr, bool bool_attr, bool dv_bool_attr, ::SomeI32Enum enum_attr, ::SomeI32Enum dv_enum_attr = ::SomeI32Enum::case5)
+// DECL: static void build({{.*}}, ::mlir::APInt i32_attr, ::mlir::APInt dv_i32_attr, ::mlir::APFloat f64_attr, ::mlir::APFloat dv_f64_attr, ::mlir::StringRef str_attr, ::mlir::StringRef dv_str_attr, bool bool_attr, bool dv_bool_attr, ::SomeI32Enum enum_attr, ::SomeI32Enum dv_enum_attr = ::SomeI32Enum::case5)
 
 // Test mixing operands and attributes in arbitrary order
 // ---
 
 def MixOperandsAndAttrs : NS_Op<"mix_operands_and_attrs", []> {
   let arguments = (ins F32Attr:$attr, F32:$operand, F32Attr:$otherAttr, F32:$otherArg);
 }
 
 // DEF-LABEL: MixOperandsAndAttrs definitions
-// DEF-DAG: Value MixOperandsAndAttrs::operand()
-// DEF-DAG: Value MixOperandsAndAttrs::otherArg()
-// DEF-DAG: void MixOperandsAndAttrs::build(OpBuilder &odsBuilder, OperationState &odsState, FloatAttr attr, Value operand, FloatAttr otherAttr, Value otherArg)
-// DEF-DAG: APFloat MixOperandsAndAttrs::attr()
-// DEF-DAG: APFloat MixOperandsAndAttrs::otherAttr()
+// DEF-DAG: ::mlir::Value MixOperandsAndAttrs::operand()
+// DEF-DAG: ::mlir::Value MixOperandsAndAttrs::otherArg()
+// DEF-DAG: void MixOperandsAndAttrs::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::FloatAttr attr, ::mlir::Value operand, ::mlir::FloatAttr otherAttr, ::mlir::Value otherArg)
+// DEF-DAG: ::mlir::APFloat MixOperandsAndAttrs::attr()
+// DEF-DAG: ::mlir::APFloat MixOperandsAndAttrs::otherAttr()
 
 // Test unit attributes.
 // ---
 
 def UnitAttrOp : NS_Op<"unit_attr_op", []> {
   let arguments = (ins UnitAttr:$attr);
 }
 
 // DEF-LABEL: UnitAttrOp definitions
 // DEF: bool UnitAttrOp::attr() {
 // DEF:   return {{.*}} != nullptr
 
-// DEF: build(OpBuilder &odsBuilder, OperationState &odsState, /*optional*/UnitAttr attr)
+// DEF: build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::UnitAttr attr)
 
 
 // Test elementAttr field of TypedArrayAttr.
 // ---
 
 def SomeTypedArrayAttr : TypedArrayAttrBase<SomeAttr, "SomeAttr array">;
 
 // RECORD-LABEL: def SomeTypedArrayAttr
 // RECORD: Attr elementAttr = SomeAttr;

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

let extraClassDeclaration = [{
     void displayGraph();
   }];
 }
 
 // CHECK-LABEL: NS::AOp declarations
 
 // CHECK: class AOpAdaptor {
 // CHECK: public:
-// CHECK:   AOpAdaptor(ValueRange values
-// CHECK:   ValueRange getODSOperands(unsigned index);
-// CHECK:   Value a();
-// CHECK:   ValueRange b();
-// CHECK:   IntegerAttr attr1();
-// CHECL:   FloatAttr attr2();
+// CHECK:   AOpAdaptor(::mlir::ValueRange values
+// CHECK:   ::mlir::ValueRange getODSOperands(unsigned index);
+// CHECK:   ::mlir::Value a();
+// CHECK:   ::mlir::ValueRange b();
+// CHECK:   ::mlir::IntegerAttr attr1();
+// CHECL:   ::mlir::FloatAttr attr2();
 // CHECK: private:
-// CHECK:   ValueRange odsOperands;
+// CHECK:   ::mlir::ValueRange odsOperands;
 // CHECK: };
 
-// CHECK: class AOp : public Op<AOp, OpTrait::AtLeastNRegions<1>::Impl, OpTrait::AtLeastNResults<1>::Impl, OpTrait::ZeroSuccessor, OpTrait::AtLeastNOperands<1>::Impl, OpTrait::IsIsolatedFromAbove
+// 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: public:
 // CHECK:   using Op::Op;
 // CHECK:   using Adaptor = AOpAdaptor;
-// CHECK:   static StringRef getOperationName();
-// CHECK:   Operation::operand_range getODSOperands(unsigned index);
-// CHECK:   Value a();
-// CHECK:   Operation::operand_range b();
+// CHECK:   static ::mlir::StringRef getOperationName();
+// CHECK:   ::mlir::Operation::operand_range getODSOperands(unsigned index);
+// CHECK:   ::mlir::Value a();
+// CHECK:   ::mlir::Operation::operand_range b();
 // CHECK:   ::mlir::MutableOperandRange aMutable();
 // CHECK:   ::mlir::MutableOperandRange bMutable();
-// CHECK:   Operation::result_range getODSResults(unsigned index);
-// CHECK:   Value r();
-// CHECK:   Region &someRegion();
-// CHECK:   MutableArrayRef<Region> someRegions();
-// CHECK:   IntegerAttr attr1Attr()
-// CHECK:   APInt attr1();
-// CHECK:   FloatAttr attr2Attr()
-// CHECK:   Optional< APFloat > attr2();
+// CHECK:   ::mlir::Operation::result_range getODSResults(unsigned index);
+// CHECK:   ::mlir::Value r();
+// CHECK:   ::mlir::Region &someRegion();
+// CHECK:   ::mlir::MutableArrayRef<Region> someRegions();
+// CHECK:   ::mlir::IntegerAttr attr1Attr()
+// CHECK:   ::mlir::APInt attr1();
+// CHECK:   ::mlir::FloatAttr attr2Attr()
+// CHECK:   ::mlir::Optional< ::mlir::APFloat > attr2();
 // CHECK:   static void build(Value val);
-// CHECK:   static void build(OpBuilder &odsBuilder, OperationState &odsState, Type r, ArrayRef<Type> s, Value a, ValueRange b, IntegerAttr attr1, /*optional*/FloatAttr attr2, unsigned someRegionsCount)
-// CHECK:   static void build(OpBuilder &odsBuilder, OperationState &odsState, Type r, ArrayRef<Type> s, Value a, ValueRange b, APInt attr1, /*optional*/FloatAttr attr2, unsigned someRegionsCount)
-// CHECK:   static void build(OpBuilder &, OperationState &odsState, ArrayRef<Type> resultTypes, ValueRange operands, ArrayRef<NamedAttribute> attributes, unsigned numRegions)
-// CHECK:   static ParseResult parse(OpAsmParser &parser, OperationState &result);
-// CHECK:   void print(OpAsmPrinter &p);
-// CHECK:   LogicalResult verify();
-// CHECK:   static void getCanonicalizationPatterns(OwningRewritePatternList &results, MLIRContext *context);
-// CHECK:   LogicalResult fold(ArrayRef<Attribute> operands, SmallVectorImpl<OpFoldResult> &results);
+// CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::ArrayRef<::mlir::Type> s, ::mlir::Value a, ::mlir::ValueRange b, ::mlir::IntegerAttr attr1, /*optional*/::mlir::FloatAttr attr2, unsigned someRegionsCount)
+// CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type r, ::mlir::ArrayRef<::mlir::Type> s, ::mlir::Value a, ::mlir::ValueRange b, ::mlir::APInt attr1, /*optional*/::mlir::FloatAttr attr2, unsigned someRegionsCount)
+// CHECK:   static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands, ::mlir::ArrayRef<::mlir::NamedAttribute> attributes, unsigned numRegions)
+// CHECK:   static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);
+// CHECK:   void print(::mlir::OpAsmPrinter &p);
+// CHECK:   ::mlir::LogicalResult verify();
+// CHECK:   static void getCanonicalizationPatterns(::mlir::OwningRewritePatternList &results, ::mlir::MLIRContext *context);
+// CHECK:   ::mlir::LogicalResult fold(::mlir::ArrayRef<::mlir::Attribute> operands, ::mlir::SmallVectorImpl<::mlir::OpFoldResult> &results);
 // CHECK:   // Display a graph for debugging purposes.
 // CHECK:   void displayGraph();
 // CHECK: };
 
 // Check AttrSizedOperandSegments
 // ---
 
 def NS_AttrSizedOperandOp : NS_Op<"attr_sized_operands",
                                  [AttrSizedOperandSegments]> {
   let arguments = (ins
     Variadic<I32>:$a,
     Variadic<I32>:$b,
     I32:$c,
     Variadic<I32>:$d,
     I32ElementsAttr:$operand_segment_sizes
   );
 }
 
 // CHECK-LABEL: AttrSizedOperandOpAdaptor(
-// CHECK-SAME:    ValueRange values
-// CHECK-SAME:    DictionaryAttr attrs
-// CHECK:  ValueRange a();
-// CHECK:  ValueRange b();
-// CHECK:  Value c();
-// CHECK:  ValueRange d();
-// CHECK:  DenseIntElementsAttr operand_segment_sizes();
+// CHECK-SAME:    ::mlir::ValueRange values
+// CHECK-SAME:    ::mlir::DictionaryAttr attrs
+// CHECK:  ::mlir::ValueRange a();
+// CHECK:  ::mlir::ValueRange b();
+// CHECK:  ::mlir::Value c();
+// CHECK:  ::mlir::ValueRange d();
+// CHECK:  ::mlir::DenseIntElementsAttr operand_segment_sizes();
 
 // Check op trait for different number of operands
 // ---
 
 def NS_BOp : NS_Op<"op_with_no_operand", []> {
   let arguments = (ins);
 }
 

 // CHECK: OpTrait::NOperands<2>::Impl
 
 def NS_EOp : NS_Op<"op_with_optionals", []> {
   let arguments = (ins Optional<I32>:$a);
   let results = (outs Optional<F32>:$b);
 }
 
 // CHECK-LABEL: NS::EOp declarations
-// CHECK:   Value a();
+// CHECK:   ::mlir::Value a();
 // CHECK:   ::mlir::MutableOperandRange aMutable();
-// CHECK:   Value b();
-// CHECK:   static void build(OpBuilder &odsBuilder, OperationState &odsState, /*optional*/Type b, /*optional*/Value a)
+// CHECK:   ::mlir::Value b();
+// CHECK:   static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type b, /*optional*/::mlir::Value a)
 
 // Check that all types match constraint results in generating builder.
 // ---
 
 def NS_FOp : NS_Op<"op_with_all_types_constraint",
     [AllTypesMatch<["a", "b"]>]> {
   let arguments = (ins AnyType:$a);
   let results = (outs Res<AnyType, "output b", []>:$b);
 }
 
 // CHECK-LABEL: class FOp :
-// CHECK: static LogicalResult inferReturnTypes
+// CHECK: static ::mlir::LogicalResult inferReturnTypes
 
 def NS_GOp : NS_Op<"op_with_fixed_return_type", []> {
   let arguments = (ins AnyType:$a);
   let results = (outs I32:$b);
 }
 
 // CHECK-LABEL: class GOp :
-// CHECK: static LogicalResult inferReturnTypes
+// CHECK: static ::mlir::LogicalResult inferReturnTypes
 
 // Check that default builders can be suppressed.
 // ---
 
 def NS_SkipDefaultBuildersOp : NS_Op<"skip_default_builders", []> {
   let skipDefaultBuilders = 1;
   let builders = [OpBuilder<"Value val">];
 }
 
 // CHECK-LABEL: NS::SkipDefaultBuildersOp declarations
 // CHECK:     class SkipDefaultBuildersOp
-// CHECK-NOT:   static void build(Builder
+// CHECK-NOT:   static void build(::mlir::Builder
 // CHECK:       static void build(Value
 
 // Check leading underscore in op name
 // ---
 
 def NS__AOp : NS_Op<"_op_with_leading_underscore", []>;
 
 // CHECK-LABEL: NS::_AOp declarations
-// CHECK: class _AOp : public Op<_AOp
+// CHECK: class _AOp : public ::mlir::Op<_AOp
 
 def _BOp : NS_Op<"_op_with_leading_underscore_and_no_namespace", []>;
 
 // CHECK-LABEL: _BOp declarations
-// CHECK: class _BOp : public Op<_BOp
+// CHECK: class _BOp : public ::mlir::Op<_BOp
 
 // REDUCE-LABEL: NS::AOp declarations
 // REDUCE-NOT: NS::BOp declarations

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

 
 def DeclareMethodsOp : Op<TestDialect, "declare_methods_op",
                           [DeclareOpInterfaceMethods<TestOpInterface>]>;
 
 def DeclareMethodsWithDefaultOp : Op<TestDialect, "declare_methods_op",
       [DeclareOpInterfaceMethods<TestOpInterface, ["default_foo"]>]>;
 
 // DECL-LABEL: TestOpInterfaceInterfaceTraits
-// DECL: class TestOpInterface : public OpInterface<TestOpInterface, detail::TestOpInterfaceInterfaceTraits>
+// DECL: class TestOpInterface : public ::mlir::OpInterface<TestOpInterface, detail::TestOpInterfaceInterfaceTraits>
 // DECL: int foo(int input);
 
 // DECL-NOT: TestOpInterface
 
 // OP_DECL-LABEL: class DeclareMethodsOp : public
 // OP_DECL: int foo(int input);
 // OP_DECL-NOT: int default_foo(int input);
 
 // OP_DECL-LABEL: class DeclareMethodsWithDefaultOp : public
 // OP_DECL: int foo(int input);
 // OP_DECL: int default_foo(int input);

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

 }
 
 // CHECK-LABEL: OpA definitions
 
 // CHECK:      OpAAdaptor::OpAAdaptor
 // CHECK-SAME: odsOperands(values), odsAttrs(attrs)
 
 // CHECK:      void OpA::build
-// CHECK:        Value input
+// CHECK:        ::mlir::Value input
 // CHECK:        odsState.addOperands(input);
 
 // CHECK:      void OpA::build
-// CHECK:        ValueRange operands
+// CHECK:        ::mlir::ValueRange operands
 // CHECK:        assert(operands.size() == 1u && "mismatched number of parameters");
 // CHECK:        odsState.addOperands(operands);
 
 def OpB : NS_Op<"one_variadic_operand_op", []> {
   let arguments = (ins Variadic<I32>:$input);
 }
 
 // CHECK-LABEL: OpB::build
-// CHECK:         ValueRange input
+// CHECK:         ::mlir::ValueRange input
 // CHECK-NOT:     assert
 // CHECK:         odsState.addOperands(input);
 
 def OpD : NS_Op<"mix_variadic_and_normal_inputs_op", [SameVariadicOperandSize]> {
   let arguments = (ins Variadic<AnyTensor>:$input1, AnyTensor:$input2, Variadic<AnyTensor>:$input3);
 }
 
-// CHECK-LABEL: ValueRange OpDAdaptor::input1
+// CHECK-LABEL: ::mlir::ValueRange OpDAdaptor::input1
 // CHECK-NEXT:    return getODSOperands(0);
 
-// CHECK-LABEL: Value OpDAdaptor::input2
+// CHECK-LABEL: ::mlir::Value OpDAdaptor::input2
 // CHECK-NEXT:    return *getODSOperands(1).begin();
 
-// CHECK-LABEL: ValueRange OpDAdaptor::input3
+// CHECK-LABEL: ::mlir::ValueRange OpDAdaptor::input3
 // CHECK-NEXT:    return getODSOperands(2);
 
-// CHECK-LABEL: Operation::operand_range OpD::input1
+// CHECK-LABEL: ::mlir::Operation::operand_range OpD::input1
 // CHECK-NEXT: return getODSOperands(0);
 
-// CHECK-LABEL: Value OpD::input2
+// CHECK-LABEL: ::mlir::Value OpD::input2
 // CHECK-NEXT: return *getODSOperands(1).begin();
 
 // CHECK-LABEL: OpD::build
 // CHECK-NEXT: odsState.addOperands(input1);
 // CHECK-NEXT: odsState.addOperands(input2);
 // CHECK-NEXT: odsState.addOperands(input3);

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

 // RUN: mlir-tblgen -gen-op-defs -I %S/../../include %s | FileCheck %s
 
 include "mlir/IR/OpBase.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
 }
 class NS_Op<string mnemonic, list<OpTrait> traits> :
     Op<Test_Dialect, mnemonic, traits>;
 
 def OpA : NS_Op<"one_normal_result_op", []> {
   let results = (outs I32:$result);
 }
 
 // CHECK-LABEL: void OpA::build
-// CHECK:         ArrayRef<Type> resultTypes, ValueRange operands
+// CHECK:         ::mlir::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange operands
 // CHECK:         assert(resultTypes.size() == 1u && "mismatched number of return types");
 // CHECK-NEXT:    odsState.addTypes(resultTypes);
 
 def OpB : NS_Op<"same_input_output_type_op", [SameOperandsAndResultType]> {
   let arguments = (ins I32:$x);
   let results = (outs I32:$y);
 }
 
 // CHECK-LABEL: OpB definitions
-// CHECK: void OpB::build(OpBuilder &odsBuilder, OperationState &odsState, Type y, Value x)
+// CHECK: void OpB::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type y, ::mlir::Value x)
 // CHECK:   odsState.addTypes(y);
-// CHECK: void OpB::build(OpBuilder &odsBuilder, OperationState &odsState, Value x)
+// CHECK: void OpB::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value x)
 // CHECK:   odsState.addTypes({x.getType()});
 
 def OpC : NS_Op<"three_normal_result_op", []> {
   let results = (outs I32:$x, /*unnamed*/I32, I32:$z);
 }
 
 // CHECK-LABEL: OpC definitions
-// CHECK:       void OpC::build(OpBuilder &odsBuilder, OperationState &odsState, Type x, Type resultType1, Type z)
+// CHECK:       void OpC::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type x, ::mlir::Type resultType1, ::mlir::Type z)
 // CHECK-NEXT:   odsState.addTypes(x)
 // CHECK-NEXT:   odsState.addTypes(resultType1)
 // CHECK-NEXT:   odsState.addTypes(z)
 
-// CHECK:      void OpC::build(OpBuilder &odsBuilder, OperationState &odsState, ArrayRef<Type> resultTypes) {
+// CHECK:      void OpC::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ArrayRef<::mlir::Type> resultTypes) {
 // CHECK-NEXT:   assert(resultTypes.size() == 3u && "mismatched number of results");
 // CHECK-NEXT:   odsState.addTypes(resultTypes);
 
 def IntegerTypeAttr : TypeAttrBase<"IntegerType", "Integer type attribute">;
 def OpD : NS_Op<"type_attr_as_result_type", [FirstAttrDerivedResultType]> {
   let arguments = (ins I32:$x, IntegerTypeAttr:$attr, F32Attr:$f32);
   let results = (outs AnyTensor:$y);
 }
 
 // CHECK-LABEL: OpD definitions
-// CHECK: void OpD::build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes)
-// CHECK: odsState.addTypes({attr.second.cast<TypeAttr>().getValue()});
+// CHECK: void OpD::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::mlir::ArrayRef<::mlir::NamedAttribute> attributes)
+// CHECK: odsState.addTypes({attr.second.cast<::mlir::TypeAttr>().getValue()});
 
 def OpE : NS_Op<"value_attr_as_result_type", [FirstAttrDerivedResultType]> {
   let arguments = (ins I32:$x, F32Attr:$attr);
   let results = (outs AnyTensor:$y);
 }
 
 // CHECK-LABEL: OpE definitions
-// CHECK: void OpE::build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange operands, ArrayRef<NamedAttribute> attributes)
+// CHECK: void OpE::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange operands, ::mlir::ArrayRef<::mlir::NamedAttribute> attributes)
 // CHECK: odsState.addTypes({attr.second.getType()});
 
 def OpF : NS_Op<"one_variadic_result_op", []> {
   let results = (outs Variadic<I32>:$x);
 }
 
 // CHECK-LABEL: void OpF::build
-// CHECK-SAME:    ArrayRef<Type> x
+// CHECK-SAME:    ::mlir::ArrayRef<::mlir::Type> x
 // CHECK-NOT:     assert
 // CHECK:         odsState.addTypes(x);
 
 def OpG : NS_Op<"one_normal_and_one_variadic_result_op", []> {
 
   let results = (outs I32:$x, Variadic<I32>:$y);
 }
 
 // CHECK-LABEL: OpG definitions
 
-// CHECK:      void OpG::build(OpBuilder &odsBuilder, OperationState &odsState, Type x, ArrayRef<Type> y)
+// CHECK:      void OpG::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type x, ::mlir::ArrayRef<::mlir::Type> y)
 // CHECK-NEXT:   odsState.addTypes(x);
 // CHECK-NEXT:   odsState.addTypes(y);
 
 // CHECK:       void OpG::build
-// CHECK:         ArrayRef<Type> resultTypes
+// CHECK:         ::mlir::ArrayRef<::mlir::Type> resultTypes
 // CHECK:         assert(resultTypes.size() >= 1u && "mismatched number of return types");
 // CHECK-NEXT:    odsState.addTypes(resultTypes);
 
 def OpI : NS_Op<"mix_variadic_and_normal_results_op", [SameVariadicResultSize]> {
   let results = (outs Variadic<AnyTensor>:$output1, AnyTensor:$output2, Variadic<AnyTensor>:$output3);
 }
 
-// CHECK-LABEL: Operation::result_range OpI::output1
+// CHECK-LABEL: ::mlir::Operation::result_range OpI::output1
 // CHECK-NEXT:    return getODSResults(0);
 
-// CHECK-LABEL: Value OpI::output2
+// CHECK-LABEL: ::mlir::Value OpI::output2
 // CHECK-NEXT:    return *getODSResults(1).begin();
 
 // CHECK-LABEL: OpI::build
 // CHECK-NEXT:    odsState.addTypes(output1);
 // CHECK-NEXT:    odsState.addTypes(output2);
 // CHECK-NEXT:    odsState.addTypes(output3);
 
 // Test that if the only operand is variadic, we access the first value in the
 // pack to set result type
 // ---
 def OpK : NS_Op<"only_input_is_variadic_with_same_value_type_op", [SameOperandsAndResultType]> {
   let arguments = (ins Variadic<AnyTensor>:$input);
   let results = (outs AnyTensor:$result);
 }
 
-// CHECK-LABEL: OpK::build(OpBuilder &odsBuilder, OperationState &odsState, ValueRange input)
+// CHECK-LABEL: OpK::build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::ValueRange input)
 // CHECK: odsState.addTypes({input.front().getType()});

mlir/test/mlir-tblgen/op-side-effects.td

def SideEffectOpA : TEST_Op<"side_effect_op_a"> {
   let arguments = (ins Arg<Variadic<AnyMemRef>, "", [MemRead]>);
   let results = (outs Res<AnyMemRef, "", [MemAlloc<CustomResource>]>);
 }
 
 def SideEffectOpB : TEST_Op<"side_effect_op_b",
     [MemoryEffects<[MemWrite<CustomResource>]>]>;
 
 // CHECK: void SideEffectOpA::getEffects
-// CHECK:   for (Value value : getODSOperands(0))
+// CHECK:   for (::mlir::Value value : getODSOperands(0))
 // CHECK:     effects.emplace_back(MemoryEffects::Read::get(), value, ::mlir::SideEffects::DefaultResource::get());
-// CHECK:   for (Value value : getODSResults(0))
+// CHECK:   for (::mlir::Value value : getODSResults(0))
 // CHECK:     effects.emplace_back(MemoryEffects::Allocate::get(), value, CustomResource::get());
 
 // CHECK: void SideEffectOpB::getEffects
 // CHECK:   effects.emplace_back(MemoryEffects::Write::get(), CustomResource::get());

mlir/test/mlir-tblgen/predicate.td

def I32OrF32 : Type<CPred<"$_self.isInteger(32) || $_self.isF32()">,
                     "32-bit integer or floating-point type">;
 
 def OpA : NS_Op<"op_for_CPred_containing_multiple_same_placeholder", []> {
   let arguments = (ins I32OrF32:$x);
 }
 
 // CHECK-LABEL: OpA::verify
 // CHECK: auto valueGroup0 = getODSOperands(0);
-// CHECK: for (Value v : valueGroup0) {
+// CHECK: for (::mlir::Value v : valueGroup0) {
 // CHECK:   if (!((v.getType().isInteger(32) || v.getType().isF32())))
 
 def OpB : NS_Op<"op_for_And_PredOpTrait", [
     PredOpTrait<"both first and second holds",
                 And<[CPred<"first">, CPred<"second">]>>]> {
 }
 
 // CHECK-LABEL: OpB::verify
 // CHECK: if (!(((first)) && ((second))))
 
 def OpF : NS_Op<"op_for_int_min_val", []> {
   let arguments = (ins Confined<I32Attr, [IntMinValue<10>]>:$attr);
 }
 
 // CHECK-LABEL: OpFAdaptor::verify
-// CHECK:       (tblgen_attr.cast<IntegerAttr>().getInt() >= 10)
+// CHECK:       (tblgen_attr.cast<::mlir::IntegerAttr>().getInt() >= 10)
 // CHECK-SAME:  "attribute 'attr' failed to satisfy constraint: 32-bit signless integer attribute whose minimum value is 10"
 
 def OpFX : NS_Op<"op_for_int_max_val", []> {
   let arguments = (ins Confined<I32Attr, [IntMaxValue<10>]>:$attr);
 }
 
 // CHECK-LABEL: OpFXAdaptor::verify
-// CHECK:       (tblgen_attr.cast<IntegerAttr>().getInt() <= 10)
+// CHECK:       (tblgen_attr.cast<::mlir::IntegerAttr>().getInt() <= 10)
 // CHECK-SAME:  "attribute 'attr' failed to satisfy constraint: 32-bit signless integer attribute whose maximum value is 10"
 
 def OpG : NS_Op<"op_for_arr_min_count", []> {
   let arguments = (ins Confined<ArrayAttr, [ArrayMinCount<8>]>:$attr);
 }
 
 // CHECK-LABEL: OpGAdaptor::verify
-// CHECK:       (tblgen_attr.cast<ArrayAttr>().size() >= 8)
+// CHECK:       (tblgen_attr.cast<::mlir::ArrayAttr>().size() >= 8)
 // CHECK-SAME:  "attribute 'attr' failed to satisfy constraint: array attribute with at least 8 elements"
 
 def OpH : NS_Op<"op_for_arr_value_at_index", []> {
   let arguments = (ins Confined<ArrayAttr, [IntArrayNthElemEq<0, 8>]>:$attr);
 }
 
 // CHECK-LABEL: OpHAdaptor::verify
-// CHECK: (((tblgen_attr.cast<ArrayAttr>().size() > 0)) && ((tblgen_attr.cast<ArrayAttr>()[0].cast<IntegerAttr>().getInt() == 8)))))
+// CHECK: (((tblgen_attr.cast<::mlir::ArrayAttr>().size() > 0)) && ((tblgen_attr.cast<::mlir::ArrayAttr>()[0].cast<::mlir::IntegerAttr>().getInt() == 8)))))
 // CHECK-SAME:  "attribute 'attr' failed to satisfy constraint: array attribute whose 0-th element must be 8"
 
 def OpI: NS_Op<"op_for_arr_min_value_at_index", []> {
   let arguments = (ins Confined<ArrayAttr, [IntArrayNthElemMinValue<0, 8>]>:$attr);
 }
 
 // CHECK-LABEL: OpIAdaptor::verify
-// CHECK: (((tblgen_attr.cast<ArrayAttr>().size() > 0)) && ((tblgen_attr.cast<ArrayAttr>()[0].cast<IntegerAttr>().getInt() >= 8)))))
+// CHECK: (((tblgen_attr.cast<::mlir::ArrayAttr>().size() > 0)) && ((tblgen_attr.cast<::mlir::ArrayAttr>()[0].cast<::mlir::IntegerAttr>().getInt() >= 8)))))
 // CHECK-SAME: "attribute 'attr' failed to satisfy constraint: array attribute whose 0-th element must be at least 8"
 
 def OpJ: NS_Op<"op_for_TCopVTEtAreSameAt", [
                 PredOpTrait<"operands indexed at 0, 2, 3 should all have "
                  "the same type", TCopVTEtAreSameAt<[0, 2, 3]>>]> {
   let arguments = (ins
     AnyTensor:$a,
     AnyTensor:$b,
     AnyTensor:$c,
     AnyTensor:$d,
     AnyTensor:$e
   );
 }
 
 // CHECK-LABEL: OpJAdaptor::verify
-// CHECK:      llvm::is_splat(llvm::map_range(
-// CHECK-SAME:   llvm::ArrayRef<unsigned>({0, 2, 3}),
+// CHECK:      ::llvm::is_splat(::llvm::map_range(
+// CHECK-SAME:   ::mlir::ArrayRef<unsigned>({0, 2, 3}),
 // CHECK-SAME:   [this](unsigned i) { return getElementTypeOrSelf(this->getOperand(i)); }))
 // CHECK: "failed to verify that operands indexed at 0, 2, 3 should all have the same type"
 
 def OpK : NS_Op<"op_for_AnyTensorOf", []> {
   let arguments = (ins TensorOf<[F32, I32]>:$x);
 }
 
 // CHECK-LABEL: OpK::verify
 // CHECK: auto valueGroup0 = getODSOperands(0);
-// CHECK: for (Value v : valueGroup0) {
-// CHECK: if (!(((v.getType().isa<TensorType>())) && (((v.getType().cast<ShapedType>().getElementType().isF32())) || ((v.getType().cast<ShapedType>().getElementType().isSignlessInteger(32))))))
+// CHECK: for (::mlir::Value v : valueGroup0) {
+// CHECK: if (!(((v.getType().isa<::mlir::TensorType>())) && (((v.getType().cast<::mlir::ShapedType>().getElementType().isF32())) || ((v.getType().cast<::mlir::ShapedType>().getElementType().isSignlessInteger(32))))))

mlir/tools/mlir-tblgen/DialectGen.cpp

 /// The code block for the start of a dialect class declaration.
 ///
 /// {0}: The name of the dialect class.
 /// {1}: The dialect namespace.
 static const char *const dialectDeclBeginStr = R"(
 class {0} : public ::mlir::Dialect {
 public:
   explicit {0}(::mlir::MLIRContext *context);
-  static ::llvm::StringRef getDialectNamespace() { return "{1}"; }
+  static ::mlir::StringRef getDialectNamespace() { return "{1}"; }
 )";
 
 /// The code block for the attribute parser/printer hooks.
 static const char *const attrParserDecl = R"(
   /// Parse an attribute registered to this dialect.
   ::mlir::Attribute parseAttribute(::mlir::DialectAsmParser &parser,
                                    ::mlir::Type type) const override;
 

mlir/tools/mlir-tblgen/EnumsGen.cpp

std::string qualName =
       std::string(formatv("{0}::{1}", cppNamespace, enumName));
   if (underlyingType.empty())
     underlyingType =
         std::string(formatv("std::underlying_type<{0}>::type", qualName));
 
   const char *const mapInfo = R"(
 namespace llvm {
 template<> struct DenseMapInfo<{0}> {{
-  using StorageInfo = llvm::DenseMapInfo<{1}>;
+  using StorageInfo = ::llvm::DenseMapInfo<{1}>;
 
   static inline {0} getEmptyKey() {{
     return static_cast<{0}>(StorageInfo::getEmptyKey());
   }
 
   static inline {0} getTombstoneKey() {{
     return static_cast<{0}>(StorageInfo::getTombstoneKey());
   }
static void emitSymToStrFnForBitEnum(const Record &enumDef, raw_ostream &os) {
 
   os << formatv("  auto val = static_cast<{0}>(symbol);\n",
                 enumAttr.getUnderlyingType());
   if (allBitsUnsetCase) {
     os << "  // Special case for all bits unset.\n";
     os << formatv("  if (val == 0) return \"{0}\";\n\n",
                   allBitsUnsetCase->getSymbol());
   }
-  os << "  llvm::SmallVector<llvm::StringRef, 2> strs;\n";
+  os << "  ::mlir::SmallVector<::mlir::StringRef, 2> strs;\n";
   for (const auto &enumerant : enumerants) {
     // Skip the special enumerant for None.
     if (auto val = enumerant.getValue())
       os << formatv("  if ({0}u & val) {{ strs.push_back(\"{1}\"); "
                     "val &= ~{0}u; }\n",
                     val, enumerant.getSymbol());
   }
   // If we have unknown bit set, return an empty string to signal errors.
   os << "\n  if (val) return \"\";\n";
-  os << formatv("  return llvm::join(strs, \"{0}\");\n", separator);
+  os << formatv("  return ::llvm::join(strs, \"{0}\");\n", separator);
 
   os << "}\n\n";
 }
 
 static void emitStrToSymFnForIntEnum(const Record &enumDef, raw_ostream &os) {
   EnumAttr enumAttr(enumDef);
   StringRef enumName = enumAttr.getEnumClassName();
   StringRef strToSymFnName = enumAttr.getStringToSymbolFnName();
   auto enumerants = enumAttr.getAllCases();
 
-  os << formatv("llvm::Optional<{0}> {1}(llvm::StringRef str) {{\n", enumName,
-                strToSymFnName);
-  os << formatv("  return llvm::StringSwitch<llvm::Optional<{0}>>(str)\n",
+  os << formatv("::mlir::Optional<{0}> {1}(::mlir::StringRef str) {{\n",
+                enumName, strToSymFnName);
+  os << formatv("  return ::llvm::StringSwitch<::mlir::Optional<{0}>>(str)\n",
                 enumName);
   for (const auto &enumerant : enumerants) {
     auto symbol = enumerant.getSymbol();
     auto str = enumerant.getStr();
     os << formatv("      .Case(\"{1}\", {0}::{2})\n", enumName, str,
                   makeIdentifier(symbol));
   }
-  os << "      .Default(llvm::None);\n";
+  os << "      .Default(::llvm::None);\n";
   os << "}\n";
 }
 
 static void emitStrToSymFnForBitEnum(const Record &enumDef, raw_ostream &os) {
   EnumAttr enumAttr(enumDef);
   StringRef enumName = enumAttr.getEnumClassName();
   std::string underlyingType = std::string(enumAttr.getUnderlyingType());
   StringRef strToSymFnName = enumAttr.getStringToSymbolFnName();
   StringRef separator = enumDef.getValueAsString("separator");
   auto enumerants = enumAttr.getAllCases();
   auto allBitsUnsetCase = getAllBitsUnsetCase(enumerants);
 
-  os << formatv("llvm::Optional<{0}> {1}(llvm::StringRef str) {{\n", enumName,
-                strToSymFnName);
+  os << formatv("::mlir::Optional<{0}> {1}(::mlir::StringRef str) {{\n",
+                enumName, strToSymFnName);
 
   if (allBitsUnsetCase) {
     os << "  // Special case for all bits unset.\n";
     StringRef caseSymbol = allBitsUnsetCase->getSymbol();
     os << formatv("  if (str == \"{1}\") return {0}::{2};\n\n", enumName,
                   caseSymbol, makeIdentifier(caseSymbol));
   }
 
   // Split the string to get symbols for all the bits.
-  os << "  llvm::SmallVector<llvm::StringRef, 2> symbols;\n";
+  os << "  ::mlir::SmallVector<::mlir::StringRef, 2> symbols;\n";
   os << formatv("  str.split(symbols, \"{0}\");\n\n", separator);
 
   os << formatv("  {0} val = 0;\n", underlyingType);
   os << "  for (auto symbol : symbols) {\n";
 
   // Convert each symbol to the bit ordinal and set the corresponding bit.
   os << formatv(
-      "    auto bit = llvm::StringSwitch<llvm::Optional<{0}>>(symbol)\n",
+      "    auto bit = llvm::StringSwitch<::mlir::Optional<{0}>>(symbol)\n",
       underlyingType);
   for (const auto &enumerant : enumerants) {
     // Skip the special enumerant for None.
     if (auto val = enumerant.getValue())
       os.indent(6) << formatv(".Case(\"{0}\", {1})\n", enumerant.getSymbol(),
                               val);
   }
-  os.indent(6) << ".Default(llvm::None);\n";
+  os.indent(6) << ".Default(::llvm::None);\n";
 
-  os << "    if (bit) { val |= *bit; } else { return llvm::None; }\n";
+  os << "    if (bit) { val |= *bit; } else { return ::llvm::None; }\n";
   os << "  }\n";
 
   os << formatv("  return static_cast<{0}>(val);\n", enumName);
   os << "}\n\n";
 }
 
 static void emitUnderlyingToSymFnForIntEnum(const Record &enumDef,
                                             raw_ostream &os) {
   EnumAttr enumAttr(enumDef);
   StringRef enumName = enumAttr.getEnumClassName();
   std::string underlyingType = std::string(enumAttr.getUnderlyingType());
   StringRef underlyingToSymFnName = enumAttr.getUnderlyingToSymbolFnName();
   auto enumerants = enumAttr.getAllCases();
 
   // Avoid generating the underlying value to symbol conversion function if
   // there is an enumerant without explicit value.
   if (llvm::any_of(enumerants, [](EnumAttrCase enumerant) {
         return enumerant.getValue() < 0;
       }))
     return;
 
-  os << formatv("llvm::Optional<{0}> {1}({2} value) {{\n", enumName,
+  os << formatv("::mlir::Optional<{0}> {1}({2} value) {{\n", enumName,
                 underlyingToSymFnName,
                 underlyingType.empty() ? std::string("unsigned")
                                        : underlyingType)
      << "  switch (value) {\n";
   for (const auto &enumerant : enumerants) {
     auto symbol = enumerant.getSymbol();
     auto value = enumerant.getValue();
     os << formatv("  case {0}: return {1}::{2};\n", value, enumName,
                   makeIdentifier(symbol));
   }
-  os << "  default: return llvm::None;\n"
+  os << "  default: return ::llvm::None;\n"
      << "  }\n"
      << "}\n\n";
 }
 
 static void emitUnderlyingToSymFnForBitEnum(const Record &enumDef,
                                             raw_ostream &os) {
   EnumAttr enumAttr(enumDef);
   StringRef enumName = enumAttr.getEnumClassName();
   std::string underlyingType = std::string(enumAttr.getUnderlyingType());
   StringRef underlyingToSymFnName = enumAttr.getUnderlyingToSymbolFnName();
   auto enumerants = enumAttr.getAllCases();
   auto allBitsUnsetCase = getAllBitsUnsetCase(enumerants);
 
-  os << formatv("llvm::Optional<{0}> {1}({2} value) {{\n", enumName,
+  os << formatv("::mlir::Optional<{0}> {1}({2} value) {{\n", enumName,
                 underlyingToSymFnName, underlyingType);
   if (allBitsUnsetCase) {
     os << "  // Special case for all bits unset.\n";
     os << formatv("  if (value == 0) return {0}::{1};\n\n", enumName,
                   makeIdentifier(allBitsUnsetCase->getSymbol()));
   }
   llvm::SmallVector<std::string, 8> values;
   for (const auto &enumerant : enumerants) {
static void emitEnumDecl(const Record &enumDef, raw_ostream &os) {
   // Emit the enum class definition
   emitEnumClass(enumDef, enumName, underlyingType, description, enumerants, os);
 
   // Emit conversion function declarations
   if (llvm::all_of(enumerants, [](EnumAttrCase enumerant) {
         return enumerant.getValue() >= 0;
       })) {
     os << formatv(
-        "llvm::Optional<{0}> {1}({2});\n", enumName, underlyingToSymFnName,
+        "::mlir::Optional<{0}> {1}({2});\n", enumName, underlyingToSymFnName,
         underlyingType.empty() ? std::string("unsigned") : underlyingType);
   }
   os << formatv("{2} {1}({0});\n", enumName, symToStrFnName, symToStrFnRetType);
-  os << formatv("llvm::Optional<{0}> {1}(llvm::StringRef);\n", enumName,
+  os << formatv("::mlir::Optional<{0}> {1}(::mlir::StringRef);\n", enumName,
                 strToSymFnName);
 
   if (enumAttr.isBitEnum()) {
     emitOperators(enumDef, os);
   } else {
     emitMaxValueFn(enumDef, os);
   }
 
   // Generate a generic `stringifyEnum` function that forwards to the method
   // specified by the user.
   const char *const stringifyEnumStr = R"(
 inline {0} stringifyEnum({1} enumValue) {{
   return {2}(enumValue);
 }
 )";
   os << formatv(stringifyEnumStr, symToStrFnRetType, enumName, symToStrFnName);
 
   // Generate a generic `symbolizeEnum` function that forwards to the method
   // specified by the user.
   const char *const symbolizeEnumStr = R"(
 template <typename EnumType>
-llvm::Optional<EnumType> symbolizeEnum(llvm::StringRef);
+::mlir::Optional<EnumType> symbolizeEnum(::mlir::StringRef);
 
 template <>
-inline llvm::Optional<{0}> symbolizeEnum<{0}>(llvm::StringRef str) {
+inline ::mlir::Optional<{0}> symbolizeEnum<{0}>(::mlir::StringRef str) {
   return {1}(str);
 }
 )";
   os << formatv(symbolizeEnumStr, enumName, strToSymFnName);
 
   for (auto ns : llvm::reverse(namespaces))
     os << "} // namespace " << ns << "\n";
 

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

 // The logic to calculate the actual value range for a declared operand/result
 // of an op with variadic operands/results. Note that this logic is assumes
 // the op has an attribute specifying the size of each operand/result segment
 // (variadic or not).
 //
 // {0}: The name of the attribute specifying the segment sizes.
 const char *adapterSegmentSizeAttrInitCode = R"(
   assert(odsAttrs && "missing segment size attribute for op");
-  auto sizeAttr = odsAttrs.get("{0}").cast<DenseIntElementsAttr>();
+  auto sizeAttr = odsAttrs.get("{0}").cast<::mlir::DenseIntElementsAttr>();
 )";
 const char *opSegmentSizeAttrInitCode = R"(
-  auto sizeAttr = getAttrOfType<DenseIntElementsAttr>("{0}");
+  auto sizeAttr = getAttrOfType<::mlir::DenseIntElementsAttr>("{0}");
 )";
 const char *attrSizedSegmentValueRangeCalcCode = R"(
   unsigned start = 0;
   for (unsigned i = 0; i < index; ++i)
     start += (*(sizeAttr.begin() + i)).getZExtValue();
   unsigned size = (*(sizeAttr.begin() + index)).getZExtValue();
   return {start, size};
 )";

 }
 
 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())");
+  fctx.withBuilder("::mlir::Builder(this->getContext())");
 
   // 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";
   };
 
for (auto &namedAttr : op.getAttributes()) {
     }
   }
 
   auto derivedAttrs = make_filter_range(op.getAttributes(),
                                         [](const NamedAttribute &namedAttr) {
                                           return namedAttr.attr.isDerivedAttr();
                                         });
   if (!derivedAttrs.empty()) {
-    opClass.addTrait("DerivedAttributeOpInterface::Trait");
+    opClass.addTrait("::mlir::DerivedAttributeOpInterface::Trait");
     // Generate helper method to query whether a named attribute is a derived
     // attribute. This enables, for example, avoiding adding an attribute that
     // overlaps with a derived attribute.
     {
-      auto &method = opClass.newMethod("bool", "isDerivedAttribute",
-                                       "StringRef name", OpMethod::MP_Static);
+      auto &method =
+          opClass.newMethod("bool", "isDerivedAttribute",
+                            "::mlir::StringRef name", OpMethod::MP_Static);
       auto &body = method.body();
       for (auto namedAttr : derivedAttrs)
         body << "  if (name == \"" << namedAttr.name << "\") return true;\n";
       body << " return false;";
     }
     // Generate method to materialize derived attributes as a DictionaryAttr.
     {
-      OpMethod &method =
-          opClass.newMethod("DictionaryAttr", "materializeDerivedAttributes");
+      OpMethod &method = opClass.newMethod("::mlir::DictionaryAttr",
+                                           "materializeDerivedAttributes");
       auto &body = method.body();
 
       auto nonMaterializable =
           make_filter_range(derivedAttrs, [](const NamedAttribute &namedAttr) {
             return namedAttr.attr.getConvertFromStorageCall().empty();
           });
       if (!nonMaterializable.empty()) {
         std::string attrs;
         llvm::raw_string_ostream os(attrs);
         interleaveComma(nonMaterializable, os,
                         [&](const NamedAttribute &attr) { os << attr.name; });
         PrintWarning(
             op.getLoc(),
             formatv(
                 "op has non-materialzable derived attributes '{0}', skipping",
                 os.str()));
         body << formatv("  emitOpError(\"op has non-materializable derived "
                         "attributes '{0}'\");\n",
                         attrs);
         body << "  return nullptr;";
         return;
       }
 
-      body << "  MLIRContext* ctx = getContext();\n";
-      body << "  Builder odsBuilder(ctx); (void)odsBuilder;\n";
-      body << "  return DictionaryAttr::get({\n";
+      body << "  ::mlir::MLIRContext* ctx = getContext();\n";
+      body << "  ::mlir::Builder odsBuilder(ctx); (void)odsBuilder;\n";
+      body << "  return ::mlir::DictionaryAttr::get({\n";
       interleave(
           derivedAttrs, body,
           [&](const NamedAttribute &namedAttr) {
             auto tmpl = namedAttr.attr.getConvertFromStorageCall();
-            body << "    {Identifier::get(\"" << namedAttr.name << "\", ctx),\n"
+            body << "    {::mlir::Identifier::get(\"" << namedAttr.name
+                 << "\", ctx),\n"
                  << tgfmt(tmpl, &fctx.withSelf(namedAttr.name + "()")
                                      .withBuilder("odsBuilder")
                                      .addSubst("_ctx", "ctx"))
                  << "}";
           },
           ",\n");
       body << "\n    }, ctx);";
     }
static void generateNamedOperandGetters(const Operator &op, Class &opClass,
   // Then we emit nicer named getter methods by redirecting to the "sink" getter
   // method.
   for (int i = 0; i != numOperands; ++i) {
     const auto &operand = op.getOperand(i);
     if (operand.name.empty())
       continue;
 
     if (operand.isOptional()) {
-      auto &m = opClass.newMethod("Value", operand.name);
+      auto &m = opClass.newMethod("::mlir::Value", operand.name);
       m.body() << "  auto operands = getODSOperands(" << i << ");\n"
                << "  return operands.empty() ? Value() : *operands.begin();";
     } else if (operand.isVariadic()) {
       auto &m = opClass.newMethod(rangeType, operand.name);
       m.body() << "  return getODSOperands(" << i << ");";
     } else {
-      auto &m = opClass.newMethod("Value", operand.name);
+      auto &m = opClass.newMethod("::mlir::Value", operand.name);
       m.body() << "  return *getODSOperands(" << i << ").begin();";
     }
   }
 }
 
 void OpEmitter::genNamedOperandGetters() {
   generateNamedOperandGetters(
       op, opClass,
       /*sizeAttrInit=*/
       formatv(opSegmentSizeAttrInitCode, "operand_segment_sizes").str(),
-      /*rangeType=*/"Operation::operand_range",
+      /*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");
   for (int i = 0, e = op.getNumOperands(); i != e; ++i) {
PrintFatalError(op.getLoc(),
                     "'SameVariadicResultSize' traits");
   }
 
   generateValueRangeStartAndEnd(
       opClass, "getODSResultIndexAndLength", numVariadicResults,
       numNormalResults, "getOperation()->getNumResults()", attrSizedResults,
       formatv(opSegmentSizeAttrInitCode, "result_segment_sizes").str(),
       op.getResults());
-  auto &m = opClass.newMethod("Operation::result_range", "getODSResults",
-                              "unsigned index");
+  auto &m = opClass.newMethod("::mlir::Operation::result_range",
+                              "getODSResults", "unsigned index");
   m.body() << formatv(valueRangeReturnCode, "getOperation()->result_begin()",
                       "getODSResultIndexAndLength(index)");
 
   for (int i = 0; i != numResults; ++i) {
     const auto &result = op.getResult(i);
     if (result.name.empty())
       continue;
 
     if (result.isOptional()) {
-      auto &m = opClass.newMethod("Value", result.name);
-      m.body() << "  auto results = getODSResults(" << i << ");\n"
-               << "  return results.empty() ? Value() : *results.begin();";
+      auto &m = opClass.newMethod("::mlir::Value", result.name);
+      m.body()
+          << "  auto results = getODSResults(" << i << ");\n"
+          << "  return results.empty() ? ::mlir::Value() : *results.begin();";
     } else if (result.isVariadic()) {
-      auto &m = opClass.newMethod("Operation::result_range", result.name);
+      auto &m =
+          opClass.newMethod("::mlir::Operation::result_range", result.name);
       m.body() << "  return getODSResults(" << i << ");";
     } else {
-      auto &m = opClass.newMethod("Value", result.name);
+      auto &m = opClass.newMethod("::mlir::Value", result.name);
       m.body() << "  return *getODSResults(" << i << ").begin();";
     }
   }
 }
 
 void OpEmitter::genNamedRegionGetters() {
   unsigned numRegions = op.getNumRegions();
   for (unsigned i = 0; i < numRegions; ++i) {
     const auto &region = op.getRegion(i);
     if (region.name.empty())
       continue;
 
     // Generate the accessors for a varidiadic region.
     if (region.isVariadic()) {
-      auto &m = opClass.newMethod("MutableArrayRef<Region>", region.name);
+      auto &m =
+          opClass.newMethod("::mlir::MutableArrayRef<Region>", region.name);
       m.body() << formatv(
           "  return this->getOperation()->getRegions().drop_front({0});", i);
       continue;
     }
 
-    auto &m = opClass.newMethod("Region &", region.name);
+    auto &m = opClass.newMethod("::mlir::Region &", region.name);
     m.body() << formatv("  return this->getOperation()->getRegion({0});", i);
   }
 }
 
 void OpEmitter::genNamedSuccessorGetters() {
   unsigned numSuccessors = op.getNumSuccessors();
   for (unsigned i = 0; i < numSuccessors; ++i) {
     const NamedSuccessor &successor = op.getSuccessor(i);
     if (successor.name.empty())
       continue;
 
     // Generate the accessors for a variadic successor list.
     if (successor.isVariadic()) {
-      auto &m = opClass.newMethod("SuccessorRange", successor.name);
+      auto &m = opClass.newMethod("::mlir::SuccessorRange", successor.name);
       m.body() << formatv(
           "  return {std::next(this->getOperation()->successor_begin(), {0}), "
           "this->getOperation()->successor_end()};",
           i);
       continue;
     }
 
-    auto &m = opClass.newMethod("Block *", successor.name);
+    auto &m = opClass.newMethod("::mlir::Block *", successor.name);
     m.body() << formatv("  return this->getOperation()->getSuccessor({0});", i);
   }
 }
 
 static bool canGenerateUnwrappedBuilder(Operator &op) {
   // If this op does not have native attributes at all, return directly to avoid
   // redefining builders.
   if (op.getNumNativeAttributes() == 0)
auto emit = [&](AttrParamKind attrType, TypeParamKind paramKind,
     // Push all result types to the operation state
 
     if (inferType) {
       // Generate builder that infers type too.
       // TODO(jpienaar): Subsume this with general checking if type can be
       // inferred automatically.
       // TODO(jpienaar): Expand to handle regions.
       body << formatv(R"(
-        SmallVector<Type, 2> inferredReturnTypes;
+        ::mlir::SmallVector<::mlir::Type, 2> inferredReturnTypes;
         if (succeeded({0}::inferReturnTypes(odsBuilder.getContext(),
                       {1}.location, {1}.operands,
                       {1}.attributes.getDictionary({1}.getContext()),
                       /*regions=*/{{}, inferredReturnTypes)))
           {1}.addTypes(inferredReturnTypes);
         else
-          llvm::report_fatal_error("Failed to infer result type(s).");)",
+          ::llvm::report_fatal_error("Failed to infer result type(s).");)",
                       opClass.getClassName(), builderOpState);
       return;
     }
 
     switch (paramKind) {
     case TypeParamKind::None:
       return;
     case TypeParamKind::Separate:
void OpEmitter::genUseOperandAsResultTypeCollectiveParamBuilder() {
   // we don't know how many results to create.
   if (op.getNumVariableLengthResults() != 0)
     return;
 
   int numResults = op.getNumResults();
 
   // Signature
   std::string params =
-      std::string("OpBuilder &odsBuilder, OperationState &") + builderOpState +
-      ", ValueRange operands, ArrayRef<NamedAttribute> attributes";
+      std::string("::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &") +
+      builderOpState +
+      ", ::mlir::ValueRange operands, ::mlir::ArrayRef<::mlir::NamedAttribute> "
+      "attributes";
   if (op.getNumVariadicRegions())
     params += ", unsigned numRegions";
   auto &m = opClass.newMethod("void", "build", params, OpMethod::MP_Static);
   auto &body = m.body();
 
   // Operands
   body << "  " << builderOpState << ".addOperands(operands);\n";
 
void OpEmitter::genUseOperandAsResultTypeCollectiveParamBuilder() {
   SmallVector<std::string, 2> resultTypes(numResults, "operands[0].getType()");
   body << "  " << builderOpState << ".addTypes({"
        << llvm::join(resultTypes, ", ") << "});\n\n";
 }
 
 void OpEmitter::genInferredTypeCollectiveParamBuilder() {
   // TODO(jpienaar): Expand to support regions.
   const char *params =
-      "OpBuilder &odsBuilder, OperationState &{0}, "
-      "ValueRange operands, ArrayRef<NamedAttribute> attributes";
+      "::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &{0}, "
+      "::mlir::ValueRange operands, ::mlir::ArrayRef<::mlir::NamedAttribute> "
+      "attributes";
   auto &m =
       opClass.newMethod("void", "build", formatv(params, builderOpState).str(),
                         OpMethod::MP_Static);
   auto &body = m.body();
 
   int numResults = op.getNumResults();
   int numVariadicResults = op.getNumVariableLengthResults();
   int numNonVariadicResults = numResults - numVariadicResults;
if (int numRegions = op.getNumRegions()) {
     body << llvm::formatv(
         "  for (unsigned i = 0; i != {0}; ++i)\n",
         (op.getNumVariadicRegions() ? "numRegions" : Twine(numRegions)));
     body << "    (void)" << builderOpState << ".addRegion();\n";
   }
 
   // Result types
   body << formatv(R"(
-    SmallVector<Type, 2> inferredReturnTypes;
+    ::mlir::SmallVector<::mlir::Type, 2> inferredReturnTypes;
     if (succeeded({0}::inferReturnTypes(odsBuilder.getContext(),
                   {1}.location, operands,
                   {1}.attributes.getDictionary({1}.getContext()),
                   /*regions=*/{{}, inferredReturnTypes))) {{)",
                   opClass.getClassName(), builderOpState);
   if (numVariadicResults == 0 || numNonVariadicResults != 0)
     body << "  assert(inferredReturnTypes.size()"
          << (numVariadicResults != 0 ? " >= " : " == ") << numNonVariadicResults
          << "u && \"mismatched number of return types\");\n";
   body << "      " << builderOpState << ".addTypes(inferredReturnTypes);";
 
   body << formatv(R"(
     } else
-      llvm::report_fatal_error("Failed to infer result type(s).");)",
+      ::llvm::report_fatal_error("Failed to infer result type(s).");)",
                   opClass.getClassName(), builderOpState);
 }
 
 void OpEmitter::genUseOperandAsResultTypeSeparateParamBuilder() {
   std::string paramList;
   llvm::SmallVector<std::string, 4> resultNames;
   buildParamList(paramList, resultNames, TypeParamKind::None);
 
void OpEmitter::genUseOperandAsResultTypeSeparateParamBuilder() {
   m.body() << "  " << builderOpState << ".addTypes({" << resultType;
   for (int i = 1; i != numResults; ++i)
     m.body() << ", " << resultType;
   m.body() << "});\n\n";
 }
 
 void OpEmitter::genUseAttrAsResultTypeBuilder() {
   std::string params =
-      std::string("OpBuilder &odsBuilder, OperationState &") + builderOpState +
-      ", ValueRange operands, ArrayRef<NamedAttribute> attributes";
+      std::string("::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &") +
+      builderOpState +
+      ", ::mlir::ValueRange operands, ::mlir::ArrayRef<::mlir::NamedAttribute> "
+      "attributes";
   auto &m = opClass.newMethod("void", "build", params, OpMethod::MP_Static);
   auto &body = m.body();
 
   // Push all result types to the operation state
   std::string resultType;
   const auto &namedAttr = op.getAttribute(0);
 
   body << "  for (auto attr : attributes) {\n";
   body << "    if (attr.first != \"" << namedAttr.name << "\") continue;\n";
   if (namedAttr.attr.isTypeAttr()) {
-    resultType = "attr.second.cast<TypeAttr>().getValue()";
+    resultType = "attr.second.cast<::mlir::TypeAttr>().getValue()";
   } else {
     resultType = "attr.second.getType()";
   }
 
   // Operands
   body << "  " << builderOpState << ".addOperands(operands);\n";
 
   // Attributes
void OpEmitter::genCollectiveParamBuilder() {
   int numResults = op.getNumResults();
   int numVariadicResults = op.getNumVariableLengthResults();
   int numNonVariadicResults = numResults - numVariadicResults;
 
   int numOperands = op.getNumOperands();
   int numVariadicOperands = op.getNumVariableLengthOperands();
   int numNonVariadicOperands = numOperands - numVariadicOperands;
   // Signature
-  std::string params = std::string("OpBuilder &, OperationState &") +
-                       builderOpState +
-                       ", ArrayRef<Type> resultTypes, ValueRange operands, "
-                       "ArrayRef<NamedAttribute> attributes";
+  std::string params =
+      std::string("::mlir::OpBuilder &, ::mlir::OperationState &") +
+      ", ::mlir::ArrayRef<::mlir::Type> resultTypes, ::mlir::ValueRange "
+      "operands, "
+      "::mlir::ArrayRef<::mlir::NamedAttribute> attributes";
   if (op.getNumVariadicRegions())
     params += ", unsigned numRegions";
   auto &m = opClass.newMethod("void", "build", params, OpMethod::MP_Static);
   auto &body = m.body();
 
   // Operands
   if (numVariadicOperands == 0 || numNonVariadicOperands != 0)
     body << "  assert(operands.size()"

 void OpEmitter::buildParamList(std::string &paramList,
                                SmallVectorImpl<std::string> &resultTypeNames,
                                TypeParamKind typeParamKind,
                                AttrParamKind attrParamKind) {
   resultTypeNames.clear();
   auto numResults = op.getNumResults();
   resultTypeNames.reserve(numResults);
 
-  paramList = "OpBuilder &odsBuilder, OperationState &";
+  paramList = "::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &";
   paramList.append(builderOpState);
 
   switch (typeParamKind) {
   case TypeParamKind::None:
     break;
   case TypeParamKind::Separate: {
     // Add parameters for all return types
     for (int i = 0; i < numResults; ++i) {
       const auto &result = op.getResult(i);
       std::string resultName = std::string(result.name);
       if (resultName.empty())
         resultName = std::string(formatv("resultType{0}", i));
 
       if (result.isOptional())
-        paramList.append(", /*optional*/Type ");
+        paramList.append(", /*optional*/::mlir::Type ");
       else if (result.isVariadic())
-        paramList.append(", ArrayRef<Type> ");
+        paramList.append(", ::mlir::ArrayRef<::mlir::Type> ");
       else
-        paramList.append(", Type ");
+        paramList.append(", ::mlir::Type ");
       paramList.append(resultName);
 
       resultTypeNames.emplace_back(std::move(resultName));
     }
   } break;
   case TypeParamKind::Collective: {
-    paramList.append(", ArrayRef<Type> resultTypes");
+    paramList.append(", ::mlir::ArrayRef<::mlir::Type> resultTypes");
     resultTypeNames.push_back("resultTypes");
   } break;
   }
 
   // Add parameters for all arguments (operands and attributes).
 
   int numOperands = 0;
   int numAttrs = 0;
for (int i = op.getNumArgs() - 1; i >= 0; --i) {
         break;
 
       // Creating an APInt requires us to provide bitwidth, value, and
       // signedness, which is complicated compared to others. Similarly
       // for APFloat.
       // TODO(b/144412160) Adjust the 'returnType' field of such attributes
       // to support them.
       StringRef retType = namedAttr->attr.getReturnType();
-      if (retType == "APInt" || retType == "APFloat")
+      if (retType == "::mlir::APInt" || retType == "::mlir::APFloat")
         break;
 
       defaultValuedAttrStartIndex = i;
     }
   }
 
   for (int i = 0, e = op.getNumArgs(); i < e; ++i) {
     auto argument = op.getArg(i);
     if (argument.is<tblgen::NamedTypeConstraint *>()) {
       const auto &operand = op.getOperand(numOperands);
       if (operand.isOptional())
-        paramList.append(", /*optional*/Value ");
+        paramList.append(", /*optional*/::mlir::Value ");
       else if (operand.isVariadic())
-        paramList.append(", ValueRange ");
+        paramList.append(", ::mlir::ValueRange ");
       else
-        paramList.append(", Value ");
+        paramList.append(", ::mlir::Value ");
       paramList.append(getArgumentName(op, numOperands));
       ++numOperands;
     } else {
       const auto &namedAttr = op.getAttribute(numAttrs);
       const auto &attr = namedAttr.attr;
       paramList.append(", ");
 
       if (attr.isOptional())
if (argument.is<tblgen::NamedTypeConstraint *>()) {
         break;
       }
       paramList.append(" ");
       paramList.append(std::string(namedAttr.name));
 
       // Attach default value if requested and possible.
       if (attrParamKind == AttrParamKind::UnwrappedValue &&
           i >= defaultValuedAttrStartIndex) {
-        bool isString = attr.getReturnType() == "StringRef";
+        bool isString = attr.getReturnType() == "::mlir::StringRef";
         paramList.append(" = ");
         if (isString)
           paramList.append("\"");
         paramList.append(std::string(attr.getDefaultValue()));
         if (isString)
           paramList.append("\"");
       }
       ++numAttrs;
     }
   }
 
   /// Insert parameters for each successor.
   for (const NamedSuccessor &succ : op.getSuccessors()) {
-    paramList += (succ.isVariadic() ? ", ArrayRef<Block *> " : ", Block *");
+    paramList += (succ.isVariadic() ? ", ::mlir::ArrayRef<::mlir::Block *> "
+                                    : ", ::mlir::Block *");
     paramList += succ.name;
   }
 
   /// Insert parameters for variadic regions.
   for (const NamedRegion &region : op.getRegions()) {
     if (region.isVariadic())
       paramList += llvm::formatv(", unsigned {0}Count", region.name).str();
   }
void OpEmitter::genCodeForAddingArgAndRegionForBuilder(OpMethodBody &body,
   }
 }
 
 void OpEmitter::genCanonicalizerDecls() {
   if (!def.getValueAsBit("hasCanonicalizer"))
     return;
 
   const char *const params =
-      "OwningRewritePatternList &results, MLIRContext *context";
+      "::mlir::OwningRewritePatternList &results, ::mlir::MLIRContext *context";
   opClass.newMethod("void", "getCanonicalizationPatterns", params,
                     OpMethod::MP_Static, /*declOnly=*/true);
 }
 
 void OpEmitter::genFolderDecls() {
   bool hasSingleResult =
       op.getNumResults() == 1 && op.getNumVariableLengthResults() == 0;
 
   if (def.getValueAsBit("hasFolder")) {
     if (hasSingleResult) {
-      const char *const params = "ArrayRef<Attribute> operands";
-      opClass.newMethod("OpFoldResult", "fold", params, OpMethod::MP_None,
+      const char *const params = "::mlir::ArrayRef<::mlir::Attribute> operands";
+      opClass.newMethod("::mlir::OpFoldResult", "fold", params,
+                        OpMethod::MP_None,
                         /*declOnly=*/true);
     } else {
-      const char *const params = "ArrayRef<Attribute> operands, "
-                                 "SmallVectorImpl<OpFoldResult> &results";
-      opClass.newMethod("LogicalResult", "fold", params, OpMethod::MP_None,
+      const char *const params =
+          "::mlir::ArrayRef<::mlir::Attribute> operands, "
+          "::mlir::SmallVectorImpl<::mlir::OpFoldResult> &results";
+      opClass.newMethod("::mlir::LogicalResult", "fold", params,
+                        OpMethod::MP_None,
                         /*declOnly=*/true);
     }
   }
 }
 
 void OpEmitter::genOpInterfaceMethod(const tblgen::InterfaceOpTrait *opTrait) {
   auto interface = opTrait->getOpInterface();
 
for (unsigned i = 0, operandIt = 0, e = op.getNumArgs(); i != e; ++i) {
     }
   }
   /// Results.
   for (unsigned i = 0, e = op.getNumResults(); i != e; ++i)
     resolveDecorators(op.getResultDecorators(i), i, EffectKind::Result);
 
   for (auto &it : interfaceEffects) {
     auto effectsParam =
-        llvm::formatv(
-            "SmallVectorImpl<SideEffects::EffectInstance<{0}>> &effects",
+        llvm::formatv("::mlir::SmallVectorImpl<::mlir::SideEffects::"
+                      "EffectInstance<{0}>> &effects",
                       it.first())
             .str();
 
     // Generate the 'getEffects' method.
     auto &getEffects = opClass.newMethod("void", "getEffects", effectsParam);
     auto &body = getEffects.body();
 
     // Add effect instances for each of the locations marked on the operation.
     for (auto &location : it.second) {
       if (location.kind != EffectKind::Static) {
-        body << "  for (Value value : getODS"
+        body << "  for (::mlir::Value value : getODS"
              << (location.kind == EffectKind::Operand ? "Operands" : "Results")
              << "(" << location.index << "))\n  ";
       }
 
       body << "  effects.emplace_back(" << location.effect.getName()
            << "::get()";
 
       // If the effect isn't static, it has a specific value attached to it.
       if (location.kind != EffectKind::Static)
         body << ", value";
       body << ", " << location.effect.getResource() << "::get());\n";
     }
   }
 }
 
 void OpEmitter::genTypeInterfaceMethods() {
   if (!op.allResultTypesKnown())
     return;
 
   auto &method = opClass.newMethod(
-      "LogicalResult", "inferReturnTypes",
-      "MLIRContext* context, Optional<Location> location, "
-      "ValueRange operands, DictionaryAttr attributes, RegionRange regions, "
-      "SmallVectorImpl<Type>& inferredReturnTypes",
+      "::mlir::LogicalResult", "inferReturnTypes",
+      "::mlir::MLIRContext* context, "
+      "::mlir::Optional<::mlir::Location> location, "
+      "::mlir::ValueRange operands, ::mlir::DictionaryAttr attributes, "
+      "::mlir::RegionRange regions, "
+      "::mlir::SmallVectorImpl<::mlir::Type>& inferredReturnTypes",
       OpMethod::MP_Static,
       /*declOnly=*/false);
   auto &os = method.body();
   os << "  inferredReturnTypes.resize(" << op.getNumResults() << ");\n";
 
   FmtContext fctx;
   fctx.withBuilder("odsBuilder");
-  os << "  Builder odsBuilder(context);\n";
+  os << "  ::mlir::Builder odsBuilder(context);\n";
 
   auto emitType =
       [&](const tblgen::Operator::ArgOrType &type) -> OpMethodBody & {
     if (type.isArg()) {
       auto argIndex = type.getArg();
       assert(!op.getArg(argIndex).is<NamedAttribute *>());
       return os << "operands[" << argIndex << "].getType()";
     } else {

 }
 
 void OpEmitter::genParser() {
   if (!hasStringAttribute(def, "parser") ||
       hasStringAttribute(def, "assemblyFormat"))
     return;
 
   auto &method = opClass.newMethod(
-      "ParseResult", "parse", "OpAsmParser &parser, OperationState &result",
+      "::mlir::ParseResult", "parse",
+      "::mlir::OpAsmParser &parser, ::mlir::OperationState &result",
       OpMethod::MP_Static);
   FmtContext fctx;
   fctx.addSubst("cppClass", opClass.getClassName());
   auto parser = def.getValueAsString("parser").ltrim().rtrim(" \t\v\f\r");
   method.body() << "  " << tgfmt(parser, &fctx);
 }
 
 void OpEmitter::genPrinter() {
   if (hasStringAttribute(def, "assemblyFormat"))
     return;
 
   auto valueInit = def.getValueInit("printer");
   CodeInit *codeInit = dyn_cast<CodeInit>(valueInit);
   if (!codeInit)
     return;
 
-  auto &method = opClass.newMethod("void", "print", "OpAsmPrinter &p");
+  auto &method = opClass.newMethod("void", "print", "::mlir::OpAsmPrinter &p");
   FmtContext fctx;
   fctx.addSubst("cppClass", opClass.getClassName());
   auto printer = codeInit->getValue().ltrim().rtrim(" \t\v\f\r");
   method.body() << "  " << tgfmt(printer, &fctx);
 }
 
 void OpEmitter::genVerifier() {
-  auto &method = opClass.newMethod("LogicalResult", "verify", /*params=*/"");
+  auto &method =
+      opClass.newMethod("::mlir::LogicalResult", "verify", /*params=*/"");
   auto &body = method.body();
   body << "  if (failed(" << op.getAdaptorName()
        << "(*this).verify(this->getLoc()))) "
        << "return failure();\n";
 
   auto *valueInit = def.getValueInit("verifier");
   CodeInit *codeInit = dyn_cast<CodeInit>(valueInit);
   bool hasCustomVerify = codeInit && !codeInit->getValue().empty();
void OpEmitter::genVerifier() {
   genSuccessorVerifier(body);
 
   if (hasCustomVerify) {
     FmtContext fctx;
     fctx.addSubst("cppClass", opClass.getClassName());
     auto printer = codeInit->getValue().ltrim().rtrim(" \t\v\f\r");
     body << "  " << tgfmt(printer, &fctx);
   } else {
-    body << "  return mlir::success();\n";
+    body << "  return ::mlir::success();\n";
   }
 }
 
 void OpEmitter::genOperandResultVerifier(OpMethodBody &body,
                                          Operator::value_range values,
                                          StringRef valueKind) {
   FmtContext fctx;
 
if (isOptional) {
                       staticValue.index(), valueKind);
     }
 
     // Otherwise, if there is no predicate there is nothing left to do.
     if (!hasPredicate)
       continue;
 
     // Emit a loop to check all the dynamic values in the pack.
-    body << "    for (Value v : valueGroup" << staticValue.index() << ") {\n";
+    body << "    for (::mlir::Value v : valueGroup" << staticValue.index()
+         << ") {\n";
 
     auto constraint = staticValue.value().constraint;
     body << "      (void)v;\n"
          << "      if (!("
          << tgfmt(constraint.getConditionTemplate(),
                   &fctx.withSelf("v.getType()"))
          << ")) {\n"
          << formatv("        return emitOpError(\"{0} #\") << index "
void OpEmitter::genRegionVerifier(OpMethodBody &body) {
   body << "{\n";
   body << "    unsigned index = 0; (void)index;\n";
 
   for (unsigned i = 0; i < numRegions; ++i) {
     const auto &region = op.getRegion(i);
     if (region.constraint.getPredicate().isNull())
       continue;
 
-    body << "    for (Region &region : ";
-    body << formatv(
-        region.isVariadic()
+    body << "    for (::mlir::Region &region : ";
+    body << formatv(region.isVariadic()
                         ? "{0}()"
-            : "MutableArrayRef<Region>(this->getOperation()->getRegion({1}))",
+                        : "::mlir::MutableArrayRef<::mlir::Region>(this->"
+                          "getOperation()->getRegion({1}))",
                     region.name, i);
     body << ") {\n";
     auto constraint = tgfmt(region.constraint.getConditionTemplate(),
                             &verifyCtx.withSelf("region"))
                           .str();
 
     body << formatv("      (void)region;\n"
                     "      if (!({0})) {\n        "
                     "return emitOpError(\"region #\") << index << \" {1}"
void OpEmitter::genSuccessorVerifier(OpMethodBody &body) {
   body << "{\n";
   body << "    unsigned index = 0; (void)index;\n";
 
   for (unsigned i = 0; i < numSuccessors; ++i) {
     const auto &successor = op.getSuccessor(i);
     if (successor.constraint.getPredicate().isNull())
       continue;
 
-    body << "    for (Block *successor : ";
-    body << formatv(successor.isVariadic() ? "{0}()"
-                                           : "ArrayRef<Block *>({0}())",
+    body << "    for (::mlir::Block *successor : ";
+    body << formatv(successor.isVariadic()
+                        ? "{0}()"
+                        : "::mlir::ArrayRef<::mlir::Block *>({0}())",
                     successor.name);
     body << ") {\n";
     auto constraint = tgfmt(successor.constraint.getConditionTemplate(),
                             &verifyCtx.withSelf("successor"))
                           .str();
 
     body << formatv("      (void)successor;\n"
                     "      if (!({0})) {\n        "
for (const auto &trait : op.getTraits()) {
     if (auto opTrait = dyn_cast<tblgen::NativeOpTrait>(&trait))
       opClass.addTrait(opTrait->getTrait());
     else if (auto opTrait = dyn_cast<tblgen::InterfaceOpTrait>(&trait))
       opClass.addTrait(opTrait->getTrait());
   }
 }
 
 void OpEmitter::genOpNameGetter() {
-  auto &method = opClass.newMethod("StringRef", "getOperationName",
+  auto &method = opClass.newMethod("::mlir::StringRef", "getOperationName",
                                    /*params=*/"", OpMethod::MP_Static);
   method.body() << "  return \"" << op.getOperationName() << "\";\n";
 }
 
 void OpEmitter::genOpAsmInterface() {
   // If the user only has one results or specifically added the Asm trait,
   // then don't generate it for them. We specifically only handle multi result
   // operations, because the name of a single result in the common case is not
private:
 
   const Operator &op;
   Class adaptor;
 };
 } // end namespace
 
 OpOperandAdaptorEmitter::OpOperandAdaptorEmitter(const Operator &op)
     : op(op), adaptor(op.getAdaptorName()) {
-  adaptor.newField("ValueRange", "odsOperands");
-  adaptor.newField("DictionaryAttr", "odsAttrs");
+  adaptor.newField("::mlir::ValueRange", "odsOperands");
+  adaptor.newField("::mlir::DictionaryAttr", "odsAttrs");
   const auto *attrSizedOperands =
       op.getTrait("OpTrait::AttrSizedOperandSegments");
   {
     auto &constructor = adaptor.newConstructor(
         attrSizedOperands
-            ? "ValueRange values, DictionaryAttr attrs"
-            : "ValueRange values, DictionaryAttr attrs = nullptr");
+            ? "::mlir::ValueRange values, ::mlir::DictionaryAttr attrs"
+            : "::mlir::ValueRange values, ::mlir::DictionaryAttr attrs = "
+              "nullptr");
     constructor.addMemberInitializer("odsOperands", "values");
     constructor.addMemberInitializer("odsAttrs", "attrs");
   }
 
   {
     auto &constructor = adaptor.newConstructor(
         llvm::formatv("{0}& op", op.getCppClassName()).str());
     constructor.addMemberInitializer("odsOperands",
                                      "op.getOperation()->getOperands()");
     constructor.addMemberInitializer("odsAttrs",
                                      "op.getOperation()->getAttrDictionary()");
   }
 
   std::string sizeAttrInit =
       formatv(adapterSegmentSizeAttrInitCode, "operand_segment_sizes");
   generateNamedOperandGetters(op, adaptor, sizeAttrInit,
-                              /*rangeType=*/"ValueRange",
+                              /*rangeType=*/"::mlir::ValueRange",
                               /*rangeBeginCall=*/"odsOperands.begin()",
                               /*rangeSizeCall=*/"odsOperands.size()",
                               /*getOperandCallPattern=*/"odsOperands[{0}]");
 
   FmtContext fctx;
-  fctx.withBuilder("mlir::Builder(odsAttrs.getContext())");
+  fctx.withBuilder("::mlir::Builder(odsAttrs.getContext())");
 
   auto emitAttr = [&](StringRef name, Attribute attr) {
     auto &body = adaptor.newMethod(attr.getStorageType(), name).body();
     body << "  assert(odsAttrs && \"no attributes when constructing adapter\");"
          << "\n  " << attr.getStorageType() << " attr = "
          << "odsAttrs.get(\"" << name << "\").";
     if (attr.hasDefaultValue() || attr.isOptional())
       body << "dyn_cast_or_null<";
if (!attr.isDerivedAttr())
       emitAttr(name, attr);
   }
 
   // Add verification function.
   addVerification();
 }
 
 void OpOperandAdaptorEmitter::addVerification() {
-  auto &method = adaptor.newMethod("LogicalResult", "verify",
-                                   /*params=*/"Location loc");
+  auto &method = adaptor.newMethod("::mlir::LogicalResult", "verify",
+                                   /*params=*/"::mlir::Location loc");
   auto &body = method.body();
 
   const char *checkAttrSizedValueSegmentsCode = R"(
   {
-    auto sizeAttr = odsAttrs.get("{0}").cast<DenseIntElementsAttr>();
-    auto numElements = sizeAttr.getType().cast<ShapedType>().getNumElements();
+    auto sizeAttr = odsAttrs.get("{0}").cast<::mlir::DenseIntElementsAttr>();
+    auto numElements = sizeAttr.getType().cast<::mlir::ShapedType>().getNumElements();
     if (numElements != {1})
       return emitError(loc, "'{0}' attribute for specifying {2} segments "
                        "must have {1} elements");
   }
   )";
 
   // Verify a few traits first so that we can use
   // getODSOperands()/getODSResults() in the rest of the verifier.

mlir/tools/mlir-tblgen/OpFormatGen.cpp

 /// 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"(
   {
-    StringAttr attrVal;
-    NamedAttrList attrStorage;
+    ::mlir::StringAttr attrVal;
+    ::mlir::NamedAttrList attrStorage;
     auto loc = parser.getCurrentLocation();
     if (parser.parseAttribute(attrVal, parser.getBuilder().getNoneType(),
                               "{0}", attrStorage))
       return failure();
 
     auto attrOptional = {1}::{2}(attrVal.getValue());
     if (!attrOptional)
       return parser.emitError(loc, "invalid ")
              << "{0} attribute specification: " << attrVal;
 
     result.addAttribute("{0}", {3});
   }
 )";
 
 /// The code snippet used to generate a parser call for an operand.
 ///
 /// {0}: The name of the operand.
 const char *const variadicOperandParserCode = R"(
   if (parser.parseOperandList({0}Operands))
     return failure();
 )";
 const char *const optionalOperandParserCode = R"(
   {
-    OpAsmParser::OperandType operand;
-    OptionalParseResult parseResult = parser.parseOptionalOperand(operand);
+    ::mlir::OpAsmParser::OperandType operand;
+    ::mlir::OptionalParseResult parseResult =
+                                    parser.parseOptionalOperand(operand);
     if (parseResult.hasValue()) {
       if (failed(*parseResult))
         return failure();
       {0}Operands.push_back(operand);
     }
   }
 )";
 const char *const operandParserCode = R"(
   if (parser.parseOperand({0}RawOperands[0]))
     return 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();
 )";
 const char *const optionalTypeParserCode = R"(
   {
-    Type optionalType;
-    OptionalParseResult parseResult = parser.parseOptionalType(optionalType);
+    ::mlir::Type optionalType;
+    ::mlir::OptionalParseResult parseResult =
+                                    parser.parseOptionalType(optionalType);
     if (parseResult.hasValue()) {
       if (failed(*parseResult))
         return failure();
       {0}Types.push_back(optionalType);
     }
   }
 )";
 const char *const typeParserCode = R"(
   if (parser.parseType({0}RawTypes[0]))
     return 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"(
-  FunctionType {0}__{1}_functionType;
+  ::mlir::FunctionType {0}__{1}_functionType;
   if (parser.parseType({0}__{1}_functionType))
     return failure();
   {0}Types = {0}__{1}_functionType.getInputs();
   {1}Types = {0}__{1}_functionType.getResults();
 )";
 
 /// The code snippet used to generate a parser call for a successor list.
 ///
 /// {0}: The name for the successor list.
 const char *successorListParserCode = R"(
-  SmallVector<Block *, 2> {0}Successors;
+  ::mlir::SmallVector<::mlir::Block *, 2> {0}Successors;
   {
-    Block *succ;
+    ::mlir::Block *succ;
     auto firstSucc = parser.parseOptionalSuccessor(succ);
     if (firstSucc.hasValue()) {
       if (failed(*firstSucc))
         return failure();
       {0}Successors.emplace_back(succ);
 
       // Parse any trailing successors.
       while (succeeded(parser.parseOptionalComma())) {
         if (parser.parseSuccessor(succ))
           return 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"(
-  Block *{0}Successor = nullptr;
+  ::mlir::Block *{0}Successor = nullptr;
   if (parser.parseSuccessor({0}Successor))
     return failure();
 )";
 
 namespace {
 /// The type of length for a given parse argument.
 enum class ArgumentLengthKind {
   /// The argument is variadic, and may contain 0->N elements.

 /// Generate the storage code required for parsing the given element.
 static void genElementParserStorage(Element *element, OpMethodBody &body) {
   if (auto *optional = dyn_cast<OptionalElement>(element)) {
     for (auto &childElement : optional->getElements())
       genElementParserStorage(&childElement, body);
   } else if (auto *operand = dyn_cast<OperandVariable>(element)) {
     StringRef name = operand->getVar()->name;
     if (operand->getVar()->isVariableLength()) {
-      body << "  SmallVector<OpAsmParser::OperandType, 4> " << name
-           << "Operands;\n";
+      body << "  ::mlir::SmallVector<::mlir::OpAsmParser::OperandType, 4> "
+           << name << "Operands;\n";
     } else {
-      body << "  OpAsmParser::OperandType " << name << "RawOperands[1];\n"
-           << "  ArrayRef<OpAsmParser::OperandType> " << name << "Operands("
-           << name << "RawOperands);";
+      body << "  ::mlir::OpAsmParser::OperandType " << name
+           << "RawOperands[1];\n"
+           << "  ::mlir::ArrayRef<::mlir::OpAsmParser::OperandType> " << name
+           << "Operands(" << name << "RawOperands);";
     }
     body << llvm::formatv(
-        "  llvm::SMLoc {0}OperandsLoc = parser.getCurrentLocation();\n"
+        "  ::llvm::SMLoc {0}OperandsLoc = parser.getCurrentLocation();\n"
         "  (void){0}OperandsLoc;\n",
         name);
   } else if (auto *dir = dyn_cast<TypeDirective>(element)) {
     ArgumentLengthKind lengthKind;
     StringRef name = getTypeListName(dir->getOperand(), lengthKind);
     if (lengthKind != ArgumentLengthKind::Single)
-      body << "  SmallVector<Type, 1> " << name << "Types;\n";
+      body << "  ::mlir::SmallVector<::mlir::Type, 1> " << name << "Types;\n";
     else
-      body << llvm::formatv("  Type {0}RawTypes[1];\n", name)
-           << llvm::formatv("  ArrayRef<Type> {0}Types({0}RawTypes);\n", name);
+      body << llvm::formatv("  ::mlir::Type {0}RawTypes[1];\n", name)
+           << llvm::formatv(
+                  "  ::mlir::ArrayRef<::mlir::Type> {0}Types({0}RawTypes);\n",
+                  name);
   } else if (auto *dir = dyn_cast<FunctionalTypeDirective>(element)) {
     ArgumentLengthKind ignored;
-    body << "  ArrayRef<Type> " << getTypeListName(dir->getInputs(), ignored)
-         << "Types;\n";
-    body << "  ArrayRef<Type> " << getTypeListName(dir->getResults(), ignored)
-         << "Types;\n";
+    body << "  ::mlir::ArrayRef<::mlir::Type> "
+         << getTypeListName(dir->getInputs(), ignored) << "Types;\n";
+    body << "  ::mlir::ArrayRef<::mlir::Type> "
+         << getTypeListName(dir->getResults(), ignored) << "Types;\n";
   }
 }
 
 /// Generate the parser for a single format element.
 static void genElementParser(Element *element, OpMethodBody &body,
                              FmtContext &attrTypeCtx) {
   /// Optional Group.
   if (auto *optional = dyn_cast<OptionalElement>(element)) {
if (auto *optional = dyn_cast<OptionalElement>(element)) {
 
     /// Directives.
   } else if (auto *attrDict = dyn_cast<AttrDictDirective>(element)) {
     body << "  if (parser.parseOptionalAttrDict"
          << (attrDict->isWithKeyword() ? "WithKeyword" : "")
          << "(result.attributes))\n"
          << "    return failure();\n";
   } else if (isa<OperandsDirective>(element)) {
-    body << "  llvm::SMLoc allOperandLoc = parser.getCurrentLocation();\n"
-         << "  SmallVector<OpAsmParser::OperandType, 4> allOperands;\n"
+    body << "  ::llvm::SMLoc allOperandLoc = parser.getCurrentLocation();\n"
+         << "  ::mlir::SmallVector<::mlir::OpAsmParser::OperandType, 4> "
+            "allOperands;\n"
          << "  if (parser.parseOperandList(allOperands))\n"
          << "    return failure();\n";
   } else if (isa<SuccessorsDirective>(element)) {
     body << llvm::formatv(successorListParserCode, "full");
   } else if (auto *dir = dyn_cast<TypeDirective>(element)) {
     ArgumentLengthKind lengthKind;
     StringRef listName = getTypeListName(dir->getOperand(), lengthKind);
     if (lengthKind == ArgumentLengthKind::Variadic)
body << formatv(functionalTypeParserCode,
                     getTypeListName(dir->getResults(), ignored));
   } else {
     llvm_unreachable("unknown format element");
   }
 }
 
 void OperationFormat::genParser(Operator &op, OpClass &opClass) {
   auto &method = opClass.newMethod(
-      "ParseResult", "parse", "OpAsmParser &parser, OperationState &result",
+      "::mlir::ParseResult", "parse",
+      "::mlir::OpAsmParser &parser, ::mlir::OperationState &result",
       OpMethod::MP_Static);
   auto &body = method.body();
 
   // Generate variables to store the operands and type within the format. This
   // allows for referencing these variables in the presence of optional
   // groupings.
   for (auto &element : elements)
     genElementParserStorage(&*element, body);
for (TypeResolution &resolver :
     if (!transformer)
       continue;
     // Ensure that we don't verify the same variables twice.
     const NamedTypeConstraint *variable = resolver.getVariable();
     if (!verifiedVariables.insert(variable).second)
       continue;
 
     auto constraint = variable->constraint;
-    body << "  for (Type type : " << variable->name << "Types) {\n"
+    body << "  for (::mlir::Type type : " << variable->name << "Types) {\n"
          << "    (void)type;\n"
          << "    if (!("
          << tgfmt(constraint.getConditionTemplate(),
                   &verifierFCtx.withSelf("type"))
          << ")) {\n"
          << formatv("      return parser.emitError(parser.getNameLoc()) << "
                     "\"'{0}' must be {1}, but got \" << type;\n",
                     variable->name, constraint.getDescription())
          << "    }\n"
          << "  }\n";
   }
 
   // Initialize the set of buildable types.
   if (!buildableTypes.empty()) {
     FmtContext typeBuilderCtx;
     typeBuilderCtx.withBuilder("parser.getBuilder()");
     for (auto &it : buildableTypes)
-      body << "  Type odsBuildableType" << it.second << " = "
+      body << "  ::mlir::Type odsBuildableType" << it.second << " = "
            << tgfmt(it.first, &typeBuilderCtx) << ";\n";
   }
 
   // Emit the code necessary for a type resolver.
   auto emitTypeResolver = [&](TypeResolution &resolver, StringRef curVar) {
     if (Optional<int> val = resolver.getBuilderIdx()) {
       body << "odsBuildableType" << *val;
     } else if (const NamedTypeConstraint *var = resolver.getVariable()) {
if (allOperands) {
               "    return 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 OpAsmParser::OperandType>(";
+      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;
   }
   // 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>(";
+      body << "::llvm::concat<const Type>(";
       llvm::interleaveComma(
           llvm::seq<int>(0, op.getNumOperands()), body, [&](int i) {
-            body << "ArrayRef<Type>(";
+            body << "::mlir::ArrayRef<::mlir::Type>(";
             emitTypeResolver(operandTypes[i], op.getOperand(i).name);
             body << ")";
           });
       body << ")";
     } else {
       emitTypeResolver(operandTypes.front(), op.getOperand(0).name);
     }
 
static OpMethodBody &genTypeOperandPrinter(Element *arg, OpMethodBody &body) {
   if (isa<ResultsDirective>(arg))
     return body << "getOperation()->getResultTypes()";
   auto *operand = dyn_cast<OperandVariable>(arg);
   auto *var = operand ? operand->getVar() : cast<ResultVariable>(arg)->getVar();
   if (var->isVariadic())
     return body << var->name << "().getTypes()";
   if (var->isOptional())
     return body << llvm::formatv(
-               "({0}() ? ArrayRef<Type>({0}().getType()) : ArrayRef<Type>())",
+               "({0}() ? ::mlir::ArrayRef<::mlir::Type>({0}().getType()) : "
+               "::mlir::ArrayRef<::mlir::Type>())",
                var->name);
-  return body << "ArrayRef<Type>(" << var->name << "().getType())";
+  return body << "::mlir::ArrayRef<::mlir::Type>(" << var->name
+              << "().getType())";
 }
 
 /// Generate the code for printing the given element.
 static void genElementPrinter(Element *element, OpMethodBody &body,
                               OperationFormat &fmt, Operator &op,
                               bool &shouldEmitSpace, bool &lastWasPunctuation) {
   if (LiteralElement *literal = dyn_cast<LiteralElement>(element))
     return genLiteralPrinter(literal->getLiteral(), body, shouldEmitSpace,
if (auto *attr = dyn_cast<AttributeVariable>(element)) {
 
     // Elide the attribute type if it is buildable.
     if (attr->getTypeBuilder())
       body << "  p.printAttributeWithoutType(" << var->name << "Attr());\n";
     else
       body << "  p.printAttribute(" << var->name << "Attr());\n";
   } else if (auto *operand = dyn_cast<OperandVariable>(element)) {
     if (operand->getVar()->isOptional()) {
-      body << "  if (Value value = " << operand->getVar()->name << "())\n"
+      body << "  if (::mlir::Value value = " << operand->getVar()->name
+           << "())\n"
            << "    p << value;\n";
     } else {
       body << "  p << " << operand->getVar()->name << "();\n";
     }
   } else if (auto *successor = dyn_cast<SuccessorVariable>(element)) {
     const NamedSuccessor *var = successor->getVar();
     if (var->isVariadic())
-      body << "  llvm::interleaveComma(" << var->name << "(), p);\n";
+      body << "  ::llvm::interleaveComma(" << var->name << "(), p);\n";
     else
       body << "  p << " << var->name << "();\n";
   } else if (isa<OperandsDirective>(element)) {
     body << "  p << getOperation()->getOperands();\n";
   } else if (isa<SuccessorsDirective>(element)) {
-    body << "  llvm::interleaveComma(getOperation()->getSuccessors(), p);\n";
+    body << "  ::llvm::interleaveComma(getOperation()->getSuccessors(), p);\n";
   } else if (auto *dir = dyn_cast<TypeDirective>(element)) {
     body << "  p << ";
     genTypeOperandPrinter(dir->getOperand(), body) << ";\n";
   } else if (auto *dir = dyn_cast<FunctionalTypeDirective>(element)) {
     body << "  p.printFunctionalType(";
     genTypeOperandPrinter(dir->getInputs(), body) << ", ";
     genTypeOperandPrinter(dir->getResults(), body) << ");\n";
   } else {

 }
 
 //===----------------------------------------------------------------------===//
 // FormatParser
 //===----------------------------------------------------------------------===//
 
 /// Function to find an element within the given range that has the same name as
 /// 'name'.
-template <typename RangeT> static auto findArg(RangeT &&range, StringRef name) {
+template <typename RangeT>
+static auto findArg(RangeT &&range, StringRef name) {
   auto it = llvm::find_if(range, [=](auto &arg) { return arg.name == name; });
   return it != range.end() ? &*it : nullptr;
 }
 
 namespace {
 /// This class implements a parser for an instance of an operation assembly
 /// format.
 class FormatParser {

mlir/tools/mlir-tblgen/OpInterfacesGen.cpp

static void emitModelDecl(OpInterface &interface, raw_ostream &os) {
   // Insert each of the virtual method overrides.
   for (auto &method : interface.getMethods()) {
     os << "    " << method.getReturnType() << " ";
     emitMethodNameAndArgs(method, os, /*addOperationArg=*/!method.isStatic());
     os << " final {\n";
 
     // Provide a definition of the concrete op if this is non static.
     if (!method.isStatic()) {
-      os << "      auto op = llvm::cast<ConcreteOp>(tablegen_opaque_op);\n"
+      os << "      auto op = ::mlir::cast<ConcreteOp>(tablegen_opaque_op);\n"
          << "      (void)op;\n";
     }
 
     // Check for a provided body to the function.
     if (auto body = method.getBody()) {
       os << body << "\n    }\n";
       continue;
     }
static void emitModelDecl(OpInterface &interface, raw_ostream &os) {
   }
   os << "  };\n";
 }
 
 static void emitTraitDecl(OpInterface &interface, raw_ostream &os,
                           StringRef interfaceName,
                           StringRef interfaceTraitsName) {
   os << "  template <typename ConcreteOp>\n  "
-     << llvm::formatv("struct {0}Trait : public OpInterface<{0},"
+     << llvm::formatv("struct {0}Trait : public ::mlir::OpInterface<{0},"
                       " detail::{1}>::Trait<ConcreteOp> {{\n",
                       interfaceName, interfaceTraitsName);
 
   // Insert the default implementation for any methods.
   for (auto &method : interface.getMethods()) {
     // Flag interface methods named verifyTrait.
     if (method.getName() == "verifyTrait")
       PrintFatalError(
           formatv("'verifyTrait' method cannot be specified as interface "
                   "method for '{0}'; set 'verify' on OpInterfaceTrait instead",
                   interfaceName));
     auto defaultImpl = method.getDefaultImplementation();
     if (!defaultImpl)
       continue;
 
     os << "  " << (method.isStatic() ? "static " : "") << method.getReturnType()
        << " ";
     emitMethodNameAndArgs(method, os, /*addOperationArg=*/false);
     os << " {\n" << defaultImpl.getValue() << "  }\n";
   }
 
   tblgen::FmtContext traitCtx;
   traitCtx.withOp("op");
   if (auto verify = interface.getVerify()) {
-    os << "    static LogicalResult verifyTrait(Operation* op) {\n"
+    os << "    static ::mlir::LogicalResult verifyTrait(Operation* op) {\n"
        << std::string(tblgen::tgfmt(*verify, &traitCtx)) << "\n  }\n";
   }
   if (auto extraTraitDecls = interface.getExtraTraitClassDeclaration())
     os << extraTraitDecls << "\n";
 
   os << "  };\n";
 
   // Emit a utility wrapper trait class.
static void emitInterfaceDecl(OpInterface &interface, raw_ostream &os) {
   // Emit the traits struct containing the concept and model declarations.
   os << "namespace detail {\n"
      << "struct " << interfaceTraitsName << " {\n";
   emitConceptDecl(interface, os);
   emitModelDecl(interface, os);
   os << "};\n} // end namespace detail\n";
 
   // Emit the main interface class declaration.
-  os << llvm::formatv("class {0} : public OpInterface<{1}, detail::{2}> {\n"
-                      "public:\n"
-                      "  using OpInterface<{1}, detail::{2}>::OpInterface;\n",
-                      interfaceName, interfaceName, interfaceTraitsName);
+  os << llvm::formatv(
+      "class {0} : public ::mlir::OpInterface<{1}, detail::{2}> {\n"
+      "  using ::mlir::OpInterface<{1}, detail::{2}>::OpInterface;\n",
 
   // Emit the derived trait for the interface.
   emitTraitDecl(interface, os, interfaceName, interfaceTraitsName);
 
   // Insert the method declarations.
   for (auto &method : interface.getMethods()) {
     os << "  " << method.getReturnType() << " ";
     emitMethodNameAndArgs(method, os, /*addOperationArg=*/false);

mlir/tools/mlir-tblgen/PassGen.cpp

 
 template <typename DerivedT>
 class {0}Base : public {1} {
 public:
   {0}Base() : {1}(::mlir::TypeID::get<DerivedT>()) {{}
   {0}Base(const {0}Base &) : {1}(::mlir::TypeID::get<DerivedT>()) {{}
 
   /// Returns the command-line argument attached to this pass.
-  llvm::StringRef getArgument() const override { return "{2}"; }
+  ::mlir::StringRef getArgument() const override { return "{2}"; }
 
   /// Returns the derived pass name.
-  llvm::StringRef getName() const override { return "{0}"; }
+  ::mlir::StringRef getName() const override { return "{0}"; }
 
   /// Support isa/dyn_cast functionality for the derived pass class.
   static bool classof(const ::mlir::Pass *pass) {{
     return pass->getTypeID() == ::mlir::TypeID::get<DerivedT>();
   }
 
   /// A clone method to create a copy of this pass.
   std::unique_ptr<::mlir::Pass> clonePass() const override {{
     return std::make_unique<DerivedT>(*static_cast<const DerivedT *>(this));
   }
 
 protected:
 )";
 
 /// Emit the declarations for each of the pass options.
 static void emitPassOptionDecls(const Pass &pass, raw_ostream &os) {
   for (const PassOption &opt : pass.getOptions()) {
-    os.indent(2) << "Pass::" << (opt.isListOption() ? "ListOption" : "Option");
+    os.indent(2) << "::mlir::Pass::"
+                 << (opt.isListOption() ? "ListOption" : "Option");
 
-    os << llvm::formatv("<{0}> {1}{{*this, \"{2}\", llvm::cl::desc(\"{3}\")",
+    os << llvm::formatv("<{0}> {1}{{*this, \"{2}\", ::llvm::cl::desc(\"{3}\")",
                         opt.getType(), opt.getCppVariableName(),
                         opt.getArgument(), opt.getDescription());
     if (Optional<StringRef> defaultVal = opt.getDefaultValue())
-      os << ", llvm::cl::init(" << defaultVal << ")";
+      os << ", ::llvm::cl::init(" << defaultVal << ")";
     if (Optional<StringRef> additionalFlags = opt.getAdditionalFlags())
       os << ", " << *additionalFlags;
     os << "};\n";
   }
 }
 
 /// Emit the declarations for each of the pass statistics.
 static void emitPassStatisticDecls(const Pass &pass, raw_ostream &os) {
   for (const PassStatistic &stat : pass.getStatistics()) {
-    os << llvm::formatv("  Pass::Statistic {0}{{this, \"{1}\", \"{2}\"};\n",
-                        stat.getCppVariableName(), stat.getName(),
-                        stat.getDescription());
+    os << llvm::formatv(
+        "  ::mlir::Pass::Statistic {0}{{this, \"{1}\", \"{2}\"};\n",
+        stat.getCppVariableName(), stat.getName(), stat.getDescription());
   }
 }
 
 static void emitPassDecl(const Pass &pass, raw_ostream &os) {
   StringRef defName = pass.getDef()->getName();
   os << llvm::formatv(passDeclBegin, defName, pass.getBaseClass(),
                       pass.getArgument());
   emitPassOptionDecls(pass, os);

mlir/tools/mlir-tblgen/RewriterGen.cpp

 
 using llvm::formatv;
 using llvm::Record;
 using llvm::RecordKeeper;
 
 #define DEBUG_TYPE "mlir-tblgen-rewritergen"
 
 namespace llvm {
-template <> struct format_provider<mlir::tblgen::Pattern::IdentifierLine> {
+template <>
+struct format_provider<mlir::tblgen::Pattern::IdentifierLine> {
   static void format(const mlir::tblgen::Pattern::IdentifierLine &v,
                      raw_ostream &os, StringRef style) {
     os << v.first << ":" << v.second;
   }
 };
 } // end namespace llvm
 
 //===----------------------------------------------------------------------===//
for (unsigned i = 0, e = pattern.getNumResultPatterns(); i != e; ++i) {
     collectOps(pattern.getResultPattern(i), resultOps);
   }
   LLVM_DEBUG(llvm::dbgs() << "done collecting ops used in result patterns\n");
 
   // Emit RewritePattern for Pattern.
   auto locs = pattern.getLocation();
   os << formatv("/* Generated from:\n\t{0:$[ instantiating\n\t]}\n*/\n",
                 make_range(locs.rbegin(), locs.rend()));
-  os << formatv(R"(struct {0} : public RewritePattern {
-  {0}(MLIRContext *context)
-      : RewritePattern("{1}", {{)",
+  os << formatv(R"(struct {0} : public ::mlir::RewritePattern {
+  {0}(::mlir::MLIRContext *context)
+      : ::mlir::RewritePattern("{1}", {{)",
                 rewriteName, rootName);
   // Sort result operators by name.
   llvm::SmallVector<const Operator *, 4> sortedResultOps(resultOps.begin(),
                                                          resultOps.end());
   llvm::sort(sortedResultOps, [&](const Operator *lhs, const Operator *rhs) {
     return lhs->getOperationName() < rhs->getOperationName();
   });
   llvm::interleaveComma(sortedResultOps, os, [&](const Operator *op) {
     os << '"' << op->getOperationName() << '"';
   });
   os << formatv(R"(}, {0}, context) {{})", pattern.getBenefit()) << "\n";
 
   // Emit matchAndRewrite() function.
   os << R"(
-  LogicalResult matchAndRewrite(Operation *op0,
-                                     PatternRewriter &rewriter) const override {
+  ::mlir::LogicalResult
+  matchAndRewrite(::mlir::Operation *op0,
+                  ::mlir::PatternRewriter &rewriter) const override {
 )";
 
   // Register all symbols bound in the source pattern.
   pattern.collectSourcePatternBoundSymbols(symbolInfoMap);
 
   LLVM_DEBUG(
       llvm::dbgs() << "start creating local variables for capturing matches\n");
   os.indent(4) << "// Variables for capturing values and attributes used for "
                   "creating ops\n";
   // Create local variables for storing the arguments and results bound
   // to symbols.
   for (const auto &symbolInfoPair : symbolInfoMap) {
     StringRef symbol = symbolInfoPair.getKey();
     auto &info = symbolInfoPair.getValue();
     os.indent(4) << info.getVarDecl(symbol);
   }
   // TODO(jpienaar): capture ops with consistent numbering so that it can be
   // reused for fused loc.
-  os.indent(4) << formatv("Operation *tblgen_ops[{0}];\n\n",
+  os.indent(4) << formatv("::mlir::Operation *tblgen_ops[{0}];\n\n",
                           pattern.getSourcePattern().getNumOps());
   LLVM_DEBUG(
       llvm::dbgs() << "done creating local variables for capturing matches\n");
 
   os.indent(4) << "// Match\n";
   os.indent(4) << "tblgen_ops[0] = op0;\n";
   emitMatchLogic(sourceTree);
   os << "\n";
void PatternEmitter::emitRewriteLogic() {
 
   if (numExpectedResults == 0) {
     assert(replStartIndex >= numResultPatterns &&
            "invalid auxiliary vs. replacement pattern division!");
     // No result to replace. Just erase the op.
     os.indent(4) << "rewriter.eraseOp(op0);\n";
   } else {
     // Process replacement result patterns.
-    os.indent(4) << "SmallVector<Value, 4> tblgen_repl_values;\n";
+    os.indent(4)
+        << "::mlir::SmallVector<::mlir::Value, 4> tblgen_repl_values;\n";
     for (int i = replStartIndex; i < numResultPatterns; ++i) {
       DagNode resultTree = pattern.getResultPattern(i);
       auto val = handleResultPattern(resultTree, offsets[i], 0);
       os.indent(4) << "\n";
       // Resolve each symbol for all range use so that we can loop over them.
       // We need an explicit cast to `SmallVector` to capture the cases where
       // `{0}` resolves to an `Operation::result_range` as well as cases that
       // are not iterable (e.g. vector that gets wrapped in additional braces by
       // RewriterGen).
       // TODO(b/147096809): Revisit the need for materializing a vector.
       os << symbolInfoMap.getAllRangeUse(
           val,
-          "    for (auto v : SmallVector<Value, 4>{ {0} }) {{ "
+          "    for (auto v : ::mlir::SmallVector<::mlir::Value, 4>{ {0} }) {{ "
           "tblgen_repl_values.push_back(v); }",
           "\n");
     }
     os.indent(4) << "\n";
     os.indent(4) << "rewriter.replaceOp(op0, tblgen_repl_values);\n";
   }
 
   LLVM_DEBUG(llvm::dbgs() << "--- done emitting rewrite logic ---\n");
llvm::PrintFatalError(
         "At least one argument to location directive required");
 
   if (!tree.getSymbol().empty())
     PrintFatalError(loc, "cannot bind symbol to location");
 
   if (tree.getNumArgs() == 1) {
     DagLeaf leaf = tree.getArgAsLeaf(0);
     if (leaf.isStringAttr())
-      return formatv("mlir::NameLoc::get(rewriter.getIdentifier(\"{0}\"), "
+      return formatv("::mlir::NameLoc::get(rewriter.getIdentifier(\"{0}\"), "
                      "rewriter.getContext())",
                      leaf.getStringAttr())
           .str();
     return lookUpArgLoc(0);
   }
 
   std::string ret;
   llvm::raw_string_ostream os(ret);
std::string PatternEmitter::handleOpCreation(DagNode tree, int resultIndex,
   // pattern's value types to determine the value type of the generated op
   // here.
 
   // First prepare local variables for op arguments used in builder call.
   createAggregateLocalVarsForOpArgs(tree, childNodeNames);
 
   // Then prepare the result types. We need to specify the types for all
   // results.
-  os.indent(6) << formatv(
-      "SmallVector<Type, 4> tblgen_types; (void)tblgen_types;\n");
+  os.indent(6) << formatv("::mlir::SmallVector<::mlir::Type, 4> tblgen_types; "
+                          "(void)tblgen_types;\n");
   int numResults = resultOp.getNumResults();
   if (numResults != 0) {
     for (int i = 0; i < numResults; ++i)
       os.indent(6) << formatv("for (auto v : castedOp0.getODSResults({0})) {{"
                               "tblgen_types.push_back(v.getType()); }\n",
                               resultIndex + i);
   }
   os.indent(6) << formatv("{0} = rewriter.create<{1}>({2}, tblgen_types, "
for (int argIndex = 0, e = resultOp.getNumArgs(); argIndex < e; ++argIndex) {
     if (!operand) {
       // We do not need special handling for attributes.
       continue;
     }
 
     std::string varName;
     if (operand->isVariadic()) {
       varName = std::string(formatv("tblgen_values_{0}", valueIndex++));
-      os.indent(6) << formatv("SmallVector<Value, 4> {0};\n", varName);
+      os.indent(6) << formatv("::mlir::SmallVector<::mlir::Value, 4> {0};\n",
+                              varName);
       std::string range;
       if (node.isNestedDagArg(argIndex)) {
         range = childNodeNames[argIndex];
       } else {
         range = std::string(node.getArgName(argIndex));
       }
       // Resolve the symbol for all range use so that we have a uniform way of
       // capturing the values.
       range = symbolInfoMap.getValueAndRangeUse(range);
       os.indent(6) << formatv("for (auto v : {0}) {1}.push_back(v);\n", range,
                               varName);
     } else {
       varName = std::string(formatv("tblgen_value_{0}", valueIndex++));
-      os.indent(6) << formatv("Value {0} = ", varName);
+      os.indent(6) << formatv("::mlir::Value {0} = ", varName);
       if (node.isNestedDagArg(argIndex)) {
         os << symbolInfoMap.getValueAndRangeUse(childNodeNames[argIndex]);
       } else {
         DagLeaf leaf = node.getArgAsLeaf(argIndex);
         auto symbol =
             symbolInfoMap.getValueAndRangeUse(node.getArgName(argIndex));
         if (leaf.isNativeCodeCall()) {
           os << std::string(
for (int argIndex = 0, numOpArgs = resultOp.getNumArgs();
     }
   }
 }
 
 void PatternEmitter::createAggregateLocalVarsForOpArgs(
     DagNode node, const ChildNodeIndexNameMap &childNodeNames) {
   Operator &resultOp = node.getDialectOp(opMap);
 
-  os.indent(6) << formatv(
-      "SmallVector<Value, 4> tblgen_values; (void)tblgen_values;\n");
-  os.indent(6) << formatv(
-      "SmallVector<NamedAttribute, 4> tblgen_attrs; (void)tblgen_attrs;\n");
+  os.indent(6) << formatv("::mlir::SmallVector<::mlir::Value, 4> "
+                          "tblgen_values; (void)tblgen_values;\n");
+  os.indent(6) << formatv("::mlir::SmallVector<::mlir::NamedAttribute, 4> "
+                          "tblgen_attrs; (void)tblgen_attrs;\n");
 
   const char *addAttrCmd =
       "if (auto tmpAttr = {1}) "
       "tblgen_attrs.emplace_back(rewriter.getIdentifier(\"{0}\"), tmpAttr);\n";
   for (int argIndex = 0, e = resultOp.getNumArgs(); argIndex < e; ++argIndex) {
     if (resultOp.getArg(argIndex).is<NamedAttribute *>()) {
       // The argument in the op definition.
       auto opArgName = resultOp.getArgName(argIndex);

mlir/tools/mlir-tblgen/StructsGen.cpp

 using mlir::tblgen::StructAttr;
 
 static void
 emitStructClass(const Record &structDef, StringRef structName,
                 llvm::ArrayRef<mlir::tblgen::StructFieldAttr> fields,
                 StringRef description, raw_ostream &os) {
   const char *structInfo = R"(
 // {0}
-class {1} : public mlir::DictionaryAttr)";
+class {1} : public ::mlir::DictionaryAttr)";
   const char *structInfoEnd = R"( {
 public:
-  using DictionaryAttr::DictionaryAttr;
-  static bool classof(mlir::Attribute attr);
+  using ::mlir::DictionaryAttr::DictionaryAttr;
+  static bool classof(::mlir::Attribute attr);
 )";
   os << formatv(structInfo, description, structName) << structInfoEnd;
 
   // Declares a constructor function for the tablegen structure.
   //   TblgenStruct::get(MLIRContext context, Type1 Field1, Type2 Field2, ...);
   const char *getInfoDecl = "  static {0} get(\n";
   const char *getInfoDeclArg = "      {0} {1},\n";
-  const char *getInfoDeclEnd = "      mlir::MLIRContext* context);\n\n";
+  const char *getInfoDeclEnd = "      ::mlir::MLIRContext* context);\n\n";
 
   os << llvm::formatv(getInfoDecl, structName);
 
   for (auto field : fields) {
     auto name = field.getName();
     auto type = field.getType();
     auto storage = type.getStorageType();
     os << llvm::formatv(getInfoDeclArg, storage, name);
static bool emitStructDecls(const RecordKeeper &recordKeeper, raw_ostream &os) {
   return false;
 }
 
 static void emitFactoryDef(llvm::StringRef structName,
                            llvm::ArrayRef<mlir::tblgen::StructFieldAttr> fields,
                            raw_ostream &os) {
   const char *getInfoDecl = "{0} {0}::get(\n";
   const char *getInfoDeclArg = "    {0} {1},\n";
-  const char *getInfoDeclEnd = "    mlir::MLIRContext* context) {";
+  const char *getInfoDeclEnd = "    ::mlir::MLIRContext* context) {";
 
   os << llvm::formatv(getInfoDecl, structName);
 
   for (auto field : fields) {
     auto name = field.getName();
     auto type = field.getType();
     auto storage = type.getStorageType();
     os << llvm::formatv(getInfoDeclArg, storage, name);
   }
   os << getInfoDeclEnd;
 
   const char *fieldStart = R"(
-  llvm::SmallVector<mlir::NamedAttribute, {0}> fields;
+  ::mlir::SmallVector<::mlir::NamedAttribute, {0}> fields;
 )";
   os << llvm::formatv(fieldStart, fields.size());
 
   const char *getFieldInfo = R"(
   assert({0});
-  auto {0}_id = mlir::Identifier::get("{0}", context);
+  auto {0}_id = ::mlir::Identifier::get("{0}", context);
   fields.emplace_back({0}_id, {0});
 )";
 
   const char *getFieldInfoOptional = R"(
   if ({0}) {
-    auto {0}_id = mlir::Identifier::get("{0}", context);
+    auto {0}_id = ::mlir::Identifier::get("{0}", context);
     fields.emplace_back({0}_id, {0});
   }
 )";
 
   for (auto field : fields) {
     if (field.getType().isOptional())
       os << llvm::formatv(getFieldInfoOptional, field.getName());
     else
       os << llvm::formatv(getFieldInfo, field.getName());
   }
 
   const char *getEndInfo = R"(
-  Attribute dict = mlir::DictionaryAttr::get(fields, context);
+  ::mlir::Attribute dict = ::mlir::DictionaryAttr::get(fields, context);
   return dict.dyn_cast<{0}>();
 }
 )";
   os << llvm::formatv(getEndInfo, structName);
 }
 
 static void emitClassofDef(llvm::StringRef structName,
                            llvm::ArrayRef<mlir::tblgen::StructFieldAttr> fields,
                            raw_ostream &os) {
   const char *classofInfo = R"(
-bool {0}::classof(mlir::Attribute attr))";
+bool {0}::classof(::mlir::Attribute attr))";
 
   const char *classofInfoHeader = R"(
   if (!attr)
     return false;
-  auto derived = attr.dyn_cast<mlir::DictionaryAttr>();
+  auto derived = attr.dyn_cast<::mlir::DictionaryAttr>();
   if (!derived)
     return false;
   int empty_optionals = 0;
 )";
 
   os << llvm::formatv(classofInfo, structName) << " {";
   os << llvm::formatv(classofInfoHeader);
 

 }
 
 static void
 emitAccessorDef(llvm::StringRef structName,
                 llvm::ArrayRef<mlir::tblgen::StructFieldAttr> fields,
                 raw_ostream &os) {
   const char *fieldInfo = R"(
 {0} {2}::{1}() const {
-  auto derived = this->cast<mlir::DictionaryAttr>();
+  auto derived = this->cast<::mlir::DictionaryAttr>();
   auto {1} = derived.get("{1}");
   assert({1} && "attribute not found.");
   assert({1}.isa<{0}>() && "incorrect Attribute type found.");
   return {1}.cast<{0}>();
 }
 )";
   const char *fieldInfoOptional = R"(
 {0} {2}::{1}() const {
-  auto derived = this->cast<mlir::DictionaryAttr>();
+  auto derived = this->cast<::mlir::DictionaryAttr>();
   auto {1} = derived.get("{1}");
   if (!{1})
     return nullptr;
   assert({1}.isa<{0}>() && "incorrect Attribute type found.");
   return {1}.cast<{0}>();
 }
 )";
   for (auto field : fields) {

mlir/unittests/TableGen/EnumsGenTest.cpp

 //===- EnumsGenTest.cpp - TableGen EnumsGen Tests -------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Support/LLVM.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "gmock/gmock.h"
 #include <type_traits>
 
 // Pull in generated enum utility declarations
 #include "EnumsGenTest.h.inc"
 // And definitions
 #include "EnumsGenTest.cpp.inc"
 
 // Test namespaces and enum class/utility names
 using Outer::Inner::ConvertToEnum;
 using Outer::Inner::ConvertToString;
 using Outer::Inner::StrEnum;