[mlir] Move TestDialect and its passes to mlir::test namespace.

[pifon2a]

Summary

TestDialect has many operations and they all live in ::mlir namespace.
Sometimes it is not clear whether the ops used in the code for the test passes
belong to Standard or to Test dialects.

Also, with this change it is easier to understand what test passes registered
in mlir-opt are actually passes in mlir/test.

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

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

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

 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
 #include "mlir/Transforms/FoldUtils.h"
 #include "mlir/Transforms/InliningUtils.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace mlir;
+using namespace mlir::test;
 
-void mlir::registerTestDialect(DialectRegistry &registry) {
+void mlir::test::registerTestDialect(DialectRegistry &registry) {
   registry.insert<TestDialect>();
 }
 
 //===----------------------------------------------------------------------===//
 // TestDialect Interfaces
 //===----------------------------------------------------------------------===//
 
 namespace {

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

 include "mlir/Interfaces/CallInterfaces.td"
 include "mlir/Interfaces/ControlFlowInterfaces.td"
 include "mlir/Interfaces/CopyOpInterface.td"
 include "mlir/Interfaces/InferTypeOpInterface.td"
 include "mlir/Interfaces/SideEffectInterfaces.td"
 
 def Test_Dialect : Dialect {
   let name = "test";
-  let cppNamespace = "::mlir";
+  let cppNamespace = "::mlir::test";
   let hasOperationAttrVerify = 1;
   let hasRegionArgAttrVerify = 1;
   let hasRegionResultAttrVerify = 1;
 }
 
 class TEST_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<Test_Dialect, mnemonic, 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::TestType>()">, "test">,
-    BuildableType<"$_builder.getType<::mlir::TestType>()">;
+    CPred<"$_self.isa<::mlir::test::TestType>()">, "test">,
+    BuildableType<"$_builder.getType<::mlir::test::TestType>()">;
 
 //===----------------------------------------------------------------------===//
 // Test Symbols
 //===----------------------------------------------------------------------===//
 
 def SymbolOp : TEST_Op<"symbol", [Symbol]> {
   let summary =  "operation which defines a new symbol";
   let arguments = (ins StrAttr:$sym_name,

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

 #include "mlir/Dialect/StandardOps/Transforms/FuncConversions.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;
 
 // 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
 
 //===----------------------------------------------------------------------===//
 // PassRegistration
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
+namespace test {
 void registerPatternsTestPass() {
   PassRegistration<TestReturnTypeDriver>("test-return-type",
                                          "Run return type functions");
 
   PassRegistration<TestDerivedAttributeDriver>("test-derived-attr",
                                                "Run test derived attributes");
 
   PassRegistration<TestPatternDriver>("test-patterns",
void registerPatternsTestPass() {
   PassRegistration<TestTypeConversionDriver>(
       "test-legalize-type-conversion",
       "Test various type conversion functionalities in DialectConversion");
 
   PassRegistration<TestMergeBlocksPatternDriver>{
       "test-merge-blocks",
       "Test Merging operation in ConversionPatternRewriter"};
 }
+} // namespace test
 } // namespace mlir

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;
 
 //===----------------------------------------------------------------------===//
 // 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 genVerifyInvariantsDecl = 1;
   let parameters = (
     ins
     // SignednessSemantics is defined below.
-    "::mlir::TestIntegerType::SignednessSemantics":$signedness,
+    "::mlir::test::TestIntegerType::SignednessSemantics":$signedness,
     "unsigned":$width
   );
 
   // We define the printer inline.
   let printer = [{
     $_printer << "int<";
     printSignedness($_printer, getImpl()->signedness);
     $_printer << ", " << getImpl()->width << ">";

 // 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::FieldInfo", // FieldInfo is defined/declared in TestTypes.h.
+      "::mlir::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++) {

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"
 
 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;
 
   // Custom allocation called from generated constructor code
   FieldInfo allocateInto(TypeStorageAllocator &alloc) const {
     return FieldInfo{alloc.copyInto(name), type};
   }
 };
 
+} // namespace test
 } // namespace mlir
 
 #define GET_TYPEDEF_CLASSES
 #include "TestTypeDefs.h.inc"
 
 namespace mlir {
+namespace test {
 
 #include "TestTypeInterfaces.h.inc"
 
 /// This class is a simple test type that uses a generated interface.
 struct TestType : public Type::TypeBase<TestType, Type, TypeStorage,
                                         TestTypeInterface::Trait> {
   using Base::Base;
 
public:
   /// Body getter and setter.
   LogicalResult setBody(Type body) { return Base::mutate(body); }
   Type getBody() { return getImpl()->body; }
 
   /// Name/key getter.
   StringRef getName() { return getImpl()->name; }
 };
 
-} // end namespace mlir
+} // namespace test
+} // namespace mlir
 
 #endif // MLIR_TESTTYPES_H

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

 
 #include "TestTypes.h"
 #include "mlir/IR/DialectImplementation.h"
 #include "mlir/IR/Types.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
+using namespace mlir::test;
 
 // Custom parser for SignednessSemantics.
 static ParseResult
 parseSignedness(DialectAsmParser &parser,
                 TestIntegerType::SignednessSemantics &result) {
   StringRef signStr;
   auto loc = parser.getCurrentLocation();
   if (parser.parseKeyword(&signStr))
void CompoundAType::print(DialectAsmPrinter &printer) const {
   llvm::interleaveComma(intArray, printer);
   printer << "]>";
 }
 
 // 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::operator==(const FieldInfo &a, const FieldInfo &b) {
+static bool mlir::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::hash_value(const FieldInfo &fi) { // NOLINT
+static llvm::hash_code mlir::test::hash_value(const FieldInfo &fi) { // NOLINT
   return llvm::hash_combine(fi.name, fi.type);
 }
 
 // Example type validity checker.
 LogicalResult TestIntegerType::verifyConstructionInvariants(
     Location loc, TestIntegerType::SignednessSemantics ss, unsigned int width) {
   if (width > 8)
     return failure();
   return success();
 }
 
 #define GET_TYPEDEF_CLASSES
 #include "TestTypeDefs.cpp.inc"

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;
 
 namespace {
 /// This test checks various aspects of Type interface generation and
 /// application.
 struct TestTypeInterfaces
     : public PassWrapper<TestTypeInterfaces, OperationPass<ModuleOp>> {
   void runOnOperation() override {
     getOperation().walk([](Operation *op) {
       for (Type type : op->getResultTypes()) {
         if (auto testInterface = type.dyn_cast<TestTypeInterface>()) {
           testInterface.printTypeA(op->getLoc());
           testInterface.printTypeB(op->getLoc());
           testInterface.printTypeC(op->getLoc());
           testInterface.printTypeD(op->getLoc());
         }
         if (auto testType = type.dyn_cast<TestType>())
           testType.printTypeE(op->getLoc());
       }
     });
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
+namespace test {
 void registerTestInterfaces() {
   PassRegistration<TestTypeInterfaces> pass("test-type-interfaces",
                                             "Test type interface support.");
 }
+} // namespace test
 } // namespace mlir

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;
 
 namespace {
 struct TestRecursiveTypesPass
     : public PassWrapper<TestRecursiveTypesPass, FunctionPass> {
   LogicalResult createIRWithTypes();
 
   void runOnFunction() override {
     FuncOp func = getFunction();
if (func.getName() == "create") {
       return;
     }
 
     // Unknown key.
     func.emitOpError() << "unexpected function name";
     signalPassFailure();
   }
 };
-} // end namespace
+} // namespace
 
 LogicalResult TestRecursiveTypesPass::createIRWithTypes() {
   MLIRContext *ctx = &getContext();
   FuncOp func = getFunction();
   auto type = TestRecursiveType::get(ctx, "some_long_and_unique_name");
   if (failed(type.setBody(type)))
     return func.emitError("expected to be able to set the type body");
 
LogicalResult TestRecursiveTypesPass::createIRWithTypes() {
   OperationState state(func.getLoc(), "test.dummy_type_test_op");
   state.addTypes(type);
   func.getBody().front().push_front(Operation::create(state));
 
   return success();
 }
 
 namespace mlir {
+namespace test {
 
 void registerTestRecursiveTypesPass() {
   PassRegistration<TestRecursiveTypesPass> reg(
       "test-recursive-types", "Test support for recursive types");
 }
 
-} // end namespace mlir
+} // namespace test
+} // namespace mlir

mlir/test/lib/Transforms/TestAffineLoopParametricTiling.cpp

 #include "mlir/Dialect/Affine/Passes.h"
 #include "mlir/Transforms/LoopUtils.h"
 
 using namespace mlir;
 
 #define DEBUG_TYPE "test-affine-parametric-tile"
 
 namespace {
-
 struct TestAffineLoopParametricTiling
     : public PassWrapper<TestAffineLoopParametricTiling, FunctionPass> {
   void runOnFunction() override;
 };
 } // end anonymous namespace
 
 /// Checks if the function enclosing the loop nest has any arguments passed to
 /// it, which can be used as tiling parameters. Assumes that atleast 'n'
for (SmallVectorImpl<AffineForOp> &band : bands) {
 
     if (failed(
             tilePerfectlyNestedParametric(band, tilingParameters, &tiledNest)))
       return signalPassFailure();
   }
 }
 
 namespace mlir {
+namespace test {
 void registerTestAffineLoopParametricTilingPass() {
   PassRegistration<TestAffineLoopParametricTiling>(
       "test-affine-parametric-tile",
       "Tile affine loops using SSA values as tile sizes");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestCallGraph.cpp

struct TestCallGraphPass
   void runOnOperation() override {
     llvm::errs() << "Testing : " << getOperation().getAttr("test.name") << "\n";
     getAnalysis<CallGraph>().print(llvm::errs());
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
+namespace test {
 void registerTestCallGraphPass() {
   PassRegistration<TestCallGraphPass> pass(
       "test-print-callgraph", "Print the contents of a constructed callgraph.");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestConstantFold.cpp

void TestConstantFold::runOnFunction() {
   // around dead constants.  Check for them now and remove them.
   for (auto *cst : existingConstants) {
     if (cst->use_empty())
       cst->erase();
   }
 }
 
 namespace mlir {
+namespace test {
 void registerTestConstantFold() {
   PassRegistration<TestConstantFold>("test-constant-fold",
                                      "Test operation constant folding");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestConvVectorization.cpp

void TestConvVectorization::runOnOperation() {
 
   // Ensure we drop the marker in the end.
   module.walk([](linalg::LinalgOp op) {
     op.removeAttr(linalg::LinalgTransforms::kLinalgTransformMarker);
   });
 }
 
 namespace mlir {
+namespace test {
 void registerTestConvVectorization() {
   PassRegistration<TestConvVectorization> testTransformPatternsPass(
       "test-conv-vectorization", "Test vectorization of convolutions");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestConvertCallOp.cpp

 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/Pass/Pass.h"
 
 using namespace mlir;
 
 namespace {
 
 class TestTypeProducerOpConverter
-    : public ConvertOpToLLVMPattern<TestTypeProducerOp> {
+    : public ConvertOpToLLVMPattern<test::TestTypeProducerOp> {
 public:
-  using ConvertOpToLLVMPattern<TestTypeProducerOp>::ConvertOpToLLVMPattern;
+  using ConvertOpToLLVMPattern<
+      test::TestTypeProducerOp>::ConvertOpToLLVMPattern;
 
   LogicalResult
   matchAndRewrite(Operation *op, ArrayRef<Value> operands,
                   ConversionPatternRewriter &rewriter) const override {
     rewriter.replaceOpWithNewOp<LLVM::NullOp>(op, getVoidPtrType());
     return success();
   }
 };
 
 class TestConvertCallOp
     : public PassWrapper<TestConvertCallOp, OperationPass<ModuleOp>> {
 public:
   void getDependentDialects(DialectRegistry &registry) const final {
     registry.insert<LLVM::LLVMDialect>();
   }
 
   void runOnOperation() override {
     ModuleOp m = getOperation();
 
     // Populate type conversions.
     LLVMTypeConverter type_converter(m.getContext());
-    type_converter.addConversion([&](TestType type) {
+    type_converter.addConversion([&](test::TestType type) {
       return LLVM::LLVMType::getInt8PtrTy(m.getContext());
     });
 
     // Populate patterns.
     OwningRewritePatternList patterns;
     populateStdToLLVMConversionPatterns(type_converter, patterns);
     patterns.insert<TestTypeProducerOpConverter>(type_converter);
 
     // Set target.
     ConversionTarget target(getContext());
     target.addLegalDialect<LLVM::LLVMDialect>();
-    target.addIllegalDialect<TestDialect>();
+    target.addIllegalDialect<test::TestDialect>();
     target.addIllegalDialect<StandardOpsDialect>();
 
     if (failed(applyPartialConversion(m, target, std::move(patterns))))
       signalPassFailure();
   }
 };
 
 } // namespace
 
 namespace mlir {
+namespace test {
 void registerConvertCallOpPass() {
   PassRegistration<TestConvertCallOp>(
       "test-convert-call-op",
       "Tests conversion of `std.call` to `llvm.call` in "
       "presence of custom types");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestConvertGPUKernelToCubin.cpp

 //===- TestConvertGPUKernelToCubin.cpp - Test gpu kernel cubin lowering ---===//
 //
 // 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/Conversion/GPUCommon/GPUCommonPass.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Target/NVVMIR.h"
 #include "llvm/Support/TargetSelect.h"
+
 using namespace mlir;
 
 #if MLIR_CUDA_CONVERSIONS_ENABLED
 static OwnedBlob compilePtxToCubinForTesting(const std::string &, Location,
                                              StringRef) {
   const char data[] = "CUBIN";
   return std::make_unique<std::vector<char>>(data, data + sizeof(data) - 1);
 }
 
 namespace mlir {
+namespace test {
 void registerTestConvertGPUKernelToCubinPass() {
   PassPipelineRegistration<>(
       "test-kernel-to-cubin",
       "Convert all kernel functions to CUDA cubin blobs",
       [](OpPassManager &pm) {
         // Initialize LLVM NVPTX backend.
         LLVMInitializeNVPTXTarget();
         LLVMInitializeNVPTXTargetInfo();
         LLVMInitializeNVPTXTargetMC();
         LLVMInitializeNVPTXAsmPrinter();
 
         pm.addPass(createConvertGPUKernelToBlobPass(
             translateModuleToNVVMIR, compilePtxToCubinForTesting,
             "nvptx64-nvidia-cuda", "sm_35", "+ptx60", "nvvm.cubin"));
       });
 }
+} // namespace test
 } // namespace mlir
 #endif

mlir/test/lib/Transforms/TestConvertGPUKernelToHsaco.cpp

 //===- TestConvertGPUKernelToHsaco.cpp - Test gpu kernel hsaco lowering ---===//
 //
 // 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/Conversion/GPUCommon/GPUCommonPass.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Target/ROCDLIR.h"
 #include "llvm/Support/TargetSelect.h"
+
 using namespace mlir;
 
 #if MLIR_ROCM_CONVERSIONS_ENABLED
 static OwnedBlob compileIsaToHsacoForTesting(const std::string &, Location,
                                              StringRef) {
   const char data[] = "HSACO";
   return std::make_unique<std::vector<char>>(data, data + sizeof(data) - 1);
 }
 
 namespace mlir {
+namespace test {
 void registerTestConvertGPUKernelToHsacoPass() {
   PassPipelineRegistration<>(
       "test-kernel-to-hsaco",
       "Convert all kernel functions to ROCm hsaco blobs",
       [](OpPassManager &pm) {
         // Initialize LLVM AMDGPU backend.
         LLVMInitializeAMDGPUTarget();
         LLVMInitializeAMDGPUTargetInfo();
         LLVMInitializeAMDGPUTargetMC();
         LLVMInitializeAMDGPUAsmPrinter();
 
         pm.addPass(createConvertGPUKernelToBlobPass(
             translateModuleToROCDLIR, compileIsaToHsacoForTesting,
             "amdgcn-amd-amdhsa", "gfx900", "-code-object-v3", "rocdl.hsaco"));
       });
 }
+} // namespace test
 } // namespace mlir
 #endif

mlir/test/lib/Transforms/TestDominance.cpp

void runOnFunction() override {
     llvm::errs() << "--- PostDominanceInfo ---\n";
     dominanceTest.printDominance(getAnalysis<PostDominanceInfo>());
   }
 };
 
 } // end anonymous namespace
 
 namespace mlir {
+namespace test {
 void registerTestDominancePass() {
   PassRegistration<TestDominancePass>(
       "test-print-dominance",
       "Print the dominance information for multiple regions.");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestDynamicPipeline.cpp

public:
   Option<std::string> pipeline{
       *this, "dynamic-pipeline",
       llvm::cl::desc("The pipeline description that "
                      "will run on the filtered function.")};
   ListOption<std::string> opNames{
       *this, "op-name", llvm::cl::MiscFlags::CommaSeparated,
       llvm::cl::desc("List of function name to apply the pipeline to")};
 };
-} // end namespace
+} // namespace
 
 namespace mlir {
+namespace test {
 void registerTestDynamicPipelinePass() {
   PassRegistration<TestDynamicPipelinePass>(
       "test-dynamic-pipeline", "Tests the dynamic pipeline feature by applying "
                                "a pipeline on a selected set of functions");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestExpandMemRefReshape.cpp

 
 void TestExpandMemRefReshapePass::runOnFunction() {
   OwningRewritePatternList patterns;
   populateExpandMemRefReshapePattern(patterns, &getContext());
   applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 
 namespace mlir {
+namespace test {
 void registerTestExpandMemRefReshapePass() {
   PassRegistration<TestExpandMemRefReshapePass> pass(
       "test-expand-memref-reshape", "Test expanding memref reshape");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestExpandTanh.cpp

 
 void TestExpandTanhPass::runOnFunction() {
   OwningRewritePatternList patterns;
   populateExpandTanhPattern(patterns, &getContext());
   applyPatternsAndFoldGreedily(getOperation(), std::move(patterns));
 }
 
 namespace mlir {
+namespace test {
 void registerTestExpandTanhPass() {
   PassRegistration<TestExpandTanhPass> pass("test-expand-tanh",
                                             "Test expanding tanh");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestFinalizingBufferize.cpp

 template <bool allowMemrefFunctionResults>
 struct TestFinalizingBufferizePass
     : mlir::PassWrapper<TestFinalizingBufferizePass<allowMemrefFunctionResults>,
                         OperationPass<ModuleOp>> {
 
   /// Converts tensor based test operations to buffer based ones using
   /// bufferize.
   class TensorBasedOpConverter
-      : public BufferizeOpConversionPattern<mlir::TensorBasedOp> {
+      : public BufferizeOpConversionPattern<test::TensorBasedOp> {
   public:
     using BufferizeOpConversionPattern<
-        mlir::TensorBasedOp>::BufferizeOpConversionPattern;
+        test::TensorBasedOp>::BufferizeOpConversionPattern;
 
     LogicalResult
-    matchAndRewrite(mlir::TensorBasedOp op, ArrayRef<Value> operands,
+    matchAndRewrite(test::TensorBasedOp op, ArrayRef<Value> operands,
                     ConversionPatternRewriter &rewriter) const final {
-      mlir::TensorBasedOpAdaptor adaptor(
+      mlir::test::TensorBasedOpAdaptor adaptor(
           operands, op.getOperation()->getAttrDictionary());
 
       // The input needs to be turned into a buffer first. Until then, bail out.
       if (!adaptor.input().getType().isa<MemRefType>())
         return failure();
 
       Location loc = op.getLoc();
 
       // Update the result type to a memref type.
       auto type = op.getResult().getType().cast<ShapedType>();
       if (!type.hasStaticShape())
         return rewriter.notifyMatchFailure(
             op, "dynamic shapes not currently supported");
       auto memrefType = MemRefType::get(type.getShape(), type.getElementType());
       Value newOutputBuffer = rewriter.create<AllocOp>(loc, memrefType);
 
       // Generate a new test operation that works on buffers.
-      rewriter.create<mlir::BufferBasedOp>(loc,
+      rewriter.create<mlir::test::BufferBasedOp>(loc,
                                                  /*input=*/adaptor.input(),
                                                  /*output=*/newOutputBuffer);
 
       // Replace the results of the old op with the new output buffers.
       rewriter.replaceOp(op, newOutputBuffer);
       return success();
     }
   };
 
   void getDependentDialects(DialectRegistry &registry) const override {
-    registry.insert<TestDialect>();
+    registry.insert<test::TestDialect>();
   }
 
   void runOnOperation() override {
     MLIRContext &context = this->getContext();
     ConversionTarget target(context);
     BufferizeTypeConverter converter;
 
     // Mark all Standard operations legal.
     target.addLegalDialect<StandardOpsDialect>();
-    target.addLegalOp<MakeTupleOp>();
-    target.addLegalOp<GetTupleElementOp>();
+    target.addLegalOp<test::MakeTupleOp>();
+    target.addLegalOp<test::GetTupleElementOp>();
     target.addLegalOp<ModuleOp>();
     target.addLegalOp<ModuleTerminatorOp>();
 
     // Mark all Test operations illegal as long as they work on tensors.
     auto isLegalOperation = [&](Operation *op) {
       return converter.isLegal(op);
     };
-    target.addDynamicallyLegalDialect<TestDialect>(isLegalOperation);
+    target.addDynamicallyLegalDialect<test::TestDialect>(isLegalOperation);
 
     // Mark Standard Return operations illegal as long as one operand is tensor.
     target.addDynamicallyLegalOp<mlir::ReturnOp>([&](mlir::ReturnOp returnOp) {
       return converter.isLegal(returnOp.getOperandTypes());
     });
 
     // Mark Standard Call Operation illegal as long as it operates on tensor.
     target.addDynamicallyLegalOp<mlir::CallOp>(
void runOnOperation() override {
     converter.addArgumentMaterialization(
         [](OpBuilder &builder, TupleType resultType, ValueRange inputs,
            Location loc) -> Optional<Value> {
           if (inputs.size() == 1)
             return llvm::None;
           TypeRange TypeRange = inputs.getTypes();
           SmallVector<Type, 2> types(TypeRange.begin(), TypeRange.end());
           TupleType tuple = TupleType::get(types, builder.getContext());
-          mlir::Value value = builder.create<MakeTupleOp>(loc, tuple, inputs);
+          mlir::Value value =
+              builder.create<test::MakeTupleOp>(loc, tuple, inputs);
           return value;
         });
 
     converter.addDecomposeValueConversion([](OpBuilder &builder, Location loc,
                                              TupleType resultType, Value value,
                                              SmallVectorImpl<Value> &values) {
       for (unsigned i = 0, e = resultType.size(); i < e; ++i) {
-        Value res = builder.create<GetTupleElementOp>(
+        Value res = builder.create<test::GetTupleElementOp>(
             loc, resultType.getType(i), value, builder.getI32IntegerAttr(i));
         values.push_back(res);
       }
       return success();
     });
 
     OwningRewritePatternList patterns;
-    populateWithBufferizeOpConversionPatterns<mlir::ReturnOp, mlir::ReturnOp,
-                                              mlir::CopyOp>(
+    populateWithBufferizeOpConversionPatterns<ReturnOp, ReturnOp, test::CopyOp>(
         &context, converter, patterns);
     patterns.insert<TensorBasedOpConverter>(&context, converter);
 
     if (failed(applyFullConversion(this->getOperation(), target,
                                    std::move(patterns))))
       this->signalPassFailure();
   };
 };
 } // end anonymous namespace
 
 namespace mlir {
+namespace test {
 void registerTestFinalizingBufferizePass() {
   PassRegistration<
       TestFinalizingBufferizePass</*allowMemrefFunctionResults=*/false>>(
       "test-finalizing-bufferize", "Tests finalizing bufferize conversions");
 }
 
 void registerTestPreparationPassWithAllowedMemrefResults() {
   PassRegistration<
       TestFinalizingBufferizePass</*allowMemrefFunctionResults=*/true>>(
       "test-finalizing-bufferize-with-allowed-memref-results",
       "Tests finalizing buffierize conversions, allowing functions to have "
       "memref typed results.");
 }
-} // end namespace mlir
+} // namespace test
+} // namespace mlir

mlir/test/lib/Transforms/TestGpuParallelLoopMapping.cpp

class TestGpuGreedyParallelLoopMappingPass
     : public PassWrapper<TestGpuGreedyParallelLoopMappingPass,
                          OperationPass<FuncOp>> {
   void runOnOperation() override {
     Operation *op = getOperation();
     for (Region &region : op->getRegions())
       greedilyMapParallelSCFToGPU(region);
   }
 };
-} // end namespace
+} // namespace
 
 namespace mlir {
+namespace test {
 void registerTestGpuParallelLoopMappingPass() {
   PassRegistration<TestGpuGreedyParallelLoopMappingPass> registration(
       "test-gpu-greedy-parallel-loop-mapping",
       "Greedily maps all parallel loops to gpu hardware ids.");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestInlining.cpp

 #include "mlir/IR/BlockAndValueMapping.h"
 #include "mlir/IR/Function.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;
 
 namespace {
 struct Inliner : public PassWrapper<Inliner, FunctionPass> {
   void runOnFunction() override {
     auto function = getFunction();
 
     // Collect each of the direct function calls within the module.
     SmallVector<CallIndirectOp, 16> callers;
for (auto caller : callers) {
       if (callee.use_empty())
         callee.erase();
     }
   }
 };
 } // end anonymous namespace
 
 namespace mlir {
+namespace test {
 void registerInliner() {
   PassRegistration<Inliner>("test-inline", "Test inlining region calls");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLinalgCodegenStrategy.cpp

strategy.tileIf<MatmulOp>(!tileSizes.empty(), tilingOptions)
               .setVectorTransferSplit(vectorTransferSplit))
       .setVectorTransferToSCFOptions(
           VectorTransferToSCFOptions().setUnroll(unrollVectorTransfers));
 
   strategy.transform(getFunction());
 }
 
 namespace mlir {
+namespace test {
 void registerTestLinalgCodegenStrategy() {
   PassRegistration<TestLinalgCodegenStrategy> testLinalgCodegenStrategyPass(
       "test-linalg-codegen-strategy", "Test Linalg Codegen Strategy.");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLinalgFusionTransforms.cpp

while (succeeded(fuseLinalgOpsGreedily(getFunction()))) {
       if (failed(res))
         this->signalPassFailure();
     }
   }
 };
 } // namespace
 
 namespace mlir {
+namespace test {
 void registerTestLinalgFusionTransforms() {
   PassRegistration<TestLinalgFusionTransforms> testFusionTransformsPass(
       "test-linalg-fusion-transform-patterns",
       "Test Linalg fusion transformation patterns by applying them greedily.");
 }
 void registerTestLinalgGreedyFusion() {
   PassRegistration<TestLinalgGreedyFusion> testFusionTransformsPass(
       "test-linalg-greedy-fusion",
       "Test Linalg fusion by applying a greedy test transformation.");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLinalgHoisting.cpp

void TestLinalgHoisting::runOnFunction() {
   }
   if (testHoistRedundantTransfers) {
     hoistRedundantVectorTransfers(getFunction());
     return;
   }
 }
 
 namespace mlir {
+namespace test {
 void registerTestLinalgHoisting() {
   PassRegistration<TestLinalgHoisting> testTestLinalgHoistingPass(
       "test-linalg-hoisting", "Test Linalg hoisting functions.");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLinalgTransforms.cpp

if (testVectorTransferForwardingPatterns)
     return applyVectorTransferForwardingPatterns(getFunction());
   if (testGenericToVectorPattern)
     return applyContractionToVectorPatterns(getFunction());
   if (testAffineMinSCFCanonicalizationPatterns)
     return applyAffineMinSCFCanonicalizationPatterns(getFunction());
 }
 
 namespace mlir {
+namespace test {
 void registerTestLinalgTransforms() {
   PassRegistration<TestLinalgTransforms> testTransformPatternsPass(
       "test-linalg-transform-patterns",
       "Test Linalg transformation patterns by applying them greedily.");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLiveness.cpp

void runOnFunction() override {
     llvm::errs() << "Testing : " << getFunction().getName() << "\n";
     getAnalysis<Liveness>().print(llvm::errs());
   }
 };
 
 } // end anonymous namespace
 
 namespace mlir {
+namespace test {
 void registerTestLivenessPass() {
   PassRegistration<TestLivenessPass>(
       "test-print-liveness",
       "Print the contents of a constructed liveness information.");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLoopFusion.cpp

void TestLoopFusion::runOnFunction() {
   // Run tests on all combinations of src/dst loop nests in 'depthToLoops'.
   if (clTestDependenceCheck)
     iterateLoops(depthToLoops, testDependenceCheck);
   if (clTestSliceComputation)
     iterateLoops(depthToLoops, testSliceComputation);
 }
 
 namespace mlir {
+namespace test {
 void registerTestLoopFusion() {
   PassRegistration<TestLoopFusion>("test-loop-fusion",
                                    "Tests loop fusion utility functions.");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLoopMapping.cpp

void runOnFunction() override {
     func.walk([&processorIds, &numProcessors](scf::ForOp op) {
       // Ignore nested loops.
       if (op.getParentRegion()->getParentOfType<scf::ForOp>())
         return;
       mapLoopToProcessorIds(op, processorIds, numProcessors);
     });
   }
 };
-} // end namespace
+} // namespace
 
 namespace mlir {
+namespace test {
 void registerTestLoopMappingPass() {
   PassRegistration<TestLoopMappingPass>(
       "test-mapping-to-processing-elements",
       "test mapping a single loop on a virtual processor grid");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLoopParametricTiling.cpp

void runOnFunction() override {
     });
   }
 
   ListOption<int64_t> sizes{
       *this, "test-outer-loop-sizes", llvm::cl::MiscFlags::CommaSeparated,
       llvm::cl::desc(
           "fixed number of iterations that the outer loops should have")};
 };
-} // end namespace
+} // namespace
 
 namespace mlir {
+namespace test {
 void registerSimpleParametricTilingPass() {
   PassRegistration<SimpleParametricLoopTilingPass>(
       "test-extract-fixed-outer-loops",
       "test application of parametric tiling to the outer loops so that the "
       "ranges of outer loops become static");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestLoopUnrolling.cpp

Option<uint64_t> unrollFactor{*this, "unroll-factor",
                                 llvm::cl::desc("Loop unroll factor."),
                                 llvm::cl::init(1)};
   Option<bool> unrollUpToFactor{*this, "unroll-up-to-factor",
                                 llvm::cl::desc("Loop unroll up to factor."),
                                 llvm::cl::init(false)};
   Option<unsigned> loopDepth{*this, "loop-depth", llvm::cl::desc("Loop depth."),
                              llvm::cl::init(0)};
 };
-} // end namespace
+} // namespace
 
 namespace mlir {
+namespace test {
 void registerTestLoopUnrollingPass() {
   PassRegistration<TestLoopUnrollingPass>(
       "test-loop-unrolling", "Tests loop unrolling transformation");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestMemRefBoundCheck.cpp

TypeSwitch<Operation *>(opInst)
         .Case<AffineReadOpInterface, AffineWriteOpInterface>(
             [](auto op) { boundCheckLoadOrStoreOp(op); });
 
     // TODO: do this for DMA ops as well.
   });
 }
 
 namespace mlir {
+namespace test {
 void registerMemRefBoundCheck() {
   PassRegistration<TestMemRefBoundCheck>(
       "test-memref-bound-check", "Check memref access bounds in a Function");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestMemRefDependenceCheck.cpp

getFunction().walk([&](Operation *op) {
     if (isa<AffineLoadOp, AffineStoreOp>(op))
       loadsAndStores.push_back(op);
   });
 
   checkDependences(loadsAndStores);
 }
 
 namespace mlir {
+namespace test {
 void registerTestMemRefDependenceCheck() {
   PassRegistration<TestMemRefDependenceCheck> pass(
       "test-memref-dependence-check",
       "Checks dependences between all pairs of memref accesses.");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestMemRefStrideCalculation.cpp

llvm::interleaveComma(strides, llvm::outs(), [&](int64_t v) {
         llvm::outs() << v;
     });
     llvm::outs() << "\n";
   });
   llvm::outs().flush();
 }
 
 namespace mlir {
+namespace test {
 void registerTestMemRefStrideCalculation() {
   PassRegistration<TestMemRefStrideCalculation> pass(
       "test-memref-stride-calculation", "Test operation constant folding");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestOpaqueLoc.cpp

void runOnOperation() override {
 
     getOperation().walk([&](Operation *op) { op->emitOpError(); });
   }
 };
 
 } // end anonymous namespace
 
 namespace mlir {
+namespace test {
 void registerTestOpaqueLoc() {
   PassRegistration<TestOpaqueLoc> pass(
       "test-opaque-loc", "Changes all leaf locations to opaque locations");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestSCFUtils.cpp

func.walk([&](scf::IfOp ifOp) {
       auto strCount = std::to_string(count++);
       FuncOp thenFn, elseFn;
       OpBuilder b(ifOp);
       outlineIfOp(b, ifOp, &thenFn, std::string("outlined_then") + strCount,
                   &elseFn, std::string("outlined_else") + strCount);
     });
   }
 };
-} // end namespace
+} // namespace
 
 namespace mlir {
+namespace test {
 void registerTestSCFUtilsPass() {
   PassRegistration<TestSCFForUtilsPass>("test-scf-for-utils",
                                         "test scf.for utils");
   PassRegistration<TestSCFIfUtilsPass>("test-scf-if-utils",
                                        "test scf.if utils");
 }
+} // namespace test
 } // namespace mlir

mlir/test/lib/Transforms/TestVectorTransforms.cpp

void runOnFunction() override {
     patterns.insert<VectorTransferFullPartialRewriter>(ctx, options);
     applyPatternsAndFoldGreedily(getFunction(), std::move(patterns));
   }
 };
 
 } // end anonymous namespace
 
 namespace mlir {
+namespace test {
 void registerTestVectorConversions() {
   PassRegistration<TestVectorToVectorConversion> vectorToVectorPass(
       "test-vector-to-vector-conversion",
       "Test conversion patterns between ops in the vector dialect");
 
   PassRegistration<TestVectorSlicesConversion> slicesPass(
       "test-vector-slices-conversion",
       "Test conversion patterns that lower slices ops in the vector dialect");
void registerTestVectorConversions() {
   PassRegistration<TestVectorDistributePatterns> distributePass(
       "test-vector-distribute-patterns",
       "Test conversion patterns to distribute vector ops in the vector "
       "dialect");
   PassRegistration<TestVectorToLoopPatterns> vectorToForLoop(
       "test-vector-to-forloop",
       "Test conversion patterns to break up a vector op into a for loop");
 }
+} // namespace test
 } // namespace mlir

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

 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/ToolOutputFile.h"
 
 using namespace llvm;
 using namespace mlir;
 
-namespace mlir {
 // Defined in the test directory, no public header.
-void registerConvertCallOpPass();
+namespace mlir {
 void registerConvertToTargetEnvPass();
-void registerInliner();
-void registerMemRefBoundCheck();
 void registerPassManagerTestPass();
-void registerPatternsTestPass();
 void registerPrintOpAvailabilityPass();
 void registerSideEffectTestPasses();
-void registerSimpleParametricTilingPass();
 void registerSliceAnalysisTestPass();
 void registerSymbolTestPasses();
 void registerTestAffineDataCopyPass();
-void registerTestAffineLoopParametricTilingPass();
 void registerTestAffineLoopUnswitchingPass();
 void registerTestAllReduceLoweringPass();
+void registerTestFunc();
+void registerTestGpuMemoryPromotionPass();
+void registerTestLoopPermutationPass();
+void registerTestMatchers();
+void registerTestPrintDefUsePass();
+void registerTestPrintNestingPass();
+void registerTestReducer();
+void registerTestSpirvEntryPointABIPass();
+void registerTestSpirvModuleCombinerPass();
+void registerTestTraitsPass();
+void registerVectorizerTestPass();
+
+namespace test {
+void registerConvertCallOpPass();
+void registerInliner();
+void registerMemRefBoundCheck();
+void registerPatternsTestPass();
+void registerSimpleParametricTilingPass();
+void registerTestAffineLoopParametricTilingPass();
 void registerTestCallGraphPass();
 void registerTestConstantFold();
 void registerTestConvVectorization();
 void registerTestConvertGPUKernelToCubinPass();
 void registerTestConvertGPUKernelToHsacoPass();
-void registerTestDominancePass();
 void registerTestDialect(DialectRegistry &);
+void registerTestDominancePass();
 void registerTestDynamicPipelinePass();
 void registerTestExpandMemRefReshapePass();
 void registerTestExpandTanhPass();
 void registerTestFinalizingBufferizePass();
-void registerTestFunc();
-void registerTestGpuMemoryPromotionPass();
 void registerTestGpuParallelLoopMappingPass();
 void registerTestInterfaces();
 void registerTestLinalgCodegenStrategy();
 void registerTestLinalgFusionTransforms();
 void registerTestLinalgGreedyFusion();
 void registerTestLinalgHoisting();
 void registerTestLinalgTransforms();
 void registerTestLivenessPass();
 void registerTestLoopFusion();
 void registerTestLoopMappingPass();
-void registerTestLoopPermutationPass();
 void registerTestLoopUnrollingPass();
-void registerTestMatchers();
 void registerTestMemRefDependenceCheck();
 void registerTestMemRefStrideCalculation();
 void registerTestOpaqueLoc();
 void registerTestPreparationPassWithAllowedMemrefResults();
-void registerTestPrintDefUsePass();
-void registerTestPrintNestingPass();
 void registerTestRecursiveTypesPass();
-void registerTestReducer();
-void registerTestSpirvEntryPointABIPass();
-void registerTestSpirvModuleCombinerPass();
 void registerTestSCFUtilsPass();
-void registerTestTraitsPass();
 void registerTestVectorConversions();
-void registerVectorizerTestPass();
+} // namespace test
 } // namespace mlir
 
 #ifdef MLIR_INCLUDE_TESTS
 void registerTestPasses() {
-  registerConvertCallOpPass();
   registerConvertToTargetEnvPass();
-  registerInliner();
-  registerMemRefBoundCheck();
   registerPassManagerTestPass();
-  registerPatternsTestPass();
   registerPrintOpAvailabilityPass();
   registerSideEffectTestPasses();
-  registerSimpleParametricTilingPass();
   registerSliceAnalysisTestPass();
   registerSymbolTestPasses();
   registerTestAffineDataCopyPass();
-  registerTestAllReduceLoweringPass();
   registerTestAffineLoopUnswitchingPass();
-  registerTestLoopPermutationPass();
-  registerTestCallGraphPass();
-  registerTestConvVectorization();
-  registerTestConstantFold();
-#if MLIR_CUDA_CONVERSIONS_ENABLED
-  registerTestConvertGPUKernelToCubinPass();
-#endif
-#if MLIR_ROCM_CONVERSIONS_ENABLED
-  registerTestConvertGPUKernelToHsacoPass();
-#endif
-  registerTestAffineLoopParametricTilingPass();
-  registerTestDominancePass();
-  registerTestDynamicPipelinePass();
-  registerTestFinalizingBufferizePass();
+  registerTestAllReduceLoweringPass();
   registerTestFunc();
-  registerTestExpandTanhPass();
-  registerTestExpandMemRefReshapePass();
   registerTestGpuMemoryPromotionPass();
-  registerTestInterfaces();
-  registerTestLinalgCodegenStrategy();
-  registerTestLinalgFusionTransforms();
-  registerTestLinalgGreedyFusion();
-  registerTestLinalgHoisting();
-  registerTestLinalgTransforms();
-  registerTestLivenessPass();
-  registerTestLoopFusion();
-  registerTestLoopMappingPass();
-  registerTestLoopUnrollingPass();
+  registerTestLoopPermutationPass();
   registerTestMatchers();
-  registerTestMemRefDependenceCheck();
-  registerTestMemRefStrideCalculation();
-  registerTestOpaqueLoc();
-  registerTestPreparationPassWithAllowedMemrefResults();
   registerTestPrintDefUsePass();
   registerTestPrintNestingPass();
-  registerTestRecursiveTypesPass();
   registerTestReducer();
-  registerTestGpuParallelLoopMappingPass();
   registerTestSpirvEntryPointABIPass();
   registerTestSpirvModuleCombinerPass();
-  registerTestSCFUtilsPass();
   registerTestTraitsPass();
-  registerTestVectorConversions();
   registerVectorizerTestPass();
+
+  test::registerConvertCallOpPass();
+  test::registerInliner();
+  test::registerMemRefBoundCheck();
+  test::registerPatternsTestPass();
+  test::registerSimpleParametricTilingPass();
+  test::registerTestAffineLoopParametricTilingPass();
+  test::registerTestCallGraphPass();
+  test::registerTestConstantFold();
+#if MLIR_CUDA_CONVERSIONS_ENABLED
+  test::registerTestConvertGPUKernelToCubinPass();
+#endif
+#if MLIR_ROCM_CONVERSIONS_ENABLED
+  test::registerTestConvertGPUKernelToHsacoPass();
+#endif
+  test::registerTestConvVectorization();
+  test::registerTestDominancePass();
+  test::registerTestDynamicPipelinePass();
+  test::registerTestExpandMemRefReshapePass();
+  test::registerTestExpandTanhPass();
+  test::registerTestFinalizingBufferizePass();
+  test::registerTestGpuParallelLoopMappingPass();
+  test::registerTestInterfaces();
+  test::registerTestLinalgCodegenStrategy();
+  test::registerTestLinalgFusionTransforms();
+  test::registerTestLinalgGreedyFusion();
+  test::registerTestLinalgHoisting();
+  test::registerTestLinalgTransforms();
+  test::registerTestLivenessPass();
+  test::registerTestLoopFusion();
+  test::registerTestLoopMappingPass();
+  test::registerTestLoopUnrollingPass();
+  test::registerTestMemRefDependenceCheck();
+  test::registerTestMemRefStrideCalculation();
+  test::registerTestOpaqueLoc();
+  test::registerTestPreparationPassWithAllowedMemrefResults();
+  test::registerTestRecursiveTypesPass();
+  test::registerTestSCFUtilsPass();
+  test::registerTestVectorConversions();
 }
 #endif
 
 int main(int argc, char **argv) {
   registerAllPasses();
 #ifdef MLIR_INCLUDE_TESTS
   registerTestPasses();
 #endif
   DialectRegistry registry;
   registerAllDialects(registry);
 #ifdef MLIR_INCLUDE_TESTS
-  registerTestDialect(registry);
+  test::registerTestDialect(registry);
 #endif
   return failed(MlirOptMain(argc, argv, "MLIR modular optimizer driver\n",
                             registry,
                             /*preloadDialectsInContext=*/false));
 }