[MLIR] Move TestDialect to ::test namespace

[stephenneuendorffer]

Summary

While the changes are extensive, they basically fall into a few
categories:

1. Moving the TestDialect itself.
2. Updating C++ code in tablegen to explicitly use ::mlir, since it

will be put in a headers that shouldn't expect a 'using'.

3. Updating some generic MLIR Interface definitions to do the same thing.
4. Updating the Tablegen generator in a few places to be explicit about

namespaces

5. Doing the same thing for llvm references, since we no longer pick

up the definitions from mlir/Support/LLVM.h

[mehdi_amini]

LGTM on the principle, whenever you get it to work :)

[mehdi_amini]

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

24–25

River mentioned to me that a good tradeoff would be to keep the using namespace mlir; but move it after the point where we include all the TableGen generated stuff.

That way all the manually written code in this file does not need to be clobbered with mlir:: everywhere.

[stephenneuendorffer]

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

24–25

Agreed, I'm more concerned about the tablegen'd stuff being broken right now.

[stephenneuendorffer]

Yeah, still broken.

mlir/include/mlir/IR/BuiltinOps.td

let extraClassDeclaration = [{
 
     //===------------------------------------------------------------------===//
     // CallableOpInterface
     //===------------------------------------------------------------------===//
 
     /// Returns the region on the current operation that is callable. This may
     /// return null in the case of an external callable object, e.g. an external
     /// function.
-    Region *getCallableRegion() { return isExternal() ? nullptr : &getBody(); }
+    ::mlir::Region *getCallableRegion() { return isExternal() ? nullptr : &getBody(); }
 
     /// Returns the results types that the callable region produces when
     /// executed.
     ArrayRef<Type> getCallableResults() { return getType().getResults(); }
 
     //===------------------------------------------------------------------===//
     // SymbolOpInterface Methods
     //===------------------------------------------------------------------===//

mlir/include/mlir/IR/OpBase.td

class DerivedAttr<code ret, code b, code convert = ""> :
   // * `$_builder` will be replaced by a mlir::Builder instance.
   // * `$_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> {
+class DerivedTypeAttr<code body> : DerivedAttr<"::mlir::Type", body> {
   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

mlir/include/mlir/IR/RegionKindInterface.td

def RegionKindInterface : OpInterface<"RegionKindInterface"> {
   }];
   let cppNamespace = "::mlir";
 
   let methods = [
     StaticInterfaceMethod<
       /*desc=*/[{
         Return the kind of the region with the given index inside this operation.
       }],
-      /*retTy=*/"RegionKind",
+      /*retTy=*/"::mlir::RegionKind",
       /*methodName=*/"getRegionKind",
       /*args=*/(ins "unsigned":$index)
     >,
     StaticInterfaceMethod<
       /*desc=*/"Return true if the kind of the given region requires the "
                "SSA-Dominance property",
       /*retTy=*/"bool",
       /*methodName=*/"hasSSADominance",
       /*args=*/(ins "unsigned":$index),
       /*methodBody=*/[{
-        return getRegionKind(index) == RegionKind::SSACFG;
+        return getRegionKind(index) == ::mlir::RegionKind::SSACFG;
       }]
     >,
   ];
 }
 
 def HasOnlyGraphRegion : NativeOpTrait<"HasOnlyGraphRegion">;
 
 // Op's regions that don't need a terminator: requires some other traits

mlir/include/mlir/Interfaces/InferTypeOpInterface.td

InterfaceMethod<
 
         Insert operations using the given `OpBuilder` that computes
         the result shape. The `reifiedReturnShapes` is expected to be
         populated with as many vectors as the number of results of the
         op. Each of these vectors is expected to be of size equal to
         rank of the corresponding result. If the shape of a particular
         result cannot be computed it must be empty.
       }],
-      /*retTy=*/"LogicalResult",
+      /*retTy=*/"::mlir::LogicalResult",
       /*methodName=*/"reifyResultShapes",
       /*args=*/(ins "::mlir::OpBuilder &":$builder,
-        "ReifiedRankedShapedTypeDims &":$reifiedReturnShapes)
+        "::mlir::ReifiedRankedShapedTypeDims &":$reifiedReturnShapes)
     >
   ];
 }
 
 #endif // MLIR_INFERTYPEOPINTERFACE

mlir/test/lib/Dialect/Test/TestAttributes.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
-using namespace mlir::test;
+using namespace test;
 
 //===----------------------------------------------------------------------===//
 // AttrWithSelfTypeParamAttr
 //===----------------------------------------------------------------------===//
 
 Attribute AttrWithSelfTypeParamAttr::parse(MLIRContext *context,
                                            DialectAsmParser &parser,
                                            Type type) {

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

 #include "TestOpEnums.h.inc"
 #include "TestOpInterfaces.h.inc"
 #include "TestOpStructs.h.inc"
 #include "TestOpsDialect.h.inc"
 
 #define GET_OP_CLASSES
 #include "TestOps.h.inc"
 
-namespace mlir {
 namespace test {
-void registerTestDialect(DialectRegistry &registry);
-void populateTestReductionPatterns(RewritePatternSet &patterns);
-} // namespace test
-} // namespace mlir
+void registerTestDialect(::mlir::DialectRegistry &registry);
+void populateTestReductionPatterns(::mlir::RewritePatternSet &patterns);
+} // end namespace test
 
 #endif // MLIR_TESTDIALECT_H

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

 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Reducer/ReductionPatternInterface.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/InliningUtils.h"
 #include "llvm/ADT/StringSwitch.h"
 
-using namespace mlir;
-using namespace mlir::test;
-
+// Include this before the using namespace lines below to
+// test that we don't have namespace dependencies.
 #include "TestOpsDialect.cpp.inc"
 
-void mlir::test::registerTestDialect(DialectRegistry &registry) {
+using namespace mlir;
+using namespace test;
+
+void test::registerTestDialect(DialectRegistry &registry) {
   registry.insert<TestDialect>();
 }
 
 //===----------------------------------------------------------------------===//
 // TestDialect Interfaces
 //===----------------------------------------------------------------------===//
 
 namespace {

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

 //===-- TestInterfaces.td - Test dialect interfaces --------*- tablegen -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_TEST_DIALECT_TEST_INTERFACES
 #define MLIR_TEST_DIALECT_TEST_INTERFACES
 
 include "mlir/IR/OpBase.td"
 include "mlir/Interfaces/SideEffectInterfaceBase.td"
 
 // A type interface used to test the ODS generation of type interfaces.
 def TestTypeInterface : TypeInterface<"TestTypeInterface"> {
-  let cppNamespace = "::mlir::test";
+  let cppNamespace = "::test";
   let methods = [
     InterfaceMethod<"Prints the type name.",
-      "void", "printTypeA", (ins "Location":$loc), [{
+      "void", "printTypeA", (ins "::mlir::Location":$loc), [{
         emitRemark(loc) << $_type << " - TestA";
       }]
     >,
     InterfaceMethod<"Prints the type name.",
-      "void", "printTypeB", (ins "Location":$loc),
+      "void", "printTypeB", (ins "::mlir::Location":$loc),
       [{}], /*defaultImplementation=*/[{
         emitRemark(loc) << $_type << " - TestB";
       }]
     >,
     InterfaceMethod<"Prints the type name.",
-      "void", "printTypeC", (ins "Location":$loc)
+      "void", "printTypeC", (ins "::mlir::Location":$loc)
     >,
     // It should be possible to use the interface type name as result type
     // as well as in the implementation.
     InterfaceMethod<"Prints the type name and returns the type as interface.",
-      "TestTypeInterface", "printTypeRet", (ins "Location":$loc),
+      "TestTypeInterface", "printTypeRet", (ins "::mlir::Location":$loc),
       [{}], /*defaultImplementation=*/[{
         emitRemark(loc) << $_type << " - TestRet";
         return $_type;
       }]
     >,
   ];
   let extraClassDeclaration = [{
     /// Prints the type name.
-    void printTypeD(Location loc) const {
+    void printTypeD(::mlir::Location loc) const {
       emitRemark(loc) << *this << " - TestD";
     }
   }];
   let extraTraitClassDeclaration = [{
     /// Prints the type name.
-    void printTypeE(Location loc) const {
+    void printTypeE(::mlir::Location loc) const {
       emitRemark(loc) << $_type << " - TestE";
     }
   }];
 }
 
 def TestExternalTypeInterface : TypeInterface<"TestExternalTypeInterface"> {
   let cppNamespace = "::mlir";
   let methods = [

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

 include "mlir/Interfaces/CopyOpInterface.td"
 include "mlir/Interfaces/DataLayoutInterfaces.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 include "TestInterfaces.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
-  let cppNamespace = "::mlir::test";
+  let cppNamespace = "::test";
   let hasCanonicalizer = 1;
   let hasConstantMaterializer = 1;
   let hasOperationAttrVerify = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
   let hasOperationInterfaceFallback = 1;
   let hasNonDefaultDestructor = 1;
   let dependentDialects = ["::mlir::DLTIDialect"];
 
   let extraClassDeclaration = [{
     void registerAttributes();
     void registerTypes();
 
-    Attribute parseAttribute(DialectAsmParser &parser,
-                             Type type) const override;
-    void printAttribute(Attribute attr,
-                        DialectAsmPrinter &printer) const override;
+    ::mlir::Attribute parseAttribute(::mlir::DialectAsmParser &parser,
+                             ::mlir::Type type) const override;
+    void printAttribute(::mlir::Attribute attr,
+                        ::mlir::DialectAsmPrinter &printer) const override;
 
     // Provides a custom printing/parsing for some operations.
-    Optional<ParseOpHook>
-      getParseOperationHook(StringRef opName) const override;
-    LogicalResult printOperation(Operation *op,
-                                 OpAsmPrinter &printer) const override;
+    ::llvm::Optional<ParseOpHook>
+      getParseOperationHook(::llvm::StringRef opName) const override;
+    ::mlir::LogicalResult printOperation(::mlir::Operation *op,
+                                 ::mlir::OpAsmPrinter &printer) const override;
   private:
     // Storage for a custom fallback interface.
     void *fallbackEffectOpInterfaces;
 
   }];
 }
 
 class TEST_Op<string mnemonic, list<OpTrait> traits = []> :

 
 def MultiTensorRankOf : TEST_Op<"multi_tensor_rank_of"> {
   let arguments = (ins
     TensorRankOf<[I8, I32, F32], [0, 1]>:$arg0
   );
 }
 
 def TEST_TestType : DialectType<Test_Dialect,
-    CPred<"$_self.isa<::mlir::test::TestType>()">, "test">,
-    BuildableType<"$_builder.getType<::mlir::test::TestType>()">;
+    CPred<"$_self.isa<::test::TestType>()">, "test">,
+    BuildableType<"$_builder.getType<::test::TestType>()">;
 
 //===----------------------------------------------------------------------===//
 // Test Symbols
 //===----------------------------------------------------------------------===//
 
 def SymbolOp : TEST_Op<"symbol", [Symbol]> {
   let summary =  "operation which defines a new symbol";
   let arguments = (ins StrAttr:$sym_name,
def ConversionCallOp : TEST_Op<"conversion_call_op",
   let arguments = (ins Variadic<AnyType>:$inputs, SymbolRefAttr:$callee);
   let results = (outs Variadic<AnyType>);
 
   let extraClassDeclaration = [{
     /// Get the argument operands to the called function.
     operand_range getArgOperands() { return inputs(); }
 
     /// Return the callee of this operation.
-    CallInterfaceCallable getCallableForCallee() {
-      return (*this)->getAttrOfType<SymbolRefAttr>("callee");
+    ::mlir::CallInterfaceCallable getCallableForCallee() {
+      return (*this)->getAttrOfType<::mlir::SymbolRefAttr>("callee");
     }
   }];
 }
 
 def FunctionalRegionOp : TEST_Op<"functional_region_op",
     [CallableOpInterface]> {
   let regions = (region AnyRegion:$body);
   let results = (outs FunctionType);
 
   let extraClassDeclaration = [{
-    Region *getCallableRegion() { return &body(); }
-    ArrayRef<Type> getCallableResults() {
-      return getType().cast<FunctionType>().getResults();
+    ::mlir::Region *getCallableRegion() { return &body(); }
+    ::llvm::ArrayRef<::mlir::Type> getCallableResults() {
+      return getType().cast<::mlir::FunctionType>().getResults();
     }
   }];
 }
 
 
 def FoldToCallOp : TEST_Op<"fold_to_call_op"> {
   let arguments = (ins FlatSymbolRefAttr:$callee);
   let hasCanonicalizer = 1;

 
 // Test for memrefs normalization of an op with a reference to a function
 // symbol.
 def OpFuncRef : TEST_Op<"op_funcref"> {
   let summary = "Test op with a reference to a function symbol";
   let description = [{
     The "test.op_funcref" is a test op with a reference to a function symbol.
   }];
-  let builders = [OpBuilder<(ins "FuncOp":$function)>];
+  let builders = [OpBuilder<(ins "::mlir::FuncOp":$function)>];
 }
 
 // Pattern add the argument plus a increasing static number hidden in
 // OpMTest function. That value is set into the optional argument.
 // That way, we will know if operations is called once or twice.
 def OpMGetNullAttr : NativeCodeCall<"Attribute()">;
 def OpMAttributeIsNull : Constraint<CPred<"! ($_self)">, "Attribute is null">;
 def OpMVal : NativeCodeCall<"OpMTest($_builder, $0)">;
def OpAllAttrConstraint1 : TEST_Op<"all_attr_constraint_of1"> {
   let results = (outs I32);
 }
 def OpAllAttrConstraint2 : TEST_Op<"all_attr_constraint_of2"> {
   let arguments = (ins I64ArrayAttr:$attr);
   let results = (outs I32);
 }
 def Constraint0 : AttrConstraint<
     CPred<"$_self.cast<ArrayAttr>()[0]."
-          "cast<IntegerAttr>().getInt() == 0">,
+          "cast<::mlir::IntegerAttr>().getInt() == 0">,
     "[0] == 0">;
 def Constraint1 : AttrConstraint<
-    CPred<"$_self.cast<ArrayAttr>()[1].cast<IntegerAttr>().getInt() == 1">,
+    CPred<"$_self.cast<ArrayAttr>()[1].cast<::mlir::IntegerAttr>().getInt() == 1">,
     "[1] == 1">;
 def : Pat<(OpAllAttrConstraint1
             AllAttrConstraintsOf<[Constraint0, Constraint1]>:$attr),
           (OpAllAttrConstraint2 $attr)>;
 
 // Op for testing RewritePattern removing op with inner ops.
 def TestOpWithRegionPattern : TEST_Op<"op_with_region_pattern"> {
   let regions = (region SizedRegion<1>:$region);
   let hasCanonicalizer = 1;
 }
 
 def TestOpConstant : TEST_Op<"constant", [ConstantLike, NoSideEffect]> {
   let arguments = (ins AnyAttr:$value);
   let results = (outs AnyType);
   let extraClassDeclaration = [{
-    Attribute getValue() { return (*this)->getAttr("value"); }
+    ::mlir::Attribute getValue() { return (*this)->getAttr("value"); }
   }];
 
   let hasFolder = 1;
 }
 
 def OpR : TEST_Op<"op_r">, Arguments<(ins AnyInteger, AnyInteger)>, Results<(outs AnyInteger)>;
 def OpS : TEST_Op<"op_s">, Arguments<(ins AnyInteger, AnyAttr:$value)>, Results<(outs AnyInteger)>;
 
let results = (outs
     I32:$output1,
     Variadic<I32>:$output2,
     Variadic<I32>:$output3
   );
 
   // We will use this op in a nested result pattern, where we cannot deduce the
   // result type. So need to provide a builder not requiring result types.
   let builders = [
-    OpBuilder<(ins "IntegerAttr":$count),
+    OpBuilder<(ins "::mlir::IntegerAttr":$count),
     [{
       auto i32Type = $_builder.getIntegerType(32);
       $_state.addTypes(i32Type); // $output1
       SmallVector<Type, 4> types(count.getInt(), i32Type);
       $_state.addTypes(types); // $output2
       $_state.addTypes(types); // $output3
       $_state.addAttribute("count", count);
     }]>
def CopyOp : TEST_Op<"copy", [CopyOpInterface]> {
   }];
   let arguments = (ins Res<AnyRankedOrUnrankedMemRef, "", [MemRead]>:$source,
                    Res<AnyRankedOrUnrankedMemRef, "", [MemWrite]>:$target);
   let assemblyFormat = [{
     `(` $source `,` $target `)` `:` `(` type($source) `,` type($target) `)`
      attr-dict
   }];
   let extraClassDeclaration = [{
-    Value getSource() { return source(); }
-    Value getTarget() { return target(); }
+    ::mlir::Value getSource() { return source(); }
+    ::mlir::Value getTarget() { return target(); }
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Test Buffer/Tensor
 //===----------------------------------------------------------------------===//
 
 def RegionYieldOp : TEST_Op<"region_yield",
def RegionIfOp : TEST_Op<"region_if",
   let printer = [{ return ::print(p, *this); }];
   let parser = [{ return ::parseRegionIfOp(parser, result); }];
   let arguments = (ins Variadic<AnyType>);
   let results = (outs Variadic<AnyType>:$results);
   let regions = (region SizedRegion<1>:$thenRegion,
                         AnyRegion:$elseRegion,
                         AnyRegion:$joinRegion);
   let extraClassDeclaration = [{
-    Block::BlockArgListType getThenArgs() {
+    ::mlir::Block::BlockArgListType getThenArgs() {
       return getBody(0)->getArguments();
     }
-    Block::BlockArgListType getElseArgs() {
+    ::mlir::Block::BlockArgListType getElseArgs() {
       return getBody(1)->getArguments();
     }
-    Block::BlockArgListType getJoinArgs() {
+    ::mlir::Block::BlockArgListType getJoinArgs() {
       return getBody(2)->getArguments();
     }
-    OperandRange getSuccessorEntryOperands(unsigned index);
+    ::mlir::OperandRange getSuccessorEntryOperands(unsigned index);
   }];
 }
 
 //===----------------------------------------------------------------------===//
 // Test TableGen generated build() methods
 //===----------------------------------------------------------------------===//
 
 def TableGenConstant : TEST_Op<"tblgen_constant"> {

 // Tests suppression of ambiguous build methods for operations with
 // SameOperandsAndResultType and InferTypeOpInterface.
 def TableGenBuildOp5 : TEST_Op<"tblgen_build_5",
       [SameOperandsAndResultType, InferTypeOpInterface]> {
   let arguments = (ins Variadic<AnyType>:$inputs);
   let results = (outs AnyType:$result);
 
   let extraClassDeclaration = [{
-    static LogicalResult inferReturnTypes(MLIRContext *,
-          Optional<Location> location, ValueRange operands,
-          DictionaryAttr attributes, RegionRange regions,
-          SmallVectorImpl<Type> &inferredReturnTypes) {
+    static ::mlir::LogicalResult inferReturnTypes(::mlir::MLIRContext *,
+          ::llvm::Optional<::mlir::Location> location, ::mlir::ValueRange operands,
+          ::mlir::DictionaryAttr attributes, ::mlir::RegionRange regions,
+          ::llvm::SmallVectorImpl<::mlir::Type> &inferredReturnTypes) {
       inferredReturnTypes.assign({operands[0].getType()});
-      return success();
+      return ::mlir::success();
     }
    }];
 }
 
 //===----------------------------------------------------------------------===//
 // Test BufferPlacement
 //===----------------------------------------------------------------------===//
 

mlir/test/lib/Dialect/Test/TestPatterns.cpp

 #include "mlir/Dialect/Tensor/IR/Tensor.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/DialectConversion.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
-using namespace mlir::test;
+using namespace test;
 
 // Native function for testing NativeCodeCall
 static Value chooseOperand(Value input1, Value input2, BoolAttr choice) {
   return choice.getValue() ? input1 : input2;
 }
 
 static void createOpI(PatternRewriter &rewriter, Location loc, Value input) {
   rewriter.create<OpI>(loc, input);

 namespace {
 #include "TestPatterns.inc"
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // Test Reduce Pattern Interface
 //===----------------------------------------------------------------------===//
 
-void mlir::test::populateTestReductionPatterns(RewritePatternSet &patterns) {
+void test::populateTestReductionPatterns(RewritePatternSet &patterns) {
   populateWithGenerated(patterns);
 }
 
 //===----------------------------------------------------------------------===//
 // Canonicalizer Driver.
 //===----------------------------------------------------------------------===//
 
 namespace {

mlir/test/lib/Dialect/Test/TestTraits.cpp

 //===- TestTraits.cpp - Test trait folding --------------------------------===//
 //
 // 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 "TestDialect.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 using namespace mlir;
-using namespace mlir::test;
+using namespace test;
 
 //===----------------------------------------------------------------------===//
 // Trait Folder.
 //===----------------------------------------------------------------------===//
 
 OpFoldResult TestInvolutionTraitFailingOperationFolderOp::fold(
     ArrayRef<Attribute> operands) {
   // This failure should cause the trait fold to run instead.

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

 // An example of how one could implement a standard integer.
 def IntegerType : Test_Type<"TestInteger"> {
   let mnemonic = "int";
   let genVerifyDecl = 1;
   let parameters = (
     ins
     "unsigned":$width,
     // SignednessSemantics is defined below.
-    "::mlir::test::TestIntegerType::SignednessSemantics":$signedness
+    "::test::TestIntegerType::SignednessSemantics":$signedness
   );
 
   // We define the printer inline.
   let printer = [{
     $_printer << "int<";
     printSignedness($_printer, getImpl()->signedness);
     $_printer << ", " << getImpl()->width << ">";
   }];
def IntegerType : Test_Type<"TestInteger"> {
   let parser = [{
     if (parser.parseLess()) return Type();
     SignednessSemantics signedness;
     if (parseSignedness($_parser, signedness)) return mlir::Type();
     if ($_parser.parseComma()) return Type();
     int width;
     if ($_parser.parseInteger(width)) return Type();
     if ($_parser.parseGreater()) return Type();
-    Location loc = $_parser.getEncodedSourceLoc($_parser.getNameLoc());
+    ::mlir::Location loc = $_parser.getEncodedSourceLoc($_parser.getNameLoc());
     return getChecked(loc, loc.getContext(), width, signedness);
   }];
 
   // Any extra code one wants in the type's class declaration.
   let extraClassDeclaration = [{
     /// Signedness semantics.
     enum SignednessSemantics {
       Signless, /// No signedness semantics

 // A parent type for any type which is just a list of fields (e.g. structs,
 // unions).
 class FieldInfo_Type<string name> : Test_Type<name> {
   let parameters = (
     ins
     // An ArrayRef of something which requires allocation in the storage
     // constructor.
     ArrayRefOfSelfAllocationParameter<
-      "::mlir::test::FieldInfo", // FieldInfo is defined/declared in TestTypes.h.
+      "::test::FieldInfo", // FieldInfo is defined/declared in TestTypes.h.
       "Models struct fields">: $fields
   );
 
   // Prints the type in this format:
   //   struct<[{field1Name, field1Type}, {field2Name, field2Type}]
   let printer = [{
     $_printer << "struct" << "<";
     for (size_t i=0, e = getImpl()->fields.size(); i < e; i++) {
       const auto& field = getImpl()->fields[i];
       $_printer << "{" << field.name << "," << field.type << "}";
       if (i < getImpl()->fields.size() - 1)
           $_printer << ",";
     }
     $_printer << ">";
   }];
 
   // Parses the above format
   let parser = [{
     llvm::SmallVector<FieldInfo, 4> parameters;
     if ($_parser.parseLess()) return Type();
     while (mlir::succeeded($_parser.parseOptionalLBrace())) {
-      StringRef name;
+      llvm::StringRef name;
       if ($_parser.parseKeyword(&name)) return Type();
       if ($_parser.parseComma()) return Type();
       Type type;
       if ($_parser.parseType(type)) return Type();
       if ($_parser.parseRBrace()) return Type();
       parameters.push_back(FieldInfo {name, type});
       if ($_parser.parseOptionalComma()) break;
     }

 }
 
 def TestTypeWithLayoutType : Test_Type<"TestTypeWithLayout", [
   DeclareTypeInterfaceMethods<DataLayoutTypeInterface, ["areCompatible"]>
 ]> {
   let mnemonic = "test_type_with_layout";
   let parameters = (ins "unsigned":$key);
   let extraClassDeclaration = [{
-    LogicalResult verifyEntries(DataLayoutEntryListRef params,
-                                Location loc) const;
+    ::mlir::LogicalResult verifyEntries(::mlir::DataLayoutEntryListRef params,
+                                ::mlir::Location loc) const;
 
   private:
-    unsigned extractKind(DataLayoutEntryListRef params,
-                         StringRef expectedKind) const;
+    unsigned extractKind(::mlir::DataLayoutEntryListRef params,
+                         ::llvm::StringRef expectedKind) const;
 
   public:
   }];
 }
 
 def TestMemRefElementType : Test_Type<"TestMemRefElementType",
                                       [MemRefElementTypeInterface]> {
   let mnemonic = "memref_element";
 }
 
 #endif // TEST_TYPEDEFS

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

 
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/Operation.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Interfaces/DataLayoutInterfaces.h"
 
-namespace mlir {
 namespace test {
 
 /// FieldInfo represents a field in the StructType data type. It is used as a
 /// parameter in TestTypeDefs.td.
 struct FieldInfo {
-  StringRef name;
-  Type type;
+  ::llvm::StringRef name;
+  ::mlir::Type type;
 
   // Custom allocation called from generated constructor code
-  FieldInfo allocateInto(TypeStorageAllocator &alloc) const {
+  FieldInfo allocateInto(::mlir::TypeStorageAllocator &alloc) const {
     return FieldInfo{alloc.copyInto(name), type};
   }
 };
 
 } // namespace test
-} // namespace mlir
 
 #include "TestTypeInterfaces.h.inc"
 
 #define GET_TYPEDEF_CLASSES
 #include "TestTypeDefs.h.inc"
 
-namespace mlir {
 namespace test {
 
 /// Storage for simple named recursive types, where the type is identified by
 /// its name and can "contain" another type, including itself.
-struct TestRecursiveTypeStorage : public TypeStorage {
-  using KeyTy = StringRef;
+struct TestRecursiveTypeStorage : public ::mlir::TypeStorage {
+  using KeyTy = ::llvm::StringRef;
 
-  explicit TestRecursiveTypeStorage(StringRef key) : name(key), body(Type()) {}
+  explicit TestRecursiveTypeStorage(::llvm::StringRef key) : name(key), body(::mlir::Type()) {}
 
   bool operator==(const KeyTy &other) const { return name == other; }
 
-  static TestRecursiveTypeStorage *construct(TypeStorageAllocator &allocator,
+  static TestRecursiveTypeStorage *construct(::mlir::TypeStorageAllocator &allocator,
                                              const KeyTy &key) {
     return new (allocator.allocate<TestRecursiveTypeStorage>())
         TestRecursiveTypeStorage(allocator.copyInto(key));
   }
 
-  LogicalResult mutate(TypeStorageAllocator &allocator, Type newBody) {
+  ::mlir::LogicalResult mutate(::mlir::TypeStorageAllocator &allocator, ::mlir::Type newBody) {
     // Cannot set a different body than before.
     if (body && body != newBody)
-      return failure();
+      return ::mlir::failure();
 
     body = newBody;
-    return success();
+    return ::mlir::success();
   }
 
-  StringRef name;
-  Type body;
+  ::llvm::StringRef name;
+  ::mlir::Type body;
 };
 
 /// Simple recursive type identified by its name and pointing to another named
 /// type, potentially itself. This requires the body to be mutated separately
 /// from type creation.
 class TestRecursiveType
-    : public Type::TypeBase<TestRecursiveType, Type, TestRecursiveTypeStorage> {
+    : public ::mlir::Type::TypeBase<TestRecursiveType, ::mlir::Type, TestRecursiveTypeStorage> {
 public:
   using Base::Base;
 
-  static TestRecursiveType get(MLIRContext *ctx, StringRef name) {
+  static TestRecursiveType get(::mlir::MLIRContext *ctx, ::llvm::StringRef name) {
     return Base::get(ctx, name);
   }
 
   /// Body getter and setter.
-  LogicalResult setBody(Type body) { return Base::mutate(body); }
-  Type getBody() { return getImpl()->body; }
+  ::mlir::LogicalResult setBody(Type body) { return Base::mutate(body); }
+  ::mlir::Type getBody() { return getImpl()->body; }
 
   /// Name/key getter.
-  StringRef getName() { return getImpl()->name; }
+  ::llvm::StringRef getName() { return getImpl()->name; }
 };
 
 } // namespace test
-} // namespace mlir
 
 #endif // MLIR_TESTTYPES_H

mlir/test/lib/Dialect/Test/TestTypes.cpp

 #include "mlir/IR/Builders.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
-using namespace mlir::test;
+using namespace test;
 
 // Custom parser for SignednessSemantics.
 static ParseResult
 parseSignedness(DialectAsmParser &parser,
                 TestIntegerType::SignednessSemantics &result) {
   StringRef signStr;
   auto loc = parser.getCurrentLocation();
   if (parser.parseKeyword(&signStr))
case TestIntegerType::SignednessSemantics::Signless:
     printer << "none";
     break;
   }
 }
 
 // The functions don't need to be in the header file, but need to be in the mlir
 // namespace. Declare them here, then define them immediately below. Separating
 // the declaration and definition adheres to the LLVM coding standards.
-namespace mlir {
 namespace test {
 // FieldInfo is used as part of a parameter, so equality comparison is
 // compulsory.
 static bool operator==(const FieldInfo &a, const FieldInfo &b);
 // FieldInfo is used as part of a parameter, so a hash will be computed.
 static llvm::hash_code hash_value(const FieldInfo &fi); // NOLINT
 } // namespace test
-} // namespace mlir
 
 // FieldInfo is used as part of a parameter, so equality comparison is
 // compulsory.
-static bool mlir::test::operator==(const FieldInfo &a, const FieldInfo &b) {
+static bool test::operator==(const FieldInfo &a, const FieldInfo &b) {
   return a.name == b.name && a.type == b.type;
 }
 
 // FieldInfo is used as part of a parameter, so a hash will be computed.
-static llvm::hash_code mlir::test::hash_value(const FieldInfo &fi) { // NOLINT
+static llvm::hash_code test::hash_value(const FieldInfo &fi) { // NOLINT
   return llvm::hash_combine(fi.name, fi.type);
 }
 
 //===----------------------------------------------------------------------===//
 // CompoundAType
 //===----------------------------------------------------------------------===//
 
 Type CompoundAType::parse(MLIRContext *ctxt, DialectAsmParser &parser) {

mlir/test/lib/IR/TestInterfaces.cpp

 //===- TestInterfaces.cpp - Test interface generation and application -----===//
 //
 // 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 "TestTypes.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
-using namespace mlir::test;
+using namespace test;
 
 namespace {
 /// This test checks various aspects of Type interface generation and
 /// application.
 struct TestTypeInterfaces
     : public PassWrapper<TestTypeInterfaces, OperationPass<ModuleOp>> {
   StringRef getArgument() const final { return "test-type-interfaces"; }
   StringRef getDescription() const final {

mlir/test/lib/IR/TestTypes.cpp

 //===- TestTypes.cpp - Test passes for MLIR types -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "TestTypes.h"
 #include "TestDialect.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
-using namespace mlir::test;
+using namespace test;
 
 namespace {
 struct TestRecursiveTypesPass
     : public PassWrapper<TestRecursiveTypesPass, FunctionPass> {
   LogicalResult createIRWithTypes();
 
   StringRef getArgument() const final { return "test-recursive-types"; }
   StringRef getDescription() const final {

mlir/test/lib/Transforms/TestInlining.cpp

 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Transforms/InliningUtils.h"
 #include "mlir/Transforms/Passes.h"
 #include "llvm/ADT/StringSet.h"
 
 using namespace mlir;
-using namespace mlir::test;
+using namespace test;
 
 namespace {
 struct Inliner : public PassWrapper<Inliner, FunctionPass> {
   StringRef getArgument() const final { return "test-inline"; }
   StringRef getDescription() const final {
     return "Test inlining region calls";
   }
 

mlir/test/mlir-tblgen/attrdefs.td

 // RUN: mlir-tblgen -gen-attrdef-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
 // RUN: mlir-tblgen -gen-attrdef-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
 
 include "mlir/IR/OpBase.td"
 
 // DECL: #ifdef GET_ATTRDEF_CLASSES
 // DECL: #undef GET_ATTRDEF_CLASSES
 
 // DECL: namespace mlir {
 // DECL: class DialectAsmParser;
 // DECL: class DialectAsmPrinter;
 // DECL: } // namespace mlir
 
 // DEF: #ifdef GET_ATTRDEF_LIST
 // DEF: #undef GET_ATTRDEF_LIST
-// DEF: ::mlir::test::SimpleAAttr,
-// DEF: ::mlir::test::CompoundAAttr,
-// DEF: ::mlir::test::IndexAttr,
-// DEF: ::mlir::test::SingleParameterAttr
+// DEF: ::test::SimpleAAttr,
+// DEF: ::test::CompoundAAttr,
+// DEF: ::test::IndexAttr,
+// DEF: ::test::SingleParameterAttr
 
 // DEF-LABEL: ::mlir::OptionalParseResult generatedAttributeParser(::mlir::MLIRContext *context,
 // DEF-NEXT: ::mlir::DialectAsmParser &parser,
 // DEF-NEXT: ::llvm::StringRef mnemonic, ::mlir::Type type,
 // DEF-NEXT: ::mlir::Attribute &value) {
-// DEF: if (mnemonic == ::mlir::test::CompoundAAttr::getMnemonic()) {
-// DEF-NEXT: value = ::mlir::test::CompoundAAttr::parse(context, parser, type);
+// DEF: if (mnemonic == ::test::CompoundAAttr::getMnemonic()) {
+// DEF-NEXT: value = ::test::CompoundAAttr::parse(context, parser, type);
 // DEF-NEXT: return ::mlir::success(!!value);
 // DEF-NEXT: }
-// DEF-NEXT: if (mnemonic == ::mlir::test::IndexAttr::getMnemonic()) {
-// DEF-NEXT:   value = ::mlir::test::IndexAttr::parse(context, parser, type);
+// DEF-NEXT: if (mnemonic == ::test::IndexAttr::getMnemonic()) {
+// DEF-NEXT:   value = ::test::IndexAttr::parse(context, parser, type);
 // DEF-NEXT:   return ::mlir::success(!!value);
 // DEF: return {};
 
 def Test_Dialect: Dialect {
 // DECL-NOT: TestDialect
 // DEF-NOT: TestDialect
     let name = "TestDialect";
-    let cppNamespace = "::mlir::test";
+    let cppNamespace = "::test";
 }
 
 class TestAttr<string name> : AttrDef<Test_Dialect, name> { }
 
 def A_SimpleAttrA : TestAttr<"SimpleA"> {
 // DECL: class SimpleAAttr : public ::mlir::Attribute
 }
 
 // A more complex parameterized type
 def B_CompoundAttrA : TestAttr<"CompoundA"> {
   let summary = "A more complex parameterized attribute";
   let description = "This attribute is to test a reasonably complex attribute";
   let mnemonic = "cmpnd_a";
   let parameters = (
       ins
       "int":$widthOfSomething,
-      "::mlir::test::SimpleTypeA": $exampleTdType,
+      "::test::SimpleTypeA": $exampleTdType,
       APFloatParameter<"">: $apFloat,
       ArrayRefParameter<"int", "Matrix dimensions">:$dims,
       AttributeSelfTypeParameter<"">:$inner
   );
 
   let genVerifyDecl = 1;
 
 // DECL-LABEL: class CompoundAAttr : public ::mlir::Attribute
-// DECL: static CompoundAAttr getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int widthOfSomething, ::mlir::test::SimpleTypeA exampleTdType, ::llvm::APFloat apFloat, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
-// DECL: static ::mlir::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int widthOfSomething, ::mlir::test::SimpleTypeA exampleTdType, ::llvm::APFloat apFloat, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
+// DECL: static CompoundAAttr getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int widthOfSomething, ::test::SimpleTypeA exampleTdType, ::llvm::APFloat apFloat, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
+// DECL: static ::mlir::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int widthOfSomething, ::test::SimpleTypeA exampleTdType, ::llvm::APFloat apFloat, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
 // DECL: static constexpr ::llvm::StringLiteral getMnemonic() {
 // DECL:   return ::llvm::StringLiteral("cmpnd_a");
 // DECL: }
 // DECL: static ::mlir::Attribute parse(::mlir::MLIRContext *context,
 // DECL-NEXT: ::mlir::DialectAsmParser &parser, ::mlir::Type type);
 // DECL: void print(::mlir::DialectAsmPrinter &printer) const;
 // DECL: int getWidthOfSomething() const;
-// DECL: ::mlir::test::SimpleTypeA getExampleTdType() const;
+// DECL: ::test::SimpleTypeA getExampleTdType() const;
 // DECL: ::llvm::APFloat getApFloat() const;
 
 // Check that AttributeSelfTypeParameter is handled properly.
 // DEF-LABEL: struct CompoundAAttrStorage
 // DEF: CompoundAAttrStorage (
 // DEF-NEXT: : ::mlir::AttributeStorage(inner),
 
 // DEF: bool operator==(const KeyTy &tblgenKey) const {

mlir/test/mlir-tblgen/typedefs.td

 // RUN: mlir-tblgen -gen-typedef-decls -I %S/../../include %s | FileCheck %s --check-prefix=DECL
 // RUN: mlir-tblgen -gen-typedef-defs -I %S/../../include %s | FileCheck %s --check-prefix=DEF
 
 include "mlir/IR/OpBase.td"
 
 // DECL: #ifdef GET_TYPEDEF_CLASSES
 // DECL: #undef GET_TYPEDEF_CLASSES
 
 // DECL: namespace mlir {
 // DECL: class DialectAsmParser;
 // DECL: class DialectAsmPrinter;
 // DECL: } // namespace mlir
 
 // DEF: #ifdef GET_TYPEDEF_LIST
 // DEF: #undef GET_TYPEDEF_LIST
-// DEF: ::mlir::test::SimpleAType,
-// DEF: ::mlir::test::CompoundAType,
-// DEF: ::mlir::test::IndexType,
-// DEF: ::mlir::test::SingleParameterType,
-// DEF: ::mlir::test::IntegerType
+// DEF: ::test::SimpleAType,
+// DEF: ::test::CompoundAType,
+// DEF: ::test::IndexType,
+// DEF: ::test::SingleParameterType,
+// DEF: ::test::IntegerType
 
 // DEF-LABEL: ::mlir::OptionalParseResult generatedTypeParser(::mlir::MLIRContext *context,
 // DEF-NEXT: ::mlir::DialectAsmParser &parser,
 // DEF-NEXT: ::llvm::StringRef mnemonic,
 // DEF-NEXT: ::mlir::Type &value) {
-// DEF: if (mnemonic == ::mlir::test::CompoundAType::getMnemonic()) {
-// DEF-NEXT:   value = ::mlir::test::CompoundAType::parse(context, parser);
+// DEF: if (mnemonic == ::test::CompoundAType::getMnemonic()) {
+// DEF-NEXT:   value = ::test::CompoundAType::parse(context, parser);
 // DEF-NEXT:   return ::mlir::success(!!value);
 // DEF-NEXT: }
-// DEF-NEXT: if (mnemonic == ::mlir::test::IndexType::getMnemonic()) {
-// DEF-NEXT:   value = ::mlir::test::IndexType::parse(context, parser);
+// DEF-NEXT: if (mnemonic == ::test::IndexType::getMnemonic()) {
+// DEF-NEXT:   value = ::test::IndexType::parse(context, parser);
 // DEF-NEXT:   return ::mlir::success(!!value);
 // DEF: return {};
 
 def Test_Dialect: Dialect {
 // DECL-NOT: TestDialect
 // DEF-NOT: TestDialect
     let name = "TestDialect";
-    let cppNamespace = "::mlir::test";
+    let cppNamespace = "::test";
 }
 
 class TestType<string name> : TypeDef<Test_Dialect, name> { }
 
 def A_SimpleTypeA : TestType<"SimpleA"> {
 // DECL: class SimpleAType : public ::mlir::Type
 }
 
 def RTLValueType : Type<CPred<"isRTLValueType($_self)">, "Type"> {
   string cppType = "::mlir::Type";
 }
 
 // A more complex parameterized type
 def B_CompoundTypeA : TestType<"CompoundA"> {
   let summary = "A more complex parameterized type";
   let description = "This type is to test a reasonably complex type";
   let mnemonic = "cmpnd_a";
   let parameters = (
       ins
       "int":$widthOfSomething,
-      "::mlir::test::SimpleTypeA": $exampleTdType,
+      "::test::SimpleTypeA": $exampleTdType,
       "SomeCppStruct": $exampleCppType,
       ArrayRefParameter<"int", "Matrix dimensions">:$dims,
       RTLValueType:$inner
   );
 
   let genVerifyDecl = 1;
 
 // DECL-LABEL: class CompoundAType : public ::mlir::Type
-// DECL: static CompoundAType getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int widthOfSomething, ::mlir::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
-// DECL: static ::mlir::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int widthOfSomething, ::mlir::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
+// DECL: static CompoundAType getChecked(llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, ::mlir::MLIRContext *context, int widthOfSomething, ::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
+// DECL: static ::mlir::LogicalResult verify(::llvm::function_ref<::mlir::InFlightDiagnostic()> emitError, int widthOfSomething, ::test::SimpleTypeA exampleTdType, SomeCppStruct exampleCppType, ::llvm::ArrayRef<int> dims, ::mlir::Type inner);
 // DECL: static constexpr ::llvm::StringLiteral getMnemonic() {
 // DECL:   return ::llvm::StringLiteral("cmpnd_a");
 // DECL: }
 // DECL: static ::mlir::Type parse(::mlir::MLIRContext *context,
 // DECL-NEXT: ::mlir::DialectAsmParser &parser);
 // DECL: void print(::mlir::DialectAsmPrinter &printer) const;
 // DECL: int getWidthOfSomething() const;
-// DECL: ::mlir::test::SimpleTypeA getExampleTdType() const;
+// DECL: ::test::SimpleTypeA getExampleTdType() const;
 // DECL: SomeCppStruct getExampleCppType() const;
 }
 
 def C_IndexType : TestType<"Index"> {
     let mnemonic = "index";
 
     let parameters = (
       ins

mlir/tools/mlir-opt/mlir-opt.cpp

 void registerTestCallGraphPass();
 void registerTestConstantFold();
 void registerTestConvVectorization();
 void registerTestGpuSerializeToCubinPass();
 void registerTestGpuSerializeToHsacoPass();
 void registerTestDataLayoutQuery();
 void registerTestDecomposeCallGraphTypes();
 void registerTestDiagnosticsPass();
-void registerTestDialect(DialectRegistry &);
 void registerTestDominancePass();
 void registerTestDynamicPipelinePass();
 void registerTestExpandTanhPass();
 void registerTestComposeSubView();
 void registerTestGpuParallelLoopMappingPass();
 void registerTestIRVisitorsPass();
 void registerTestInterfaces();
 void registerTestLinalgCodegenStrategy();

 void registerTestPDLByteCodePass();
 void registerTestPreparationPassWithAllowedMemrefResults();
 void registerTestRecursiveTypesPass();
 void registerTestSCFUtilsPass();
 void registerTestVectorConversions();
 } // namespace test
 } // namespace mlir
 
+namespace test {
+void registerTestDialect(DialectRegistry &);
+} // namespace test
+
 #ifdef MLIR_INCLUDE_TESTS
 void registerTestPasses() {
   registerConvertToTargetEnvPass();
   registerPassManagerTestPass();
   registerPrintOpAvailabilityPass();
   registerShapeFunctionTestPasses();
   registerSideEffectTestPasses();
   registerSliceAnalysisTestPass();
void registerTestPasses() {
   registerTestReducer();
   registerTestSpirvEntryPointABIPass();
   registerTestSpirvGLSLCanonicalizationPass();
   registerTestSpirvModuleCombinerPass();
   registerTestTraitsPass();
   registerVectorizerTestPass();
   registerTosaTestQuantUtilAPIPass();
 
-  test::registerConvertCallOpPass();
-  test::registerInliner();
-  test::registerMemRefBoundCheck();
-  test::registerPatternsTestPass();
-  test::registerSimpleParametricTilingPass();
-  test::registerTestAffineLoopParametricTilingPass();
-  test::registerTestAliasAnalysisPass();
-  test::registerTestCallGraphPass();
-  test::registerTestConstantFold();
-  test::registerTestDiagnosticsPass();
+  mlir::test::registerConvertCallOpPass();
+  mlir::test::registerInliner();
+  mlir::test::registerMemRefBoundCheck();
+  mlir::test::registerPatternsTestPass();
+  mlir::test::registerSimpleParametricTilingPass();
+  mlir::test::registerTestAffineLoopParametricTilingPass();
+  mlir::test::registerTestAliasAnalysisPass();
+  mlir::test::registerTestCallGraphPass();
+  mlir::test::registerTestConstantFold();
+  mlir::test::registerTestDiagnosticsPass();
 #if MLIR_CUDA_CONVERSIONS_ENABLED
-  test::registerTestGpuSerializeToCubinPass();
+  mlir::test::registerTestGpuSerializeToCubinPass();
 #endif
 #if MLIR_ROCM_CONVERSIONS_ENABLED
-  test::registerTestGpuSerializeToHsacoPass();
+  mlir::test::registerTestGpuSerializeToHsacoPass();
 #endif
-  test::registerTestConvVectorization();
-  test::registerTestDecomposeCallGraphTypes();
-  test::registerTestDataLayoutQuery();
-  test::registerTestDominancePass();
-  test::registerTestDynamicPipelinePass();
-  test::registerTestExpandTanhPass();
-  test::registerTestComposeSubView();
-  test::registerTestGpuParallelLoopMappingPass();
-  test::registerTestIRVisitorsPass();
-  test::registerTestInterfaces();
-  test::registerTestLinalgCodegenStrategy();
-  test::registerTestLinalgDistribution();
-  test::registerTestLinalgElementwiseFusion();
-  test::registerTestPushExpandingReshape();
-  test::registerTestLinalgFusionTransforms();
-  test::registerTestLinalgTensorFusionTransforms();
-  test::registerTestLinalgTiledLoopFusionTransforms();
-  test::registerTestLinalgGreedyFusion();
-  test::registerTestLinalgHoisting();
-  test::registerTestLinalgTileAndFuseSequencePass();
-  test::registerTestLinalgTransforms();
-  test::registerTestLivenessPass();
-  test::registerTestLoopFusion();
-  test::registerTestLoopMappingPass();
-  test::registerTestLoopUnrollingPass();
-  test::registerTestMathAlgebraicSimplificationPass();
-  test::registerTestMathPolynomialApproximationPass();
-  test::registerTestMemRefDependenceCheck();
-  test::registerTestMemRefStrideCalculation();
-  test::registerTestNumberOfBlockExecutionsPass();
-  test::registerTestNumberOfOperationExecutionsPass();
-  test::registerTestOpaqueLoc();
-  test::registerTestPDLByteCodePass();
-  test::registerTestRecursiveTypesPass();
-  test::registerTestSCFUtilsPass();
-  test::registerTestVectorConversions();
+  mlir::test::registerTestConvVectorization();
+  mlir::test::registerTestDecomposeCallGraphTypes();
+  mlir::test::registerTestDataLayoutQuery();
+  mlir::test::registerTestDominancePass();
+  mlir::test::registerTestDynamicPipelinePass();
+  mlir::test::registerTestExpandTanhPass();
+  mlir::test::registerTestComposeSubView();
+  mlir::test::registerTestGpuParallelLoopMappingPass();
+  mlir::test::registerTestIRVisitorsPass();
+  mlir::test::registerTestInterfaces();
+  mlir::test::registerTestLinalgCodegenStrategy();
+  mlir::test::registerTestLinalgDistribution();
+  mlir::test::registerTestLinalgElementwiseFusion();
+  mlir::test::registerTestPushExpandingReshape();
+  mlir::test::registerTestLinalgFusionTransforms();
+  mlir::test::registerTestLinalgTensorFusionTransforms();
+  mlir::test::registerTestLinalgTiledLoopFusionTransforms();
+  mlir::test::registerTestLinalgGreedyFusion();
+  mlir::test::registerTestLinalgHoisting();
+  mlir::test::registerTestLinalgTileAndFuseSequencePass();
+  mlir::test::registerTestLinalgTransforms();
+  mlir::test::registerTestLivenessPass();
+  mlir::test::registerTestLoopFusion();
+  mlir::test::registerTestLoopMappingPass();
+  mlir::test::registerTestLoopUnrollingPass();
+  mlir::test::registerTestMathAlgebraicSimplificationPass();
+  mlir::test::registerTestMathPolynomialApproximationPass();
+  mlir::test::registerTestMemRefDependenceCheck();
+  mlir::test::registerTestMemRefStrideCalculation();
+  mlir::test::registerTestNumberOfBlockExecutionsPass();
+  mlir::test::registerTestNumberOfOperationExecutionsPass();
+  mlir::test::registerTestOpaqueLoc();
+  mlir::test::registerTestPDLByteCodePass();
+  mlir::test::registerTestRecursiveTypesPass();
+  mlir::test::registerTestSCFUtilsPass();
+  mlir::test::registerTestVectorConversions();
 }
 #endif
 
 int main(int argc, char **argv) {
   registerAllPasses();
 #ifdef MLIR_INCLUDE_TESTS
   registerTestPasses();
 #endif
   DialectRegistry registry;
   registerAllDialects(registry);
 #ifdef MLIR_INCLUDE_TESTS
-  test::registerTestDialect(registry);
+  ::test::registerTestDialect(registry);
 #endif
   return mlir::asMainReturnCode(
       mlir::MlirOptMain(argc, argv, "MLIR modular optimizer driver\n", registry,
                         /*preloadDialectsInContext=*/false));
 }

mlir/tools/mlir-reduce/mlir-reduce.cpp

 #include "mlir/IR/Dialect.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/InitAllDialects.h"
 #include "mlir/InitAllPasses.h"
 #include "mlir/Tools/mlir-reduce/MlirReduceMain.h"
 
 using namespace mlir;
 
-namespace mlir {
 namespace test {
 #ifdef MLIR_INCLUDE_TESTS
 void registerTestDialect(DialectRegistry &);
 #endif
 } // namespace test
-} // namespace mlir
 
 int main(int argc, char **argv) {
   registerAllPasses();
 
   DialectRegistry registry;
   registerAllDialects(registry);
 #ifdef MLIR_INCLUDE_TESTS
   test::registerTestDialect(registry);
 #endif
   MLIRContext context(registry);
 
   return failed(mlirReduceMain(argc, argv, context));
 }

mlir/unittests/IR/InterfaceAttachmentTest.cpp

 #include "mlir/IR/BuiltinTypes.h"
 #include "gtest/gtest.h"
 
 #include "../../test/lib/Dialect/Test/TestAttributes.h"
 #include "../../test/lib/Dialect/Test/TestDialect.h"
 #include "../../test/lib/Dialect/Test/TestTypes.h"
 
 using namespace mlir;
-using namespace mlir::test;
+using namespace test;
 
 namespace {
 
 /// External interface model for the integer type. Only provides non-default
 /// methods.
 struct Model
     : public TestExternalTypeInterface::ExternalModel<Model, IntegerType> {
   unsigned getBitwidthPlusArg(Type type, unsigned arg) const {